diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp --- a/src/town_cmd.cpp +++ b/src/town_cmd.cpp @@ -133,18 +133,6 @@ static inline DiagDirection RandomDiagDi } /** - * Move a TileIndex into a diagonal direction. - * - * @param tile The current tile - * @param dir The direction in which we want to step - * @return the moved tile - */ -static inline TileIndex AddDiagDirToTileIndex(TileIndex tile, DiagDirection dir) -{ - return TILE_ADD(tile, TileOffsByDiagDir(dir)); -} - -/** * House Tile drawing handler. * Part of the tile loop process * @param ti TileInfo of the tile to draw @@ -661,7 +649,7 @@ static RoadBits GetTownRoadBits(TileInde */ static bool IsNeighborRoadTile(TileIndex tile, DiagDirection dir, uint dist_multi) { - static TileIndexDiff tid_lt[3]; ///< lookup table for the used diff values + static TileIndexDiff tid_lt[3]; // lookup table for the used diff values tid_lt[0] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT)); tid_lt[1] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT)); tid_lt[2] = TileOffsByDiagDir(ReverseDiagDir(dir)); @@ -681,7 +669,7 @@ static bool IsNeighborRoadTile(TileIndex cur += tid_lt[(pos & 1) ? 0 : 1]; if (pos & 2) cur += tid_lt[2]; - cur = (uint)(pos / 4) * cur; ///< Multiply for the fitting distance + cur = (uint)(pos / 4) * cur; // Multiply for the fitting distance if (GetTownRoadBits(TILE_ADD(tile, cur)) & DiagDirToRoadBits((pos & 2) ? dir : ReverseDiagDir(dir))) return true; } return false; @@ -797,7 +785,7 @@ static void LevelTownLand(TileIndex tile static RoadBits GetTownRoadGridElement(Town* t, TileIndex tile, DiagDirection dir) { /* align the grid to the downtown */ - TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); ///< Vector from downtown to the tile + TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); // Vector from downtown to the tile RoadBits rcmd = ROAD_NONE; switch (_patches.town_layout) { @@ -849,32 +837,110 @@ static RoadBits GetTownRoadGridElement(T } /** - * Check there are enough neighbor house tiles next to the current tile + * Grows the town with an extra house. + * Check if there are enough neighbor house tiles + * next to the current tile. If there are enough + * add another house. * - * @param tile current tile - * @return true if there are more than 2 house tiles next - * to the current one + * @param t The current town + * @param tile The target tile for the extra house + * @return true if an extra house has been added */ -static bool AreNeighborsHouseTiles(TileIndex tile) +static bool GrowTownWithExtraHouse(Town *t, TileIndex tile) { - uint counter = 0; ///< counts the house neighbor tiles - /* We can't look further than that. */ - if (TileX(tile) < 1 || TileY(tile) < 1) { - return false; + if (TileX(tile) < 2 || TileY(tile) < 2 || MapMaxX() <= TileX(tile) || MapMaxY() <= TileY(tile)) return false; + + uint counter = 0; // counts the house neighbor tiles + + /* Check the tiles E,N,W and S of the current tile for houses */ + for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) { + + if (IsTileType(TileAddByDiagDir(tile, dir), MP_HOUSE)) counter++; + + /* If there are enough neighbors stop here */ + if (counter >= 3) { + if (BuildTownHouse(t, tile)) { + _grow_town_result = -1; + return true; + } + return false; + } + } + return false; +} + +/** + * Grows the town with a road piece. + * + * @param t The current town + * @param tile The current tile + * @param rcmd The RoadBits we want to build on the tile + * @return true if the RoadBits have been added else false + */ +static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd) +{ + if (CmdSucceeded(DoCommand(tile, rcmd, t->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) { + _grow_town_result = -1; + return true; } - - /* Check the tiles E,N,W and S of the current tile. */ - for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) { - if (IsTileType(AddDiagDirToTileIndex(tile, i), MP_HOUSE)) { - counter++; + return false; +} + +/** + * Grows the town with a bridge. + * At first we check if a bridge is reasonable. + * If so we check if we are able to build it. + * + * @param t The current town + * @param tile The current tile + * @param rcmd The RoadBits which are possible on this tile + * @return true if a bridge has been build else false + */ +static bool GrowTownWithBridge(const Town *t, TileIndex tile, RoadBits rcmd) +{ + DiagDirection bridge_dir; // The direction of a bridge we maybe want to build + + /* Determine direction of slope, + * and build a road if not a special slope. */ + switch (GetTileSlope(tile, NULL)) { + case SLOPE_SW: bridge_dir = DIAGDIR_NE; break; + case SLOPE_SE: bridge_dir = DIAGDIR_NW; break; + case SLOPE_NW: bridge_dir = DIAGDIR_SE; break; + case SLOPE_NE: bridge_dir = DIAGDIR_SW; break; + + default: return false; + } + + /* Check if the bridge will be compatible to the RoadBits */ + if (!(rcmd & DiagDirToRoadBits(ReverseDiagDir(bridge_dir)))) return false; + + /* We are in the right direction */ + uint32 bridge_length = 0; // This value stores the length of the possible bridge + TileIndex bridge_tile = tile; // Used to store the other waterside + + do { + if (bridge_length++ >= 11) { + /* Max 11 tile long bridges */ + return false; } - - /* If there are enougth neighbor's stop it here */ - if (counter >= 3) { + bridge_tile = TILE_MASK(bridge_tile + TileOffsByDiagDir(bridge_dir)); + } while (IsClearWaterTile(bridge_tile)); + + /* no water tiles in between? */ + if (bridge_length == 1) return false; + + for (uint8 times = 0; times <= 22; times++) { + byte bridge_type = RandomRange(MAX_BRIDGES - 1); + + /* Can we actually build the bridge? */ + if (CmdSucceeded(DoCommand(tile, bridge_tile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE))) { + DoCommand(tile, bridge_tile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE); + _grow_town_result--; return true; } } + /* Quit if it selecting an appropiate bridge type fails a large number of times. */ return false; } @@ -882,25 +948,24 @@ static bool AreNeighborsHouseTiles(TileI * Grows the given town. * There are at the moment 3 possible way's for * the town expansion: - * @li Generate a random tile and check if there is a road allowed - * @li TL_ORIGINAL - * @li TL_BETTER_ROADS - * @li Check if the town geometry allows a road and which one - * @li TL_2X2_GRID - * @li TL_3X3_GRID - * @li Forbid roads, only build houses - * @li TL_NO_ROADS + * @li Generate a random tile and check if there is a road allowed + * @li TL_ORIGINAL + * @li TL_BETTER_ROADS + * @li Check if the town geometry allows a road and which one + * @li TL_2X2_GRID + * @li TL_3X3_GRID + * @li Forbid roads, only build houses + * @li TL_NO_ROADS * * @param tile_ptr The current tile * @param cur_rb The current tiles RoadBits * @param target_dir The target road dir * @param t1 The current town */ -static void GrowTownInTile(TileIndex* tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town* t1) +static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1) { - RoadBits rcmd = ROAD_NONE; ///< RoadBits for the road construction command - TileIndex tmptile; ///< Dummy tile for various things - TileIndex tile = *tile_ptr; ///< The main tile on which we base our growth + RoadBits rcmd = ROAD_NONE; // RoadBits for the road construction command + TileIndex tile = *tile_ptr; // The main tile on which we base our growth TILE_ASSERT(tile); @@ -936,14 +1001,14 @@ static void GrowTownInTile(TileIndex* ti do target_dir = RandomDiagDir(); while (target_dir == source_dir); } - if (!IsRoadAllowedHere(AddDiagDirToTileIndex(tile, target_dir), target_dir)) { + if (!IsRoadAllowedHere(TileAddByDiagDir(tile, target_dir), target_dir)) { /* A road is not allowed to continue the randomized road, * return if the road we're trying to build is curved. */ if (target_dir != ReverseDiagDir(source_dir)) return; /* Return if neither side of the new road is a house */ - if (!IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) && - !IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90LEFT)), MP_HOUSE)) { + if (!IsTileType(TileAddByDiagDir(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) && + !IsTileType(TileAddByDiagDir(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90LEFT)), MP_HOUSE)) { return; } @@ -955,7 +1020,7 @@ static void GrowTownInTile(TileIndex* ti break; } - } else if (target_dir < (DiagDirection)5 && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) { + } else if (target_dir < DIAGDIR_END && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) { /* Continue building on a partial road. * Should be allways OK, so we only generate * the fitting RoadBits */ @@ -978,8 +1043,7 @@ static void GrowTownInTile(TileIndex* ti break; } } else { - bool allow_house = false; ///< Value which decides if we want to construct a house - TileIndex tmptile2; ///< Yet another dummy tile + bool allow_house = false; // Value which decides if we want to construct a house /* Reached a tunnel/bridge? Then continue at the other side of it. */ if (IsTileType(tile, MP_TUNNELBRIDGE)) { @@ -997,10 +1061,10 @@ static void GrowTownInTile(TileIndex* ti if (cur_rb & DiagDirToRoadBits(target_dir)) return; /* This is the tile we will reach if we extend to this direction. */ - tmptile = AddDiagDirToTileIndex(tile, target_dir); + TileIndex house_tile = TileAddByDiagDir(tile, target_dir); // position of a possible house /* Don't walk into water. */ - if (IsClearWaterTile(tmptile)) return; + if (IsClearWaterTile(house_tile)) return; switch (_patches.town_layout) { default: NOT_REACHED(); @@ -1010,41 +1074,35 @@ static void GrowTownInTile(TileIndex* ti break; case TL_3X3_GRID: /* Use 2x2 grid afterwards! */ - /* Fill gap if house has enougth neighbors */ - tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir); - if (AreNeighborsHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) { - _grow_town_result = -1; - } + GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir)); + /* FALL THROUGH */ case TL_2X2_GRID: - rcmd = GetTownRoadGridElement(t1, tmptile, target_dir); + rcmd = GetTownRoadGridElement(t1, house_tile, target_dir); allow_house = (rcmd == ROAD_NONE); break; case TL_BETTER_ROADS: /* Use original afterwards! */ - /* Fill gap if house has enougth neighbors */ - tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir); - if (AreNeighborsHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) { - _grow_town_result = -1; - } + GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir)); + /* FALL THROUGH */ case TL_ORIGINAL: /* Allow a house at the edge. 60% chance or * always ok if no road allowed. */ rcmd = DiagDirToRoadBits(target_dir); - allow_house = (!IsRoadAllowedHere(tmptile, target_dir) || CHANCE16(6, 10)); + allow_house = (!IsRoadAllowedHere(house_tile, target_dir) || CHANCE16(6, 10)); break; } if (allow_house) { /* Build a house, but not if there already is a house there. */ - if (!IsTileType(tmptile, MP_HOUSE)) { + if (!IsTileType(house_tile, MP_HOUSE)) { /* Level the land if possible */ - LevelTownLand(tmptile); + LevelTownLand(house_tile); /* And build a house. * Set result to -1 if we managed to build it. */ - if (BuildTownHouse(t1, tmptile)) { + if (BuildTownHouse(t1, house_tile)) { _grow_town_result = -1; } } @@ -1057,51 +1115,13 @@ static void GrowTownInTile(TileIndex* ti /* Return if a water tile */ if (IsClearWaterTile(tile)) return; - DiagDirection bridge_dir; ///< The direction of a bridge we maybe want to build - /* Determine direction of slope, - * and build a road if not a special slope. */ - switch (GetTileSlope(tile, NULL)) { - case SLOPE_SW: bridge_dir = DIAGDIR_NE; break; - case SLOPE_SE: bridge_dir = DIAGDIR_NW; break; - case SLOPE_NW: bridge_dir = DIAGDIR_SE; break; - case SLOPE_NE: bridge_dir = DIAGDIR_SW; break; - - default: -build_road_and_exit: - if (CmdSucceeded(DoCommand(tile, rcmd, t1->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) { - _grow_town_result = -1; - } - return; - } - - /* Check if the bridge is in the right direction */ - if (!(rcmd & DiagDirToRoadBits(bridge_dir))) goto build_road_and_exit; - - /* We are in the right direction */ - uint32 bridge_length = 0; ///< This value stores the length of the possible bridge - tmptile = tile; ///< Now we use this dummy to store the other waterside - do { - if (bridge_length++ >= 11) { - /* Max 11 tile long bridges */ - goto build_road_and_exit; - } - tmptile = TILE_MASK(tmptile + TileOffsByDiagDir(bridge_dir)); - } while (IsClearWaterTile(tmptile)); - - /* no water tiles in between? */ - if (bridge_length == 1) goto build_road_and_exit; - - for (uint times = 0; times <= 22; times++) { - byte bridge_type = RandomRange(MAX_BRIDGES - 1); - - /* Can we actually build the bridge? */ - if (CmdSucceeded(DoCommand(tile, tmptile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE))) { - DoCommand(tile, tmptile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE); - _grow_town_result = -1; - return; - } - } - /* Quit if it selecting an appropiate bridge type fails a large number of times. */ + /* Make the roads look nicer */ + rcmd = CleanUpRoadBits(tile, rcmd); + if (rcmd == ROAD_NONE) return; + + if (GrowTownWithBridge(t1, tile, rcmd)) return; + + GrowTownWithRoad(t1, tile, rcmd); } /** Returns "growth" if a house was built, or no if the build failed. @@ -1114,7 +1134,7 @@ static int GrowTownAtRoad(Town *t, TileI /* Special case. * @see GrowTownInTile Check the else if */ - DiagDirection target_dir = (DiagDirection)5; ///< The direction in which we want to extend the town + DiagDirection target_dir = DIAGDIR_END; // The direction in which we want to extend the town TILE_ASSERT(tile); @@ -1137,7 +1157,7 @@ static int GrowTownAtRoad(Town *t, TileI } do { - RoadBits cur_rb = GetTownRoadBits(tile); ///< The RoadBits of the current tile + RoadBits cur_rb = GetTownRoadBits(tile); // The RoadBits of the current tile /* Try to grow the town from this point */ GrowTownInTile(&tile, cur_rb, target_dir, t); @@ -1151,7 +1171,7 @@ static int GrowTownAtRoad(Town *t, TileI /* Select a random bit from the blockmask, walk a step * and continue the search from there. */ do target_dir = RandomDiagDir(); while (!(cur_rb & DiagDirToRoadBits(target_dir))); - tile = AddDiagDirToTileIndex(tile, target_dir); + tile = TileAddByDiagDir(tile, target_dir); if (IsTileType(tile, MP_ROAD)) { /* Don't allow building over roads of other cities */ @@ -1220,7 +1240,7 @@ static bool GrowTown(Town *t) PlayerID old_player = _current_player; _current_player = OWNER_TOWN; - TileIndex tile = t->xy; ///< The tile we are working with ATM + TileIndex tile = t->xy; // The tile we are working with ATM /* Find a road that we can base the construction on. */ for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) { @@ -2110,8 +2130,8 @@ static void UpdateTownGrowRate(Town *t) /** Towns are processed every TOWN_GROWTH_FREQUENCY ticks, and this is the * number of times towns are processed before a new building is built. */ static const uint16 _grow_count_values[2][6] = { - { 120, 120, 120, 100, 80, 60 }, ///< Fund new buildings has been activated - { 320, 420, 300, 220, 160, 100 } ///< Normal values + { 120, 120, 120, 100, 80, 60 }, // Fund new buildings has been activated + { 320, 420, 300, 220, 160, 100 } // Normal values }; if (t->fund_buildings_months != 0) { @@ -2252,9 +2272,9 @@ void ChangeTownRating(Town *t, int add, /* penalty for removing town-owned stuff */ static const int _default_rating_settings [3][3] = { /* ROAD_REMOVE, TUNNELBRIDGE_REMOVE, INDUSTRY_REMOVE */ - { 0, 128, 384}, ///< Permissive - { 48, 192, 480}, ///< Neutral - { 96, 384, 768}, ///< Hostile + { 0, 128, 384}, // Permissive + { 48, 192, 480}, // Neutral + { 96, 384, 768}, // Hostile }; bool CheckforTownRating(uint32 flags, Town *t, byte type)