openttd-ottdgrfs: comparison src/road

equal deleted inserted replaced

-:31fcaa5375a1
+:e72987579514
 #include "yapf/yapf.h"
 #include "depot.h"
 #include "newgrf.h"
 #include "station_map.h"
 #include "tunnel_map.h"
+#include "misc/autoptr.hpp"
 static uint CountRoadBits(RoadBits r)
 {
 	uint count = 0;
 	RoadType rt = (RoadType)GB(p1, 4, 2);
 	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	Town *t = NULL;
 	switch (GetTileType(tile)) {
-		case MP_STREET:
+		case MP_ROAD:
 			if (_game_mode != GM_EDITOR && GetRoadOwner(tile, rt) == OWNER_TOWN) t = GetTownByTile(tile);
 			break;
 		case MP_STATION:
 			if (!IsDriveThroughStopTile(tile)) return CMD_ERROR;
 	/* check if you're allowed to remove the street owned by a town
 	 * removal allowance depends on difficulty setting */
 	if (!CheckforTownRating(flags, t, ROAD_REMOVE)) return CMD_ERROR;
-	if (!IsTileType(tile, MP_STREET)) {
+	if (!IsTileType(tile, MP_ROAD)) {
 		/* If it's the last roadtype, just clear the whole tile */
 		if (rts == RoadTypeToRoadTypes(rt)) return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 		CommandCost cost;
 		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
 static CommandCost CheckRoadSlope(Slope tileh, RoadBits* pieces, RoadBits existing)
 {
 	RoadBits road_bits;
 	if (IsSteepSlope(tileh)) {
-		if (existing == 0) {
+		/* force full pieces. */
-			/* force full pieces. */
+		*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
-			*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
+		*pieces |= (RoadBits)((*pieces & 0x3) << 2);
-			*pieces |= (RoadBits)((*pieces & 0x3) << 2);
+		if (existing == 0 || existing == *pieces) {
 			if (*pieces == ROAD_X || *pieces == ROAD_Y) return _price.terraform;
 		}
 		return CMD_ERROR;
 	}
 	road_bits = *pieces | existing;
 	/* foundation is used. Whole tile is leveled up */
 	if ((~_valid_tileh_slopes_road[1][tileh] & road_bits) == 0) {
 		return CommandCost(existing != 0 ? 0 : _price.terraform);
 	}
+	*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
+	*pieces |= (RoadBits)((*pieces & 0x3) << 2);
 	/* partly leveled up tile, only if there's no road on that tile */
-	if (existing == 0 && (tileh == SLOPE_W || tileh == SLOPE_S || tileh == SLOPE_E || tileh == SLOPE_N)) {
+	if ((existing == 0 || existing == *pieces) && (tileh == SLOPE_W || tileh == SLOPE_S || tileh == SLOPE_E || tileh == SLOPE_N)) {
 		/* force full pieces. */
-		*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
-		*pieces |= (RoadBits)((*pieces & 0x3) << 2);
 		if (*pieces == ROAD_X || *pieces == ROAD_Y) return _price.terraform;
 	}
 	return CMD_ERROR;
 }
 	DisallowedRoadDirections toggle_drd = (DisallowedRoadDirections)GB(p1, 6, 2);
 	tileh = GetTileSlope(tile, NULL);
 	switch (GetTileType(tile)) {
-		case MP_STREET:
+		case MP_ROAD:
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL: {
 					if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
 					if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 		}
 		cost.AddCost(ret);
 	}
-	if (IsTileType(tile, MP_STREET)) {
+	if (IsTileType(tile, MP_ROAD)) {
 		/* Don't put the pieces that already exist */
 		pieces &= ComplementRoadBits(existing);
 	}
 	cost.AddCost(CountRoadBits(pieces) * _price.build_road);
 		cost.MultiplyCost(DistanceManhattan(IsTunnel(tile) ? GetOtherTunnelEnd(tile) : GetOtherBridgeEnd(tile), tile));
 	}
 	if (flags & DC_EXEC) {
 		switch (GetTileType(tile)) {
-			case MP_STREET: {
+			case MP_ROAD: {
 				RoadTileType rtt = GetRoadTileType(tile);
 				if (existing == ROAD_NONE || rtt == ROAD_TILE_CROSSING) {
 					SetRoadTypes(tile, GetRoadTypes(tile) | RoadTypeToRoadTypes(rt));
 					SetRoadOwner(tile, rt, _current_player);
 					if (_current_player == OWNER_TOWN && rt == ROADTYPE_ROAD) SetTownIndex(tile, p2);
 			default:
 				MakeRoadNormal(tile, pieces, RoadTypeToRoadTypes(rt), p2, _current_player, _current_player, _current_player);
 				break;
 		}
-		if (rt != ROADTYPE_TRAM && IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
+		if (rt != ROADTYPE_TRAM && IsTileType(tile, MP_ROAD) && GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
 			existing |= pieces;
 			SetDisallowedRoadDirections(tile, (existing == ROAD_X || existing == ROAD_Y) ?
 					GetDisallowedRoadDirections(tile) ^ toggle_drd : DRD_NONE);
 		}
 * distingush between "Flat land required" and "land sloped in wrong direction"
 */
 CommandCost CmdBuildRoadDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	CommandCost cost;
-	Depot *dep;
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	DiagDirection dir = Extract<DiagDirection, 0>(p1);
 	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);
-	dep = AllocateDepot();
+	Depot *dep = new Depot(tile);
 	if (dep == NULL) return CMD_ERROR;
+	AutoPtrT<Depot> d_auto_delete = dep;
 	if (flags & DC_EXEC) {
-		dep->xy = tile;
 		dep->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
 		MakeRoadDepot(tile, _current_player, dir, rt);
 		MarkTileDirtyByTile(tile);
+		d_auto_delete.Detach();
 	}
 	return cost.AddCost(_price.build_road_depot);
 }
 static CommandCost RemoveRoadDepot(TileIndex tile, uint32 flags)
 	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)
 		return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
-	if (flags & DC_EXEC) DeleteDepot(GetDepotByTile(tile));
+	if (flags & DC_EXEC) {
+		DoClearSquare(tile);
+		delete GetDepotByTile(tile);
+	}
 	return CommandCost(_price.remove_road_depot);
 }
 static CommandCost ClearTile_Road(TileIndex tile, byte flags)
 };
 #include "table/road_land.h"
-uint GetRoadFoundation(Slope tileh, RoadBits bits)
+Foundation GetRoadFoundation(Slope tileh, RoadBits bits)
 {
-	uint i;
+	if (!IsSteepSlope(tileh)) {
+		if ((~_valid_tileh_slopes_road[0][tileh] & bits) == 0) {
-	/* normal level sloped building */
+			/* As one can remove a single road piece when in a corner on a foundation as
-	if (!IsSteepSlope(tileh) &&
+			 * it is on a sloped piece of landscape, one creates a state that cannot be
-			(~_valid_tileh_slopes_road[1][tileh] & bits) == 0) {
+			 * created directly, but the state itself is still perfectly drawable.
-		return tileh;
+			 * However, as we do not want this to be build directly, we need to check
-	}
+			 * for that situation in here. */
+			return (tileh != 0 && HAS_SINGLE_BIT(bits)) ? FOUNDATION_LEVELED : FOUNDATION_NONE;
-	/* inclined sloped building */
+		}
-	switch (bits) {
+		if ((~_valid_tileh_slopes_road[1][tileh] & bits) == 0) return FOUNDATION_LEVELED;
-		case ROAD_X: i = 0; break;
+	}
-		case ROAD_Y: i = 1; break;
-		default:     return 0;
+	return (bits == ROAD_X ? FOUNDATION_INCLINED_X : FOUNDATION_INCLINED_Y);
-	}
-	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;
 }
 const byte _road_sloped_sprites[14] = {
 	0,  0,  2,  0,
 	0,  1,  0,  0,
 	} else {
 		back  = SPR_TRAMWAY_BASE + _road_backpole_sprites_1[tram];
 		front = SPR_TRAMWAY_BASE + _road_frontwire_sprites_1[tram];
 	}
-	SpriteID pal = PAL_NONE;
+	AddSortableSpriteToDraw(back,  PAL_NONE, ti->x, ti->y, 16, 16, 0x1F, ti->z, HASBIT(_transparent_opt, TO_BUILDINGS));
-	if (HASBIT(_transparent_opt, TO_BUILDINGS)) {
+	AddSortableSpriteToDraw(front, PAL_NONE, ti->x, ti->y, 16, 16, 0x1F, ti->z, HASBIT(_transparent_opt, TO_BUILDINGS));
-		SETBIT(front, PALETTE_MODIFIER_TRANSPARENT);
-		SETBIT(back,  PALETTE_MODIFIER_TRANSPARENT);
-		pal = PALETTE_TO_TRANSPARENT;
-	}
-	AddSortableSpriteToDraw(back,  pal, ti->x, ti->y, 16, 16, 0x1F, ti->z);
-	AddSortableSpriteToDraw(front, pal, ti->x, ti->y, 16, 16, 0x1F, ti->z);
 }
 /**
 * Draws details on/around the road
 * @param img the sprite to draw
 	SpriteID image = 0;
 	SpriteID pal = PAL_NONE;
 	Roadside roadside;
 	if (ti->tileh != SLOPE_FLAT) {
-		int foundation = GetRoadFoundation(ti->tileh, road | tram);
+		DrawFoundation(ti, GetRoadFoundation(ti->tileh, road | tram));
-		if (foundation != 0) DrawFoundation(ti, foundation);
 		/* DrawFoundation() modifies ti.
 		 * Default sloped sprites.. */
 		if (ti->tileh != SLOPE_FLAT) image = _road_sloped_sprites[ti->tileh - 1] + 0x53F;
 	}
 		case ROAD_TILE_CROSSING: {
 			SpriteID image;
 			SpriteID pal = PAL_NONE;
 			Roadside roadside = GetRoadside(ti->tile);
-			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
+			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
 			image = GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.crossing;
 			if (GetCrossingRoadAxis(ti->tile) == AXIS_X) image++;
 			if (IsCrossingBarred(ti->tile)) image += 2;
 		case ROAD_TILE_DEPOT: {
 			const DrawTileSprites* dts;
 			const DrawTileSeqStruct* dtss;
 			SpriteID palette;
-			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
+			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
 			palette = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));
 			if (HASBIT(GetRoadTypes(ti->tile), ROADTYPE_TRAM)) {
 				dts =  &_tram_depot[GetRoadDepotDirection(ti->tile)];
 			for (dtss = dts->seq; dtss->image != 0; dtss++) {
 				SpriteID image = dtss->image;
 				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 = PAL_NONE;
 				}
 				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->size_z, ti->z,
+					HASBIT(_transparent_opt, TO_BUILDINGS)
 				);
 			}
 			break;
 		}
 	}
 	uint z;
 	Slope tileh = GetTileSlope(tile, &z);
 	if (tileh == SLOPE_FLAT) return z;
 	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
-		uint f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
+		Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
+		z += ApplyFoundationToSlope(f, &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_Road(TileIndex tile, Slope tileh)
+static Foundation GetFoundation_Road(TileIndex tile, Slope tileh)
 {
-	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;
 	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
-		uint f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
+		return GetRoadFoundation(tileh, GetAllRoadBits(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;
+		return FlatteningFoundation(tileh);
 	}
 }
 static void GetAcceptedCargo_Road(TileIndex tile, AcceptedCargo ac)
 {
 	AnimateTile_Road,        /* animate_tile_proc */
 	TileLoop_Road,           /* tile_loop_clear */
 	ChangeTileOwner_Road,    /* change_tile_owner_clear */
 	NULL,                    /* get_produced_cargo_proc */
 	VehicleEnter_Road,       /* vehicle_enter_tile_proc */
-	GetSlopeTileh_Road,      /* get_slope_tileh_proc */
+	GetFoundation_Road,      /* get_foundation_proc */
 };

branch	noai
changeset 9694	e72987579514
parent 9686	d3c195c226f9
child 9701	d1ac22c62f64