openttd-ottdgrfs: comparison src/industry

equal deleted inserted replaced

-:1337d6c9b97b
+:cabfaa4a0295
 #include "cargotype.h"
 #include "newgrf_commons.h"
 #include "newgrf_industries.h"
 #include "newgrf_industrytiles.h"
 #include "newgrf_callbacks.h"
+#include "misc/autoptr.hpp"
 void ShowIndustryViewWindow(int industry);
 void BuildOilRig(TileIndex tile);
 static byte _industry_sound_ctr;
 {
 	assert(type < INVALID_INDUSTRYTYPE);
 	_industry_specs[type].appear_creation[_opt.landscape] = 0;
 }
-/**
+DEFINE_OLD_POOL_GENERIC(Industry, Industry)
-* Called if a new block is added to the industry-pool
-*/
-static void IndustryPoolNewBlock(uint start_item)
-{
-	Industry *i;
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
-	 * TODO - This is just a temporary stage, this will be removed. */
-	for (i = GetIndustry(start_item); i != NULL; i = (i->index + 1U < GetIndustryPoolSize()) ? GetIndustry(i->index + 1U) : NULL) i->index = start_item++;
-}
-DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)
 /**
 * Retrieve the type for this industry.  Although it is accessed by a tile,
 * it will return the general type of industry, and not the sprite index
 * as would do GetIndustryGfx.
 IndustryType GetIndustryType(TileIndex tile)
 {
 	assert(IsTileType(tile, MP_INDUSTRY));
 	const Industry *ind = GetIndustryByTile(tile);
-	return IsValidIndustry(ind) ? ind->type : (IndustryType)IT_INVALID;
+	return ind->IsValid() ? ind->type : (IndustryType)IT_INVALID;
 }
 /**
 * Accessor for array _industry_specs.
 * This will ensure at once : proper access and
 /**
 * Accessor for array _industry_tile_specs.
 * This will ensure at once : proper access and
 * not allowing modifications of it.
 * @param gfx of industrytile (which is the index in _industry_tile_specs)
+* @param full_check (default to true) verify if an override is available.
+*  If so, use it instead of the gfx provided.
 * @pre gfx < INVALID_INDUSTRYTILE
 * @return a pointer to the corresponding industrytile spec
 **/
-const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)
+const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx, bool full_check)
 {
 	assert(gfx < INVALID_INDUSTRYTILE);
-	return &_industry_tile_specs[gfx];
+	const IndustryTileSpec *its = &_industry_tile_specs[gfx];
-}
+	if (full_check && its->grf_prop.override != INVALID_INDUSTRYTILE) {
+		its = &_industry_tile_specs[its->grf_prop.override];
-void DestroyIndustry(Industry *i)
+	}
-{
+	return its;
-	BEGIN_TILE_LOOP(tile_cur, i->width, i->height, i->xy);
+}
+Industry::~Industry()
+{
+	/* Industry can also be destroyed when not fully initialized.
+	 * This means that we do not have to clear tiles either. */
+	if (this->width == 0) {
+		this->xy = 0;
+		return;
+	}
+	BEGIN_TILE_LOOP(tile_cur, this->width, this->height, this->xy);
 		if (IsTileType(tile_cur, MP_INDUSTRY)) {
-			if (GetIndustryIndex(tile_cur) == i->index) {
+			if (GetIndustryIndex(tile_cur) == this->index) {
 				DoClearSquare(tile_cur);
 			}
 		} else if (IsTileType(tile_cur, MP_STATION) && IsOilRig(tile_cur)) {
 			DeleteOilRig(tile_cur);
 		}
-	END_TILE_LOOP(tile_cur, i->width, i->height, i->xy);
+	END_TILE_LOOP(tile_cur, this->width, this->height, this->xy);
-	if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_FIELDS) {
+	if (GetIndustrySpec(this->type)->behaviour & INDUSTRYBEH_PLANT_FIELDS) {
 		/* Remove the farmland and convert it to regular tiles over time. */
-		BEGIN_TILE_LOOP(tile_cur, 42, 42, i->xy - TileDiffXY(21, 21)) {
+		BEGIN_TILE_LOOP(tile_cur, 42, 42, this->xy - TileDiffXY(21, 21)) {
 			tile_cur = TILE_MASK(tile_cur);
 			if (IsTileType(tile_cur, MP_CLEAR) && IsClearGround(tile_cur, CLEAR_FIELDS) &&
-					GetIndustryIndexOfField(tile_cur) == i->index) {
+					GetIndustryIndexOfField(tile_cur) == this->index) {
 				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);
 			}
-		} END_TILE_LOOP(tile_cur, 42, 42, i->xy - TileDiff(21, 21))
+		} END_TILE_LOOP(tile_cur, 42, 42, this->xy - TileDiff(21, 21))
 	}
 	_industry_sort_dirty = true;
-	DecIndustryTypeCount(i->type);
+	DecIndustryTypeCount(this->type);
-	DeleteSubsidyWithIndustry(i->index);
+	DeleteSubsidyWithIndustry(this->index);
-	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);
+	DeleteWindowById(WC_INDUSTRY_VIEW, this->index);
 	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);
+	this->xy = 0;
 }
 static void IndustryDrawSugarMine(const TileInfo *ti)
 {
 	const DrawIndustryAnimationStruct *d;
 {
 	IndustryGfx gfx = GetIndustryGfx(ti->tile);
 	Industry *ind = GetIndustryByTile(ti->tile);
 	const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
 	const DrawBuildingsTileStruct *dits;
-	byte z;
 	SpriteID image;
 	SpriteID pal;
 	/* Retrieve pointer to the draw industry tile struct */
 	if (gfx >= NEW_INDUSTRYTILEOFFSET) {
 		pal = GENERAL_SPRITE_COLOR(ind->random_color);
 	} else {
 		pal = dits->ground.pal;
 	}
-	z = ti->z;
+	/* DrawFoundation() modifes ti->z and ti->tileh */
-	/* Add bricks below the industry? */
+	if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
-	if (ti->tileh != SLOPE_FLAT) {
-		DrawFoundation(ti, ti->tileh);
-		z += TILE_HEIGHT;
-	}
 	DrawGroundSprite(image, pal);
 	/* Add industry on top of the ground? */
 	image = dits->building.sprite;
 	if (image != 0) {
-		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) {
+		AddSortableSpriteToDraw(image,
-			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
+			(HASBIT(image, PALETTE_MODIFIER_COLOR) && dits->building.pal == PAL_NONE) ? GENERAL_SPRITE_COLOR(ind->random_color) : dits->building.pal,
-			pal = PALETTE_TO_TRANSPARENT;
-		} else if (HASBIT(image, PALETTE_MODIFIER_COLOR) && dits->building.pal == PAL_NONE) {
-			pal = GENERAL_SPRITE_COLOR(ind->random_color);
-		} else {
-			pal = dits->building.pal;
-		}
-		AddSortableSpriteToDraw(image, pal,
 			ti->x + dits->subtile_x,
 			ti->y + dits->subtile_y,
 			dits->width  + 1,
 			dits->height + 1,
 			dits->dz,
-			z);
+			ti->z,
+			HASBIT(_transparent_opt, TO_INDUSTRIES));
 		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) return;
 	}
 	{
 static uint GetSlopeZ_Industry(TileIndex tile, uint x, uint y)
 {
 	return GetTileMaxZ(tile);
 }
-static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)
+static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
 {
-	return SLOPE_FLAT;
+	return FlatteningFoundation(tileh);
 }
 static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)
 {
 	IndustryGfx gfx = GetIndustryGfx(tile);
 			(_current_player == OWNER_WATER && (indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER))) {
 		SetDParam(0, indspec->name);
 		return_cmd_error(STR_4800_IN_THE_WAY);
 	}
-	if (flags & DC_EXEC) DeleteIndustry(i);
+	if (flags & DC_EXEC) delete i;
 	return CommandCost();
 }
 static void TransportIndustryGoods(TileIndex tile)
 {
 		TileY(tile) * TILE_SIZE + _tileloop_ind_case_161[dir + 4],
 		_tileloop_ind_case_161[dir + 8],
 		EV_BUBBLE
 	);
-	if (v != NULL) v->u.special.unk2 = dir;
+	if (v != NULL) v->u.special.animation_substate = dir;
 }
 static void TileLoop_Industry(TileIndex tile)
 {
 	IndustryGfx newgfx;
 			_error_message = STR_INDUSTRY_TOO_CLOSE;
 			return false;
 		}
 	}
 	return true;
-}
-static Industry *AllocateIndustry()
-{
-	Industry *i;
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
-	 * TODO - This is just a temporary stage, this will be removed. */
-	for (i = GetIndustry(0); i != NULL; i = (i->index + 1U < GetIndustryPoolSize()) ? GetIndustry(i->index + 1U) : NULL) {
-		IndustryID index = i->index;
-		if (IsValidIndustry(i)) continue;
-		memset(i, 0, sizeof(*i));
-		i->index = index;
-		return i;
-	}
-	/* 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, Owner owner)
 {
 	const IndustrySpec *indspec = GetIndustrySpec(type);
 	if (t == NULL) return NULL;
 	if (!CheckIfIndustryIsAllowed(tile, type, t)) return NULL;
 	if (!CheckSuitableIndustryPos(tile)) return NULL;
-	Industry *i = AllocateIndustry();
+	Industry *i = new Industry(tile);
 	if (i == NULL) return NULL;
+	AutoPtrT<Industry> i_auto_delete = i;
 	if (flags & DC_EXEC) {
 		if (!custom_shape_check) CheckIfCanLevelIndustryPlatform(tile, DC_EXEC, it, type);
 		DoCreateNewIndustry(i, tile, type, it, t, OWNER_NONE);
+		i_auto_delete.Detach();
 	}
 	return i;
 }
 	const IndustrySpec *indspec = GetIndustrySpec(type);
 	return CreateNewIndustryHelper(tile, type, DC_EXEC, indspec, RandomRange(indspec->num_table));
 }
-static const byte _numof_industry_table[5][11] = {
+enum {
+	NB_NUMOFINDUSTRY = 11,
+	NB_DIFFICULTY_LEVEL = 5,
+};
+static const byte _numof_industry_table[NB_DIFFICULTY_LEVEL][NB_NUMOFINDUSTRY] = {
 	/* difficulty settings for number of industries */
 	{0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0},   //none
 	{0, 1, 1, 1, 1, 1, 1, 1,  1,  1,  1},   //very low
 	{0, 1, 1, 1, 2, 2, 3, 3,  4,  4,  5},   //low
 	{0, 1, 2, 3, 4, 5, 6, 7,  8,  9, 10},   //normal
 * of random industries during game creation
 * @param type IndustryType of the desired industry
 * @param amount of industries that need to be built */
 static void PlaceInitialIndustry(IndustryType type, int amount)
 {
-	int num = _numof_industry_table[_opt.diff.number_industries][amount];
+	/* We need to bypass the amount given in parameter if it exceeds the maximum dimension of the
+	 * _numof_industry_table.  newgrf can specify a big amount */
+	int num = (amount > NB_NUMOFINDUSTRY) ? amount : _numof_industry_table[_opt.diff.number_industries][amount];
 	const IndustrySpec *ind_spc = GetIndustrySpec(type);
 	/* These are always placed next to the coastline, so we scale by the perimeter instead. */
 	num = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
 	IndustryType it;
 	const IndustrySpec *ind_spc;
 	/* Find the total amount of industries */
 	if (_opt.diff.number_industries > 0) {
-		for (it = IT_COAL_MINE; it < NUM_INDUSTRYTYPES; it++) {
+		for (it = 0; it < NUM_INDUSTRYTYPES; it++) {
 			ind_spc = GetIndustrySpec(it);
 			if (!CheckIfCallBackAllowsAvailability(it, IACT_MAPGENERATION)) {
 				ResetIndustryCreationProbility(it);
 			chance = ind_spc->appear_creation[_opt.landscape];
 			if (ind_spc->enabled && chance > 0) {
 				/* once the chance of appearance is determind, it have to be scaled by
 				 * the difficulty level. The "chance" in question is more an index into
 				 * the _numof_industry_table,in fact */
-				int num = (chance < 11) ? chance : _numof_industry_table[_opt.diff.number_industries][chance];
+				int num = (chance > NB_NUMOFINDUSTRY) ? chance : _numof_industry_table[_opt.diff.number_industries][chance];
 				/* These are always placed next to the coastline, so we scale by the perimeter instead. */
 				num = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
 				i += num;
 			}
 	}
 	SetGeneratingWorldProgress(GWP_INDUSTRY, i);
 	if (_opt.diff.number_industries > 0) {
-		for (it = IT_COAL_MINE; it < NUM_INDUSTRYTYPES; it++) {
+		for (it = 0; it < NUM_INDUSTRYTYPES; it++) {
 			/* Once the number of industries has been determined, let's really create them.
 			 * The test for chance allows us to try create industries that are available only
 			 * for this landscape.
 			 * @todo :  Do we really have to pass chance as un-scaled value, since we've already
 			 *          processed that scaling above? No, don't think so.  Will find a way. */
 	if (refresh)
 		InvalidateWindow(WC_INDUSTRY_VIEW, i->index);
 	if (i->prod_level == 0) {
-		DeleteIndustry(i);
+		delete i;
 	} else if (_patches.smooth_economy) {
 		ExtChangeIndustryProduction(i);
 	}
 }
 	AnimateTile_Industry,        /* animate_tile_proc */
 	TileLoop_Industry,           /* tile_loop_proc */
 	ChangeTileOwner_Industry,    /* change_tile_owner_proc */
 	GetProducedCargo_Industry,   /* get_produced_cargo_proc */
 	NULL,                        /* vehicle_enter_tile_proc */
-	GetSlopeTileh_Industry,      /* get_slope_tileh_proc */
+	GetFoundation_Industry,      /* get_foundation_proc */
 };
 static const SaveLoad _industry_desc[] = {
 	SLE_CONDVAR(Industry, xy,                         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 	SLE_CONDVAR(Industry, xy,                         SLE_UINT32,                  6, SL_MAX_VERSION),
 	int index;
 	ResetIndustryCounts();
 	while ((index = SlIterateArray()) != -1) {
-		Industry *i;
+		Industry *i = new (index) Industry();
-		if (!AddBlockIfNeeded(&_Industry_pool, index))
-			error("Industries: failed loading savegame: too many industries");
-		i = GetIndustry(index);
 		SlObject(i, _industry_desc);
 		IncIndustryTypeCount(i->type);
 	}
 }

branch	NewGRF_ports
changeset 6743	cabfaa4a0295
parent 6732	ca1b466db422
child 6800	6c09e1e86fcb