openttd-mini: comparison src/road

equal deleted inserted replaced

-:93ad0db32ea0
+:1411d08e26b3
 * @param pieces The RoadBits we want to add
 * @param existing The existent RoadBits of the current type
 * @param other The other existent RoadBits
 * @return The costs for these RoadBits on this slope
 */
-static CommandCost CheckRoadSlope(Slope tileh, RoadBits* pieces, RoadBits existing, RoadBits other)
+static CommandCost CheckRoadSlope(Slope tileh, RoadBits *pieces, RoadBits existing, RoadBits other)
 {
 	/* Remove already build pieces */
 	CLRBITS(*pieces, existing);
 	/* If we can't build anything stop here */
 * @param p2 the town that is building the road (0 if not applicable)
 */
 CommandCost CmdBuildRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	CommandCost cost(EXPENSES_CONSTRUCTION);
-	CommandCost ret;
 	RoadBits existing = ROAD_NONE;
 	RoadBits other_bits = ROAD_NONE;
 	/* Road pieces are max 4 bitset values (NE, NW, SE, SW) and town can only be non-zero
 	 * if a non-player is building the road */
 					goto do_clear;
 			}
 			break;
 		case MP_RAILWAY: {
-			Axis roaddir;
 			if (IsSteepSlope(tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 			}
 			/* Level crossings may only be built on these slopes */
 			if (!HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 			}
 			if (GetRailTileType(tile) != RAIL_TILE_NORMAL) goto do_clear;
+			Axis roaddir;
 			switch (GetTrackBits(tile)) {
 				case TRACK_BIT_X:
 					if (pieces & ROAD_X) goto do_clear;
 					roaddir = AXIS_Y;
 					break;
 			if (HasTileRoadType(tile, rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
 			/* Don't allow adding roadtype to the bridge/tunnel when vehicles are already driving on it */
 			if (GetVehicleTunnelBridge(tile, GetOtherTunnelBridgeEnd(tile)) != NULL) return CMD_ERROR;
 			break;
-		default:
+		default: {
 do_clear:;
-			ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+			CommandCost ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 			if (CmdFailed(ret)) return ret;
 			cost.AddCost(ret);
+		} break;
 	}
 	if (other_bits != pieces) {
 		/* Check the foundation/slopes when adding road/tram bits */
-		ret = CheckRoadSlope(tileh, &pieces, existing, other_bits);
+		CommandCost ret = CheckRoadSlope(tileh, &pieces, existing, other_bits);
 		/* Return an error if we need to build a foundation (ret != 0) but the
 		 * current patch-setting is turned off (or stupid AI@work) */
 		if (CmdFailed(ret) || (ret.GetCost() != 0 && !_patches.build_on_slopes)) {
 			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 		}
 * - p2 = (bit 3 + 4) - road type
 * - p2 = (bit 5) - set road direction
 */
 CommandCost CmdBuildLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	TileIndex start_tile, tile;
+	CommandCost cost(EXPENSES_CONSTRUCTION);
-	CommandCost ret, cost(EXPENSES_CONSTRUCTION);
 	bool had_bridge = false;
 	bool had_tunnel = false;
 	bool had_success = false;
 	DisallowedRoadDirections drd = DRD_NORTHBOUND;
 	_error_message = INVALID_STRING_ID;
 	if (p1 >= MapSize()) return CMD_ERROR;
-	start_tile = p1;
+	TileIndex start_tile = p1;
 	RoadType rt = (RoadType)GB(p2, 3, 2);
 	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;
 	/* Only drag in X or Y direction dictated by the direction variable */
 	if (!HasBit(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
 	 * when you just 'click' on one tile to build them. */
 	if (HasBit(p2, 2) == (start_tile == end_tile && HasBit(p2, 0) == HasBit(p2, 1))) drd ^= DRD_BOTH;
 	/* No disallowed direction bits have to be toggled */
 	if (!HasBit(p2, 5)) drd = DRD_NONE;
-	tile = start_tile;
+	TileIndex tile = start_tile;
 	/* Start tile is the small number. */
 	for (;;) {
 		RoadBits bits = HasBit(p2, 2) ? ROAD_Y : ROAD_X;
 		if (tile == end_tile && !HasBit(p2, 1)) bits &= ROAD_NW | ROAD_NE;
 		if (tile == start_tile && HasBit(p2, 0)) bits &= ROAD_SE | ROAD_SW;
-		ret = DoCommand(tile, drd << 6 | rt << 4 | bits, 0, flags, CMD_BUILD_ROAD);
+		CommandCost ret = DoCommand(tile, drd << 6 | rt << 4 | bits, 0, flags, CMD_BUILD_ROAD);
 		if (CmdFailed(ret)) {
 			if (_error_message != STR_1007_ALREADY_BUILT) return CMD_ERROR;
 		} else {
 			had_success = true;
 			/* Only pay for the upgrade on one side of the bridges and tunnels */
 * - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
 * - p2 = (bit 3 + 4) - road type
 */
 CommandCost CmdRemoveLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	TileIndex start_tile, tile;
+	CommandCost cost(EXPENSES_CONSTRUCTION);
-	CommandCost ret, cost(EXPENSES_CONSTRUCTION);
-	Money money;
 	if (p1 >= MapSize()) return CMD_ERROR;
-	start_tile = p1;
+	TileIndex start_tile = p1;
 	RoadType rt = (RoadType)GB(p2, 3, 2);
 	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	/* Only drag in X or Y direction dictated by the direction variable */
 	if (!HasBit(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
 		start_tile = end_tile;
 		end_tile = t;
 		p2 ^= IsInsideMM(p2 & 3, 1, 3) ? 3 : 0;
 	}
-	money = GetAvailableMoneyForCommand();
+	Money money = GetAvailableMoneyForCommand();
-	tile = start_tile;
+	TileIndex tile = start_tile;
 	/* Start tile is the small number. */
 	for (;;) {
 		RoadBits bits = HasBit(p2, 2) ? ROAD_Y : ROAD_X;
 		if (tile == end_tile && !HasBit(p2, 1)) bits &= ROAD_NW | ROAD_NE;
 		if (tile == start_tile && HasBit(p2, 0)) bits &= ROAD_SE | ROAD_SW;
 		/* try to remove the halves. */
 		if (bits != 0) {
-			ret = RemoveRoad(tile, flags & ~DC_EXEC, bits, rt, true);
+			CommandCost ret = RemoveRoad(tile, flags & ~DC_EXEC, bits, rt, true);
 			if (CmdSucceeded(ret)) {
 				if (flags & DC_EXEC) {
 					money -= ret.GetCost();
 					if (money < 0) {
 						_additional_cash_required = DoCommand(end_tile, start_tile, p2, flags & ~DC_EXEC, CMD_REMOVE_LONG_ROAD).GetCost();
 * @todo When checking for the tile slope,
 * distingush between "Flat land required" and "land sloped in wrong direction"
 */
 CommandCost CmdBuildRoadDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost cost;
-	Slope tileh;
 	DiagDirection dir = Extract<DiagDirection, 0>(p1);
 	RoadType rt = (RoadType)GB(p1, 2, 2);
 	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;
-	tileh = GetTileSlope(tile, NULL);
+	Slope tileh = GetTileSlope(tile, NULL);
 	if (tileh != SLOPE_FLAT && (
 				!_patches.build_on_slopes ||
 				IsSteepSlope(tileh) ||
 				!CanBuildDepotByTileh(dir, tileh)
 			)) {
 		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
 	}
-	cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+	CommandCost 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);
 	Depot *dep = new Depot(tile);
 	return cost.AddCost(_price.build_road_depot);
 }
 static CommandCost RemoveRoadDepot(TileIndex tile, uint32 flags)
 {
-	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)
+	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER) return CMD_ERROR;
-		return CMD_ERROR;
 	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DoClearSquare(tile);
 /**
 * Draws the catenary for the given tile
 * @param ti   information about the tile (slopes, height etc)
 * @param tram the roadbits for the tram
 */
-void DrawTramCatenary(TileInfo *ti, RoadBits tram)
+void DrawTramCatenary(const TileInfo *ti, RoadBits tram)
 {
 	/* Do not draw catenary if it is invisible */
 	if (IsInvisibilitySet(TO_CATENARY)) return;
 	/* Don't draw the catenary under a low bridge */
 * @param ti  the tile to draw on
 * @param dx  the offset from the top of the BB of the tile
 * @param dy  the offset from the top of the BB of the tile
 * @param h   the height of the sprite to draw
 */
-static void DrawRoadDetail(SpriteID img, TileInfo *ti, int dx, int dy, int h)
+static void DrawRoadDetail(SpriteID img, const TileInfo *ti, int dx, int dy, int h)
 {
 	int x = ti->x | dx;
 	int y = ti->y | dy;
 	byte z = ti->z;
 	if (ti->tileh != SLOPE_FLAT) z = GetSlopeZ(x, y);
 /**
 * Draw ground sprite and road pieces
 * @param ti TileInfo
 */
-static void DrawRoadBits(TileInfo* ti)
+static void DrawRoadBits(TileInfo *ti)
 {
 	RoadBits road = GetRoadBits(ti->tile, ROADTYPE_ROAD);
 	RoadBits tram = GetRoadBits(ti->tile, ROADTYPE_TRAM);
-	const DrawRoadTileStruct *drts;
 	SpriteID image = 0;
 	SpriteID pal = PAL_NONE;
-	Roadside roadside;
 	if (ti->tileh != SLOPE_FLAT) {
 		DrawFoundation(ti, GetRoadFoundation(ti->tileh, road | tram));
 		/* DrawFoundation() modifies ti.
 		if (ti->tileh != SLOPE_FLAT) image = _road_sloped_sprites[ti->tileh - 1] + 0x53F;
 	}
 	if (image == 0) image = _road_tile_sprites_1[road != ROAD_NONE ? road : tram];
-	roadside = GetRoadside(ti->tile);
+	Roadside roadside = GetRoadside(ti->tile);
 	if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
 		image += 19;
 	} else {
 		switch (roadside) {
 	/* If there are no road bits, return, as there is nothing left to do */
 	if (CountBits(road) < 2) return;
 	/* Draw extra details. */
-	for (drts = _road_display_table[roadside][road | tram]; drts->image != 0; drts++) {
+	for (const DrawRoadTileStruct *drts = _road_display_table[roadside][road | tram]; drts->image != 0; drts++) {
 		DrawRoadDetail(drts->image, ti, drts->subcoord_x, drts->subcoord_y, 0x10);
 	}
 }
 static void DrawTile_Road(TileInfo *ti)
 		case ROAD_TILE_NORMAL:
 			DrawRoadBits(ti);
 			break;
 		case ROAD_TILE_CROSSING: {
-			SpriteID image;
+			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
+			SpriteID image = GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.crossing;
 			SpriteID pal = PAL_NONE;
-			Roadside roadside = GetRoadside(ti->tile);
-			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;
+			Roadside roadside = GetRoadside(ti->tile);
 			if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
 				image += 8;
 			} else {
 				switch (roadside) {
 			break;
 		}
 		default:
 		case ROAD_TILE_DEPOT: {
-			const DrawTileSprites* dts;
-			const DrawTileSeqStruct* dtss;
-			SpriteID palette;
 			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
-			palette = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));
+			SpriteID palette = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));
+			const DrawTileSprites *dts;
 			if (HasTileRoadType(ti->tile, ROADTYPE_TRAM)) {
 				dts =  &_tram_depot[GetRoadDepotDirection(ti->tile)];
 			} else {
 				dts =  &_road_depot[GetRoadDepotDirection(ti->tile)];
 			}
 			DrawGroundSprite(dts->ground.sprite, PAL_NONE);
 			/* End now if buildings are invisible */
 			if (IsInvisibilitySet(TO_BUILDINGS)) break;
-			for (dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
+			for (const DrawTileSeqStruct *dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
 				SpriteID image = dtss->image.sprite;
 				SpriteID pal;
 				if (!IsTransparencySet(TO_BUILDINGS) && HasBit(image, PALETTE_MODIFIER_COLOR)) {
 					pal = palette;
 }
 void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt)
 {
 	SpriteID palette = PLAYER_SPRITE_COLOR(_local_player);
-	const DrawTileSprites* dts = (rt == ROADTYPE_TRAM) ? &_tram_depot[dir] : &_road_depot[dir];
+	const DrawTileSprites *dts = (rt == ROADTYPE_TRAM) ? &_tram_depot[dir] : &_road_depot[dir];
-	const DrawTileSeqStruct* dtss;
 	x += 33;
 	y += 17;
 	DrawSprite(dts->ground.sprite, PAL_NONE, x, y);
-	for (dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
+	for (const DrawTileSeqStruct *dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
 		Point pt = RemapCoords(dtss->delta_x, dtss->delta_y, dtss->delta_z);
 		SpriteID image = dtss->image.sprite;
 		DrawSprite(image, HasBit(image, PALETTE_MODIFIER_COLOR) ? palette : PAL_NONE, x + pt.x, y + pt.y);
 	}
 			break;
 	}
 	if (IsRoadDepot(tile)) return;
-	const Town* t = ClosestTownFromTile(tile, (uint)-1);
+	const Town *t = ClosestTownFromTile(tile, (uint)-1);
 	if (!HasRoadWorks(tile)) {
 		HouseZonesBits grp = HZB_TOWN_EDGE;
 		if (t != NULL) {
 			grp = GetTownRadiusGroup(t, tile);

changeset 8821	1411d08e26b3
parent 8806	4fe163e0b52a
child 8859	b527de22bf3e