openttd-mini: comparison industry

equal deleted inserted replaced

-:67f5a8764d4e
+:d9683fb55b45
 	}
 	return IT_INVALID;  //we have not found equivalent, whatever the reason
 }
+/**
+* Accessor for array _industry_specs.
+* This will ensure at once : proper access and
+* not allowing modifications of it.
+* @param thistype of industry (which is the index in _industry_spec)
+* @pre thistype < IT_END
+**/
+static const IndustrySpec *GetIndustrySpecification(IndustryType thistype)
+{
+	assert(thistype < IT_END);
+	return &_industry_specs[thistype];
+}
 static void IndustryDrawSugarMine(const TileInfo *ti)
 {
 	const DrawIndustrySpec1Struct *d;
 	uint32 image;
 	IndustryDrawCoalPlantSparks,
 };
 static void DrawTile_Industry(TileInfo *ti)
 {
-	const Industry* ind;
+	const Industry *ind;
 	const DrawBuildingsTileStruct *dits;
 	byte z;
 	uint32 image, ormod;
 	/* Pointer to industry */
 		int proc = dits->draw_proc - 1;
 		if (proc >= 0) _industry_draw_tile_procs[proc](ti);
 	}
 }
-static uint GetSlopeZ_Industry(const TileInfo* ti)
+static uint GetSlopeZ_Industry(const TileInfo *ti)
 {
 	return ti->z + (ti->tileh == SLOPE_FLAT ? 0 : TILE_HEIGHT);
 }
 static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)
 	if (a != CT_INVALID) ac[a] = 8;
 }
 static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)
 {
-	const Industry* i = GetIndustryByTile(tile);
+	const Industry *i = GetIndustryByTile(tile);
 	td->owner = i->owner;
 	td->str = STR_4802_COAL_MINE + i->type;
 	if (!IsIndustryCompleted(tile)) {
 		SetDParamX(td->dparam, 0, td->str);
 	}
 }
 static int32 ClearTile_Industry(TileIndex tile, byte flags)
 {
-	Industry* i = GetIndustryByTile(tile);
+	Industry *i = GetIndustryByTile(tile);
 	/*	* water can destroy industries
 			* in editor you can bulldoze industries
 			* with magic_bulldozer cheat you can destroy industries
 			* (area around OILRIG is water, so water shouldn't flood it
 	5, 5, 5, 5, 5,
 };
 static void TransportIndustryGoods(TileIndex tile)
 {
-	Industry* i = GetIndustryByTile(tile);
+	Industry *i = GetIndustryByTile(tile);
 	uint cw, am;
 	cw = min(i->cargo_waiting[0], 255);
 	if (cw > _industry_min_cargo[i->type]/* && i->produced_cargo[0] != 0xFF*/) {
 		i->cargo_waiting[0] -= cw;
 		CreateEffectVehicleAbove(TileX(tile) * TILE_SIZE + 6, TileY(tile) * TILE_SIZE + 6, 43, EV_SMOKE);
 		break;
 	case 143: {
-			Industry* i = GetIndustryByTile(tile);
+			Industry *i = GetIndustryByTile(tile);
 			if (i->was_cargo_delivered) {
 				i->was_cargo_delivered = false;
 				SetIndustryAnimationLoop(tile, 0);
 				AddAnimatedTile(tile);
 			}
 	return 0;
 }
 static void GetProducedCargo_Industry(TileIndex tile, CargoID *b)
 {
-	const Industry* i = GetIndustryByTile(tile);
+	const Industry *i = GetIndustryByTile(tile);
 	b[0] = i->produced_cargo[0];
 	b[1] = i->produced_cargo[1];
 }
 	SetupFarmFieldFence(tile - TileDiffXY(0, 1), size_x, type, AXIS_X);
 	SetupFarmFieldFence(tile + TileDiffXY(size_x - 1, 0), size_y, type, AXIS_Y);
 	SetupFarmFieldFence(tile + TileDiffXY(0, size_y - 1), size_x, type, AXIS_X);
 }
-static void MaybePlantFarmField(const Industry* i)
+static void MaybePlantFarmField(const Industry *i)
 {
 	if (CHANCE16(1, 8)) {
 		int x = i->width  / 2 + Random() % 31 - 16;
 		int y = i->height / 2 + Random() % 31 - 16;
 		TileIndex tile = TileAddWrap(i->xy, x, y);
 	}
 	return true;
 }
-static const Town* CheckMultipleIndustryInTown(TileIndex tile, int type)
+static const Town *CheckMultipleIndustryInTown(TileIndex tile, int type)
 {
-	const Town* t;
+	const Town *t;
-	const Industry* i;
+	const Industry *i;
 	t = ClosestTownFromTile(tile, (uint)-1);
 	if (_patches.multiple_industry_per_town) return t;
 	16, 16, 16, 16, 16, 16, 16, 16,
 	16, 16, 16, 16, 16, 16, 16, 16,
 	16, 16, 16, 16, 16, 16, 16,
 };
-static bool CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileTable* it, int type, const Town* t)
+static bool CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileTable *it, int type, const Town *t)
 {
 	_error_message = STR_0239_SITE_UNSUITABLE;
 	do {
 		TileIndex cur_tile = tile + ToTileIndexDiff(it->ti);
 	return true;
 }
 static bool CheckIfTooCloseToIndustry(TileIndex tile, int type)
 {
-	const IndustrySpec* spec = &_industry_spec[type];
+	const IndustrySpec *spec = GetIndustrySpecification(type);
-	const Industry* i;
+	const Industry *i;
 	// accepting industries won't be close, not even with patch
 	if (_patches.same_industry_close && spec->accepts_cargo[0] == CT_INVALID)
 		return true;
 	/* Check if we can add a block to the pool */
 	return AddBlockToPool(&_industry_pool) ? AllocateIndustry() : NULL;
 }
-static void DoCreateNewIndustry(Industry* i, TileIndex tile, int type, const IndustryTileTable* it, const Town* t, byte owner)
+static void DoCreateNewIndustry(Industry *i, TileIndex tile, int type, const IndustryTileTable *it, const Town *t, byte owner)
 {
-	const IndustrySpec *spec;
+	const IndustrySpec *spec = GetIndustrySpecification(type);
 	uint32 r;
 	int j;
 	i->xy = tile;
 	i->width = i->height = 0;
 	i->type = type;
-	spec = &_industry_spec[type];
 	i->produced_cargo[0] = spec->produced_cargo[0];
 	i->produced_cargo[1] = spec->produced_cargo[1];
 	i->accepts_cargo[0] = spec->accepts_cargo[0];
 	i->accepts_cargo[1] = spec->accepts_cargo[1];
 * @param p1 industry type @see build_industry.h and @see industry.h
 * @param p2 unused
 */
 int32 CmdBuildIndustry(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	const Town* t;
+	const Town *t;
 	Industry *i;
 	int num;
 	const IndustryTileTable * const *itt;
 	const IndustryTileTable *it;
 	const IndustrySpec *spec;
 	if (!CheckSuitableIndustryPos(tile)) return CMD_ERROR;
 	/* Check if the to-be built/founded industry is available for this climate.
 	 * Unfortunately we have no easy way of checking, except for looping the table */
 	{
-		const byte* i;
+		const byte *i;
 		bool found = false;
 		for (i = &_build_industry_types[_opt_ptr->landscape][0]; i != endof(_build_industry_types[_opt_ptr->landscape]); i++) {
 			if (*i == p1) {
 				found = true;
 			}
 		}
 		if (!found) return CMD_ERROR;
 	}
-	spec = &_industry_spec[p1];
+	spec = GetIndustrySpecification(p1);
 	/* If the patch for raw-material industries is not on, you cannot build raw-material industries.
 	 * Raw material industries are industries that do not accept cargo (at least for now)
 	 * Exclude the lumber mill (only "raw" industry that can be built) */
 	if (!_patches.build_rawmaterial_ind &&
 			spec->accepts_cargo[0] == CT_INVALID &&
 }
 Industry *CreateNewIndustry(TileIndex tile, IndustryType type)
 {
-	const Town* t;
+	const Town *t;
 	const IndustryTileTable *it;
 	Industry *i;
 	const IndustrySpec *spec;
 	if (!CheckSuitableIndustryPos(tile)) return NULL;
-	spec = &_industry_spec[type];
+	spec =  GetIndustrySpecification(type);
 	if (!_check_new_industry_procs[spec->check_proc](tile, type)) return NULL;
 	t = CheckMultipleIndustryInTown(tile, type);
 	if (t == NULL) return NULL;
 				}
 				percent = new * 100 / old - 100;
 				i->production_rate[j] = new;
-				if (new >= _industry_spec[i->type].production_rate[j] / 4)
+				if (new >= GetIndustrySpecification(i->type)->production_rate[j] / 4)
 					closeit = false;
 				mag = abs(percent);
 				if (mag >= 10) {
 					SetDParam(2, mag);

changeset 3662	d9683fb55b45
parent 3661	67f5a8764d4e
child 3663	548dfb4ad4cc