openttd-ottdgrfs: comparison src/rail

equal deleted inserted replaced

-:1337d6c9b97b
+:cabfaa4a0295
 #include "newgrf.h"
 #include "yapf/yapf.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_station.h"
 #include "train.h"
+#include "misc/autoptr.hpp"
 const byte _track_sloped_sprites[14] = {
 	14, 15, 22, 13,
 	 0, 21, 17, 12,
 	23,  0, 18, 20,
 	TRACK_BIT_ALL,
 	TRACK_BIT_ALL
 }
 };
-uint GetRailFoundation(Slope tileh, TrackBits bits)
+Foundation GetRailFoundation(Slope tileh, TrackBits bits)
 {
-	uint i;
 	if (!IsSteepSlope(tileh)) {
-		if ((~_valid_tileh_slopes[0][tileh] & bits) == 0) return 0;
+		if ((~_valid_tileh_slopes[0][tileh] & bits) == 0) return FOUNDATION_NONE;
-		if ((~_valid_tileh_slopes[1][tileh] & bits) == 0) return tileh;
+		if ((~_valid_tileh_slopes[1][tileh] & bits) == 0) return FOUNDATION_LEVELED;
 	}
 	switch (bits) {
 		default: NOT_REACHED();
-		case TRACK_BIT_X: i = 0; break;
+		case TRACK_BIT_X:     return FOUNDATION_INCLINED_X;
-		case TRACK_BIT_Y: i = 1; break;
+		case TRACK_BIT_Y:     return FOUNDATION_INCLINED_Y;
-		case TRACK_BIT_LEFT:  return 15 + 8 + (tileh == SLOPE_STEEP_W ? 4 : 0);
+		case TRACK_BIT_LEFT:  return (tileh == SLOPE_STEEP_W ? FOUNDATION_STEEP_HIGHER : FOUNDATION_STEEP_LOWER);
-		case TRACK_BIT_LOWER: return 15 + 8 + (tileh == SLOPE_STEEP_S ? 5 : 1);
+		case TRACK_BIT_LOWER: return (tileh == SLOPE_STEEP_S ? FOUNDATION_STEEP_HIGHER : FOUNDATION_STEEP_LOWER);
-		case TRACK_BIT_RIGHT: return 15 + 8 + (tileh == SLOPE_STEEP_E ? 6 : 2);
+		case TRACK_BIT_RIGHT: return (tileh == SLOPE_STEEP_E ? FOUNDATION_STEEP_HIGHER : FOUNDATION_STEEP_LOWER);
-		case TRACK_BIT_UPPER: return 15 + 8 + (tileh == SLOPE_STEEP_N ? 7 : 3);
+		case TRACK_BIT_UPPER: return (tileh == SLOPE_STEEP_N ? FOUNDATION_STEEP_HIGHER : FOUNDATION_STEEP_LOWER);
 	}
-	switch (tileh) {
-		case SLOPE_W:
-		case SLOPE_STEEP_W: i += 0; break;
-		case SLOPE_S:
-		case SLOPE_STEEP_S: i += 2; break;
-		case SLOPE_E:
-		case SLOPE_STEEP_E: i += 4; break;
-		case SLOPE_N:
-		case SLOPE_STEEP_N: i += 6; break;
-		default: return 0;
-	}
-	return i + 15;
 }
 static CommandCost CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
 {
 				SetRailGroundType(tile, RAIL_GROUND_BARREN);
 				SetTrackBits(tile, GetTrackBits(tile) | trackbit);
 			}
 			break;
-		case MP_STREET:
+		case MP_ROAD:
 #define M(x) (1 << (x))
 			/* Level crossings may only be built on these slopes */
 			if (!HASBIT(M(SLOPE_SEN) | M(SLOPE_ENW) | M(SLOPE_NWS) | M(SLOPE_NS) | M(SLOPE_WSE) | M(SLOPE_EW) | M(SLOPE_FLAT), tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 			}
 	trackbit = TrackToTrackBits(track);
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	switch (GetTileType(tile)) {
-		case MP_STREET: {
+		case MP_ROAD: {
 			if (!IsLevelCrossing(tile) ||
 					GetCrossingRailBits(tile) != trackbit ||
 					(_current_player != OWNER_WATER && !CheckTileOwnership(tile)) ||
 					!EnsureNoVehicleOnGround(tile)) {
 				return CMD_ERROR;
 * @todo When checking for the tile slope,
 * distingush between "Flat land required" and "land sloped in wrong direction"
 */
 CommandCost CmdBuildTrainDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	Depot *d;
 	CommandCost cost;
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(cost)) return CMD_ERROR;
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
-	d = AllocateDepot();
+	Depot *d = new Depot(tile);
 	if (d == NULL) return CMD_ERROR;
+	AutoPtrT<Depot> d_auto_delete = d;
 	if (flags & DC_EXEC) {
 		MakeRailDepot(tile, _current_player, dir, (RailType)p1);
 		MarkTileDirtyByTile(tile);
-		d->xy = tile;
 		d->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
 		UpdateSignalsOnSegment(tile, dir);
 		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
+		d_auto_delete.Detach();
 	}
 	return cost.AddCost(_price.build_train_depot);
 }
 				/* Ensure signal_ctr even so X and Y pieces get signals */
 				CLRBIT(signal_ctr, 0);
 			}
 			return true;
-		case MP_STREET:
+		case MP_ROAD:
 			if (!IsLevelCrossing(tile)) return false;
 			signal_ctr += 2;
 			return true;
 		case MP_TUNNELBRIDGE: {
 			DoConvertRailProc* proc;
 			switch (GetTileType(tile)) {
 				case MP_RAILWAY:      proc = DoConvertRail;             break;
 				case MP_STATION:      proc = DoConvertStationRail;      break;
-				case MP_STREET:       proc = DoConvertStreetRail;       break;
+				case MP_ROAD:         proc = DoConvertStreetRail;       break;
 				case MP_TUNNELBRIDGE: proc = DoConvertTunnelBridgeRail; break;
 				default: continue;
 			}
 			ret = proc(tile, (RailType)p2, false);
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DiagDirection dir = GetRailDepotDirection(tile);
-		DeleteDepot(GetDepotByTile(tile));
+		DoClearSquare(tile);
+		delete GetDepotByTile(tile);
 		UpdateSignalsOnSegment(tile, dir);
 		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
 	}
 	return CommandCost(_price.remove_train_depot);
 static uint32 _drawtile_track_palette;
 static void DrawTrackFence_NW(const TileInfo *ti)
 {
-	SpriteID image = 0x515;
+	SpriteID image = SPR_TRACK_FENCE_FLAT_X;
-	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? 0x519 : 0x51B;
+	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? SPR_TRACK_FENCE_SLOPE_SW : SPR_TRACK_FENCE_SLOPE_NE;
 	AddSortableSpriteToDraw(image, _drawtile_track_palette,
 		ti->x, ti->y + 1, 16, 1, 4, ti->z);
 }
 static void DrawTrackFence_SE(const TileInfo *ti)
 {
-	SpriteID image = 0x515;
+	SpriteID image = SPR_TRACK_FENCE_FLAT_X;
-	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? 0x519 : 0x51B;
+	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? SPR_TRACK_FENCE_SLOPE_SW : SPR_TRACK_FENCE_SLOPE_NE;
 	AddSortableSpriteToDraw(image, _drawtile_track_palette,
 		ti->x, ti->y + TILE_SIZE - 1, 16, 1, 4, ti->z);
 }
 static void DrawTrackFence_NW_SE(const TileInfo *ti)
 	DrawTrackFence_SE(ti);
 }
 static void DrawTrackFence_NE(const TileInfo *ti)
 {
-	SpriteID image = 0x516;
+	SpriteID image = SPR_TRACK_FENCE_FLAT_Y;
-	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? 0x51A : 0x51C;
+	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? SPR_TRACK_FENCE_SLOPE_SE : SPR_TRACK_FENCE_SLOPE_NW;
 	AddSortableSpriteToDraw(image, _drawtile_track_palette,
 		ti->x + 1, ti->y, 1, 16, 4, ti->z);
 }
 static void DrawTrackFence_SW(const TileInfo *ti)
 {
-	SpriteID image = 0x516;
+	SpriteID image = SPR_TRACK_FENCE_FLAT_Y;
-	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? 0x51A : 0x51C;
+	if (ti->tileh != SLOPE_FLAT) image = (ti->tileh & SLOPE_S) ? SPR_TRACK_FENCE_SLOPE_SE : SPR_TRACK_FENCE_SLOPE_NW;
 	AddSortableSpriteToDraw(image, _drawtile_track_palette,
 		ti->x + TILE_SIZE - 1, ti->y, 1, 16, 4, ti->z);
 }
 static void DrawTrackFence_NE_SW(const TileInfo *ti)
 {
 	DrawTrackFence_NE(ti);
 	DrawTrackFence_SW(ti);
 }
+/**
+* Draw fence at eastern side of track.
+*/
 static void DrawTrackFence_NS_1(const TileInfo *ti)
 {
 	int z = ti->z;
 	if (ti->tileh & SLOPE_W) z += TILE_HEIGHT;
-	AddSortableSpriteToDraw(0x517, _drawtile_track_palette,
+	AddSortableSpriteToDraw(SPR_TRACK_FENCE_FLAT_VERT, _drawtile_track_palette,
 		ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
 }
+/**
+* Draw fence at western side of track.
+*/
 static void DrawTrackFence_NS_2(const TileInfo *ti)
 {
 	int z = ti->z;
 	if (ti->tileh & SLOPE_E) z += TILE_HEIGHT;
-	AddSortableSpriteToDraw(0x517, _drawtile_track_palette,
+	AddSortableSpriteToDraw(SPR_TRACK_FENCE_FLAT_VERT, _drawtile_track_palette,
 		ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
 }
+/**
+* Draw fence at southern side of track.
+*/
 static void DrawTrackFence_WE_1(const TileInfo *ti)
 {
 	int z = ti->z;
 	if (ti->tileh & SLOPE_N) z += TILE_HEIGHT;
-	AddSortableSpriteToDraw(0x518, _drawtile_track_palette,
+	AddSortableSpriteToDraw(SPR_TRACK_FENCE_FLAT_HORZ, _drawtile_track_palette,
 		ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
 }
+/**
+* Draw fence at northern side of track.
+*/
 static void DrawTrackFence_WE_2(const TileInfo *ti)
 {
 	int z = ti->z;
 	if (ti->tileh & SLOPE_S) z += TILE_HEIGHT;
-	AddSortableSpriteToDraw(0x518, _drawtile_track_palette,
+	AddSortableSpriteToDraw(SPR_TRACK_FENCE_FLAT_HORZ, _drawtile_track_palette,
 		ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
 }
 static void DrawTrackDetails(const TileInfo* ti)
 	(image++,                          (track & TRACK_BIT_3WAY_NW) == 0) ||
 	(image++,                          (track & TRACK_BIT_3WAY_SE) == 0) ||
 	(image++, true);
 	if (ti->tileh != SLOPE_FLAT) {
-		uint foundation = GetRailFoundation(ti->tileh, track);
+		DrawFoundation(ti, GetRailFoundation(ti->tileh, track));
-		if (foundation != 0) DrawFoundation(ti, foundation);
 		/* DrawFoundation() modifies it.
 		 * Default sloped sprites.. */
-		if (ti->tileh != SLOPE_FLAT)
+		if (ti->tileh != SLOPE_FLAT) image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y;
-			image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y;
 	}
 	switch (GetRailGroundType(ti->tile)) {
 		case RAIL_GROUND_BARREN:     pal = PALETTE_TO_BARE_LAND; break;
 		case RAIL_GROUND_ICE_DESERT: image += rti->snow_offset; break;
 		/* draw depot/waypoint */
 		const DrawTileSprites* dts;
 		const DrawTileSeqStruct* dtss;
 		uint32 relocation;
-		if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
+		if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
 		if (IsRailDepot(ti->tile)) {
 			dts = &_depot_gfx_table[GetRailDepotDirection(ti->tile)];
 			relocation = rti->total_offset;
 				image += rti->total_offset;
 			} else {
 				image += relocation;
 			}
-			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 = _drawtile_track_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);
 			}
 		}
 		if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL) return true;
 		/* check for a vehicle with that trackdir on the end tile of the tunnel */
 		if (VehicleFromPos(end, &dest, SignalVehicleCheckProc) != NULL) return true;
-		/* now check all tiles from start to end for a warping vehicle
+		/* now check all tiles from start to end for a warping vehicle */
-		 * NOTE: the hashes for tiles may overlap, so this could maybe be optimised a bit by not checking every tile? */
 		dest.track = 0x40;   //Vehicle inside a tunnel or on a bridge
-		for (; tile != end; tile += TileOffsByDiagDir(direction)) {
+		if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL) return true;
-			if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL)
+		if (VehicleFromPos(end, &dest, SignalVehicleCheckProc) != NULL) return true;
-				return true;
-		}
 		/* no vehicle found */
 		return false;
 	}
 	uint z;
 	Slope tileh = GetTileSlope(tile, &z);
 	if (tileh == SLOPE_FLAT) return z;
 	if (IsPlainRailTile(tile)) {
-		uint f = GetRailFoundation(tileh, GetTrackBits(tile));
+		z += ApplyFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh);
-		if (f != 0) {
-			if (IsSteepSlope(tileh)) {
-				z += TILE_HEIGHT;
-			} else if (f < 15) {
-				return z + TILE_HEIGHT; // leveled foundation
-			}
-			tileh = _inclined_tileh[f - 15]; // inclined foundation
-		}
 		return z + GetPartialZ(x & 0xF, y & 0xF, tileh);
 	} else {
 		return z + TILE_HEIGHT;
 	}
 }
-static Slope GetSlopeTileh_Track(TileIndex tile, Slope tileh)
+static Foundation GetFoundation_Track(TileIndex tile, Slope tileh)
 {
-	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;
+	return IsPlainRailTile(tile) ? GetRailFoundation(tileh, GetTrackBits(tile)) : FlatteningFoundation(tileh);
-	if (IsPlainRailTile(tile)) {
-		uint f = GetRailFoundation(tileh, GetTrackBits(tile));
-		if (f == 0) return tileh;
-		if (f < 15) return SLOPE_FLAT; // leveled foundation
-		return _inclined_tileh[f - 15]; // inclined foundation
-	} else {
-		return SLOPE_FLAT;
-	}
 }
 static void GetAcceptedCargo_Track(TileIndex tile, AcceptedCargo ac)
 {
 	/* not used */
 	AnimateTile_Track,        /* animate_tile_proc */
 	TileLoop_Track,           /* tile_loop_clear */
 	ChangeTileOwner_Track,    /* change_tile_owner_clear */
 	NULL,                     /* get_produced_cargo_proc */
 	VehicleEnter_Track,       /* vehicle_enter_tile_proc */
-	GetSlopeTileh_Track,      /* get_slope_tileh_proc */
+	GetFoundation_Track,      /* get_foundation_proc */
 };

branch	NewGRF_ports
changeset 6743	cabfaa4a0295
parent 6730	f09255ea0123
child 6868	7eb395287b3d