openttd-ottdgrfs: comparison src/station

equal deleted inserted replaced

-:31fcaa5375a1
+:e72987579514
 #include "misc/autoptr.hpp"
 #include "road.h"
 #include "cargotype.h"
 #include "strings.h"
+DEFINE_OLD_POOL_GENERIC(Station, Station)
+DEFINE_OLD_POOL_GENERIC(RoadStop, RoadStop)
 /**
-* Called if a new block is added to the station-pool
+* Check whether the given tile is a hangar.
+* @param t the tile to of whether it is a hangar.
+* @pre IsTileType(t, MP_STATION)
+* @return true if and only if the tile is a hangar.
 */
-static void StationPoolNewBlock(uint start_item)
+bool IsHangar(TileIndex t)
 {
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
+	assert(IsTileType(t, MP_STATION));
-	 *  TODO - This is just a temporary stage, this will be removed. */
-	for (Station *st = GetStation(start_item); st != NULL; st = (st->index + 1U < GetStationPoolSize()) ? GetStation(st->index + 1U) : NULL) st->index = start_item++;
+	const Station *st = GetStationByTile(t);
-}
+	const AirportFTAClass *apc = st->Airport();
-static void StationPoolCleanBlock(uint start_item, uint end_item)
+	for (uint i = 0; i < apc->nof_depots; i++) {
-{
+		if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == t) return true;
-	for (uint i = start_item; i <= end_item; i++) {
+	}
-		Station *st = GetStation(i);
-		if (st->IsValid()) st->~Station();
+	return false;
-	}
+}
-}
-/**
-* Called if a new block is added to the roadstop-pool
-*/
-static void RoadStopPoolNewBlock(uint start_item)
-{
-	/* 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 (RoadStop *rs = GetRoadStop(start_item); rs != NULL; rs = (rs->index + 1U < GetRoadStopPoolSize()) ? GetRoadStop(rs->index + 1U) : NULL) {
-		rs->xy    = INVALID_TILE;
-		rs->index = start_item++;
-	}
-}
-DEFINE_OLD_POOL(Station, Station, StationPoolNewBlock, StationPoolCleanBlock)
-DEFINE_OLD_POOL(RoadStop, RoadStop, RoadStopPoolNewBlock, NULL)
 RoadStop* GetRoadStopByTile(TileIndex tile, RoadStop::Type type)
 {
 	const Station* st = GetStationByTile(tile);
 		}
 	END_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))
 	return (closest_station == INVALID_STATION) ? NULL : GetStation(closest_station);
 }
+/**
+* Function to check whether the given tile matches some criterion.
+* @param tile the tile to check
+* @return true if it matches, false otherwise
+*/
+typedef bool (*CMSAMatcher)(TileIndex tile);
 /**
 * Counts the numbers of tiles matching a specific type in the area around
 * @param tile the center tile of the 'count area'
 * @param type the type of tile searched for
 * @param industry when type == MP_INDUSTRY, the type of the industry,
 *                 in all other cases this parameter is ignored
 * @return the result the noumber of matching tiles around
 */
-static int CountMapSquareAround(TileIndex tile, TileType type, IndustryType industry)
+static int CountMapSquareAround(TileIndex tile, CMSAMatcher cmp)
 {
 	int num = 0;
 	for (int dx = -3; dx <= 3; dx++) {
 		for (int dy = -3; dy <= 3; dy++) {
-			TileIndex cur_tile = TILE_MASK(tile + TileDiffXY(dx, dy));
+			if (cmp(TILE_MASK(tile + TileDiffXY(dx, dy)))) num++;
-			if (IsTileType(cur_tile, type)) {
-				switch (type) {
-					case MP_INDUSTRY:
-						if (GetIndustryType(cur_tile) == industry)
-							num++;
-						break;
-					case MP_WATER:
-						if (!IsWater(cur_tile))
-							break;
-						/* FALL THROUGH WHEN WATER TILE */
-					case MP_TREES:
-						num++;
-						break;
-					default:
-						break;
-				}
-			}
 		}
 	}
 	return num;
+}
+/**
+* Check whether the tile is a mine.
+* @param tile the tile to investigate.
+* @return true if and only if the tile is a mine
+*/
+static bool CMSAMine(TileIndex tile)
+{
+	/* No industry */
+	if (!IsTileType(tile, MP_INDUSTRY)) return false;
+	const IndustrySpec *indsp = GetIndustrySpec(GetIndustryByTile(tile)->type);
+	/* No extractive industry */
+	if ((indsp->life_type & INDUSTRYLIFE_EXTRACTIVE) == 0) return false;
+	for (uint i = 0; i < lengthof(indsp->produced_cargo); i++) {
+		/* The industry extracts something non-liquid, i.e. no oil or plastic, so it is a mine */
+		if (indsp->produced_cargo[i] != CT_INVALID && (GetCargo(indsp->produced_cargo[i])->classes & CC_LIQUID) == 0) return true;
+	}
+	return false;
+}
+/**
+* Check whether the tile is water.
+* @param tile the tile to investigate.
+* @return true if and only if the tile is a mine
+*/
+static bool CMSAWater(TileIndex tile)
+{
+	return IsTileType(tile, MP_WATER) && IsWater(tile);
+}
+/**
+* Check whether the tile is a tree.
+* @param tile the tile to investigate.
+* @return true if and only if the tile is a mine
+*/
+static bool CMSATree(TileIndex tile)
+{
+	return IsTileType(tile, MP_TREES);
+}
+/**
+* Check whether the tile is a forest.
+* @param tile the tile to investigate.
+* @return true if and only if the tile is a mine
+*/
+static bool CMSAForest(TileIndex tile)
+{
+	/* No industry */
+	if (!IsTileType(tile, MP_INDUSTRY)) return false;
+	const IndustrySpec *indsp = GetIndustrySpec(GetIndustryByTile(tile)->type);
+	/* No extractive industry */
+	if ((indsp->life_type & INDUSTRYLIFE_ORGANIC) == 0) return false;
+	for (uint i = 0; i < lengthof(indsp->produced_cargo); i++) {
+		/* The industry produces wood. */
+		if (indsp->produced_cargo[i] != CT_INVALID && GetCargo(indsp->produced_cargo[i])->label == 'WOOD') return true;
+	}
+	return false;
 }
 #define M(x) ((x) - STR_SV_STNAME)
 static bool GenerateStationName(Station *st, TileIndex tile, int flag)
 		goto done;
 	}
 	/* check mine? */
 	if (HASBIT(free_names, M(STR_SV_STNAME_MINES))) {
-		if (CountMapSquareAround(tile, MP_INDUSTRY, IT_COAL_MINE) >= 2 ||
+		if (CountMapSquareAround(tile, CMSAMine) >= 2) {
-				CountMapSquareAround(tile, MP_INDUSTRY, IT_IRON_MINE) >= 2 ||
-				CountMapSquareAround(tile, MP_INDUSTRY, IT_COPPER_MINE) >= 2 ||
-				CountMapSquareAround(tile, MP_INDUSTRY, IT_GOLD_MINE) >= 2 ||
-				CountMapSquareAround(tile, MP_INDUSTRY, IT_DIAMOND_MINE) >= 2) {
 			found = M(STR_SV_STNAME_MINES);
 			goto done;
 		}
 	}
 	}
 	/* Check lakeside */
 	if (HASBIT(free_names, M(STR_SV_STNAME_LAKESIDE)) &&
 			DistanceFromEdge(tile) < 20 &&
-			CountMapSquareAround(tile, MP_WATER, 0) >= 5) {
+			CountMapSquareAround(tile, CMSAWater) >= 5) {
 		found = M(STR_SV_STNAME_LAKESIDE);
 		goto done;
 	}
 	/* Check woods */
 	if (HASBIT(free_names, M(STR_SV_STNAME_WOODS)) && (
-				CountMapSquareAround(tile, MP_TREES, 0) >= 8 ||
+				CountMapSquareAround(tile, CMSATree) >= 8 ||
-				CountMapSquareAround(tile, MP_INDUSTRY, IT_FOREST) >= 2)
+				CountMapSquareAround(tile, CMSAForest) >= 2)
 			) {
 		found = _opt.landscape == LT_TROPIC ?
 			M(STR_SV_STNAME_FOREST) : M(STR_SV_STNAME_WOODS);
 		goto done;
 	}
 		//XXX can't we pack this in the "else" part of the if above?
 		if (!st->rect.BeforeAddRect(tile_org, w_org, h_org, StationRect::ADD_TEST)) return CMD_ERROR;
 	} else {
 		/* allocate and initialize new station */
 		st = new Station(tile_org);
-		if (st == NULL) return CMD_ERROR;
+		if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 		/* ensure that in case of error (or no DC_EXEC) the station gets deleted upon return */
 		st_auto_delete = st;
 		st->town = ClosestTownFromTile(tile_org, (uint)-1);
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		/* success, so don't delete the new station */
-		st_auto_delete.Release();
+		st_auto_delete.Detach();
 	}
 	return cost;
 }
 */
 CommandCost CmdBuildRoadStop(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	bool type = HASBIT(p2, 0);
 	bool is_drive_through = HASBIT(p2, 1);
-	bool build_over_road  = is_drive_through && IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL;
+	bool build_over_road  = is_drive_through && IsTileType(tile, MP_ROAD) && GetRoadTileType(tile) == ROAD_TILE_NORMAL;
 	bool town_owned_road  = build_over_road && IsTileOwner(tile, OWNER_TOWN);
 	RoadTypes rts = (RoadTypes)GB(p2, 2, 3);
 	if (rts == ROADTYPES_NONE || HASBIT(rts, ROADTYPE_HWAY)) return CMD_ERROR;
 		if (!st->rect.BeforeAddTile(tile, StationRect::ADD_TEST)) return CMD_ERROR;
 	} else {
 		/* allocate and initialize new station */
 		st = new Station(tile);
-		if (st == NULL) return CMD_ERROR;
+		if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 		/* ensure that in case of error (or no DC_EXEC) the new station gets deleted upon return */
 		st_auto_delete = st;
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		/* success, so don't delete the new station and the new road stop */
-		st_auto_delete.Release();
+		st_auto_delete.Detach();
-		rs_auto_delete.Release();
+		rs_auto_delete.Detach();
 	}
 	return cost;
 }
 // Remove a bus station
 	} else {
 		airport_upgrade = false;
 		/* allocate and initialize new station */
 		st = new Station(tile);
-		if (st == NULL) return CMD_ERROR;
+		if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 		/* ensure that in case of error (or no DC_EXEC) the station gets deleted upon return */
 		st_auto_delete = st;
 		st->town = t;
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		/* success, so don't delete the new station */
-		st_auto_delete.Release();
+		st_auto_delete.Detach();
 	}
 	return cost;
 }
 	if (!IsClearWaterTile(tile) || tile == 0) return_cmd_error(STR_304B_SITE_UNSUITABLE);
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	/* allocate and initialize new station */
 	Station *st = new Station(tile);
-	if (st == NULL) return CMD_ERROR;
+	if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 	/* ensure that in case of error (or no DC_EXEC) the station gets deleted upon return */
 	AutoPtrT<Station> st_auto_delete(st);
 	st->town = ClosestTownFromTile(tile, (uint)-1);
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		/* success, so don't delete the new station */
-		st_auto_delete.Release();
+		st_auto_delete.Detach();
 	}
 	return CommandCost(_price.build_dock);
 }
 		if (st->dock_tile != 0) return_cmd_error(STR_304C_TOO_CLOSE_TO_ANOTHER_DOCK);
 	} else {
 		/* allocate and initialize new station */
 		st = new Station(tile);
-		if (st == NULL) return CMD_ERROR;
+		if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 		/* ensure that in case of error (or no DC_EXEC) the station gets deleted upon return */
 		st_auto_delete = st;
 		Town *t = st->town = ClosestTownFromTile(tile, (uint)-1);
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		/* success, so don't delete the new station */
-		st_auto_delete.Release();
+		st_auto_delete.Detach();
 	}
 	return CommandCost(_price.build_dock);
 }
 static CommandCost RemoveDock(Station *st, uint32 flags)
 		palette = PALETTE_TO_GREY;
 	}
 	// don't show foundation for docks
 	if (ti->tileh != SLOPE_FLAT && !IsDock(ti->tile))
-		DrawFoundation(ti, ti->tileh);
+		DrawFoundation(ti, FOUNDATION_LEVELED);
 	if (IsCustomStationSpecIndex(ti->tile)) {
 		// look for customization
 		st = GetStationByTile(ti->tile);
 		statspec = st->speclist[GetCustomStationSpecIndex(ti->tile)].spec;
 		} else {
 			image += relocation;
 		}
 		SpriteID pal;
-		if (HASBIT(_transparent_opt, TO_BUILDINGS)) {
+		if (!HASBIT(_transparent_opt, TO_BUILDINGS) && HASBIT(image, PALETTE_MODIFIER_COLOR)) {
-			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
-			pal = PALETTE_TO_TRANSPARENT;
-		} else if (HASBIT(image, PALETTE_MODIFIER_COLOR)) {
 			pal = palette;
 		} else {
 			pal = dtss->pal;
 		}
 		if ((byte)dtss->delta_z != 0x80) {
 			AddSortableSpriteToDraw(
 				image, pal,
 				ti->x + dtss->delta_x, ti->y + dtss->delta_y,
 				dtss->size_x, dtss->size_y,
-				dtss->size_z, ti->z + dtss->delta_z
+				dtss->size_z, ti->z + dtss->delta_z,
+				HASBIT(_transparent_opt, TO_BUILDINGS)
 			);
 		} else {
 			AddChildSpriteScreen(image, pal, dtss->delta_x, dtss->delta_y);
 		}
 	}
 static uint GetSlopeZ_Station(TileIndex tile, uint x, uint y)
 {
 	return GetTileMaxZ(tile);
 }
-static Slope GetSlopeTileh_Station(TileIndex tile, Slope tileh)
+static Foundation GetFoundation_Station(TileIndex tile, Slope tileh)
 {
-	return SLOPE_FLAT;
+	return FlatteningFoundation(tileh);
 }
 static void GetAcceptedCargo_Station(TileIndex tile, AcceptedCargo ac)
 {
 	/* not used */
 }
 void InitializeStations()
 {
 	/* Clean the station pool and create 1 block in it */
-	CleanPool(&_Station_pool);
+	_Station_pool.CleanPool();
-	AddBlockToPool(&_Station_pool);
+	_Station_pool.AddBlockToPool();
 	/* Clean the roadstop pool and create 1 block in it */
-	CleanPool(&_RoadStop_pool);
+	_RoadStop_pool.CleanPool();
-	AddBlockToPool(&_RoadStop_pool);
+	_RoadStop_pool.AddBlockToPool();
 	_station_tick_ctr = 0;
 }
 	AnimateTile_Station,        /* animate_tile_proc */
 	TileLoop_Station,           /* tile_loop_clear */
 	ChangeTileOwner_Station,    /* change_tile_owner_clear */
 	NULL,                       /* get_produced_cargo_proc */
 	VehicleEnter_Station,       /* vehicle_enter_tile_proc */
-	GetSlopeTileh_Station,      /* get_slope_tileh_proc */
+	GetFoundation_Station,      /* get_foundation_proc */
 };
 static const SaveLoad _roadstop_desc[] = {
 	SLE_VAR(RoadStop,xy,           SLE_UINT32),
 	SLE_CONDNULL(1, 0, 44),

branch	noai
changeset 9694	e72987579514
parent 9686	d3c195c226f9
child 9701	d1ac22c62f64