src/clear_cmd.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file clear_cmd.cpp Commands related to clear tiles. */
   9
  10 #include "stdafx.h"
  11 #include "clear_map.h"
  12 #include "command_func.h"
  13 #include "landscape.h"
  14 #include "genworld.h"
  15 #include "viewport_func.h"
  16 #include "water.h"
  17 #include "core/random_func.hpp"
  18 #include "newgrf_generic.h"
  19
  20 #include "table/strings.h"
  21 #include "table/sprites.h"
  22 #include "table/clear_land.h"
  23
  24 #include "safeguards.h"
  25
  26 static CommandCost ClearTile_Clear(TileIndex tile, DoCommandFlag flags)
  27 {
  28         static const Price clear_price_table[] = {
  29                 PR_CLEAR_GRASS,
  30                 PR_CLEAR_ROUGH,
  31                 PR_CLEAR_ROCKS,
  32                 PR_CLEAR_FIELDS,
  33                 PR_CLEAR_ROUGH,
  34                 PR_CLEAR_ROUGH,
  35         };
  36         CommandCost price(EXPENSES_CONSTRUCTION);
  37
  38         if (!IsClearGround(tile, CLEAR_GRASS) || GetClearDensity(tile) != 0) {
  39                 price.AddCost(_price[clear_price_table[GetClearGround(tile)]]);
  40         }
  41
  42         if (flags & DC_EXEC) DoClearSquare(tile);
  43
  44         return price;
  45 }
  46
  47 void DrawClearLandTile(const TileInfo *ti, byte set)
  48 {
  49         DrawGroundSprite(SPR_FLAT_BARE_LAND + SlopeToSpriteOffset(ti->tileh) + set * 19, PAL_NONE);
  50 }
  51
  52 void DrawHillyLandTile(const TileInfo *ti)
  53 {
  54         if (ti->tileh != SLOPE_FLAT) {
  55                 DrawGroundSprite(SPR_FLAT_ROUGH_LAND + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
  56         } else {
  57                 DrawGroundSprite(_landscape_clear_sprites_rough[GB(TileHash(ti->x, ti->y), 0, 3)], PAL_NONE);
  58         }
  59 }
  60
  61 static void DrawClearLandFence(const TileInfo *ti)
  62 {
  63         /* combine fences into one sprite object */
  64         StartSpriteCombine();
  65
  66         int maxz = GetSlopeMaxPixelZ(ti->tileh);
  67
  68         uint fence_nw = GetFence(ti->tile, DIAGDIR_NW);
  69         if (fence_nw != 0) {
  70                 int z = GetSlopePixelZInCorner(ti->tileh, CORNER_W);
  71                 SpriteID sprite = _clear_land_fence_sprites[fence_nw - 1] + _fence_mod_by_tileh_nw[ti->tileh];
  72                 AddSortableSpriteToDraw(sprite, PAL_NONE, ti->x, ti->y - 15, 16, 31, maxz - z + 4, ti->z + z, false, 0, 15, -z);
  73         }
  74
  75         uint fence_ne = GetFence(ti->tile, DIAGDIR_NE);
  76         if (fence_ne != 0) {
  77                 int z = GetSlopePixelZInCorner(ti->tileh, CORNER_E);
  78                 SpriteID sprite = _clear_land_fence_sprites[fence_ne - 1] + _fence_mod_by_tileh_ne[ti->tileh];
  79                 AddSortableSpriteToDraw(sprite, PAL_NONE, ti->x - 15, ti->y, 31, 16, maxz - z + 4, ti->z + z, false, 15, 0, -z);
  80         }
  81
  82         uint fence_sw = GetFence(ti->tile, DIAGDIR_SW);
  83         uint fence_se = GetFence(ti->tile, DIAGDIR_SE);
  84
  85         if (fence_sw != 0 || fence_se != 0) {
  86                 int z = GetSlopePixelZInCorner(ti->tileh, CORNER_S);
  87
  88                 if (fence_sw != 0) {
  89                         SpriteID sprite = _clear_land_fence_sprites[fence_sw - 1] + _fence_mod_by_tileh_sw[ti->tileh];
  90                         AddSortableSpriteToDraw(sprite, PAL_NONE, ti->x, ti->y, 16, 16, maxz - z + 4, ti->z + z, false, 0, 0, -z);
  91                 }
  92
  93                 if (fence_se != 0) {
  94                         SpriteID sprite = _clear_land_fence_sprites[fence_se - 1] + _fence_mod_by_tileh_se[ti->tileh];
  95                         AddSortableSpriteToDraw(sprite, PAL_NONE, ti->x, ti->y, 16, 16, maxz - z + 4, ti->z + z, false, 0, 0, -z);
  96                 }
  97         }
  98         EndSpriteCombine();
  99 }
 100
 101 static void DrawTile_Clear(TileInfo *ti)
 102 {
 103         switch (GetClearGround(ti->tile)) {
 104                 case CLEAR_GRASS:
 105                         DrawClearLandTile(ti, GetClearDensity(ti->tile));
 106                         break;
 107
 108                 case CLEAR_ROUGH:
 109                         DrawHillyLandTile(ti);
 110                         break;
 111
 112                 case CLEAR_ROCKS:
 113                         DrawGroundSprite((HasGrfMiscBit(GMB_SECOND_ROCKY_TILE_SET) && (TileHash(ti->x, ti->y) & 1) ? SPR_FLAT_ROCKY_LAND_2 : SPR_FLAT_ROCKY_LAND_1) + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
 114                         break;
 115
 116                 case CLEAR_FIELDS:
 117                         DrawGroundSprite(_clear_land_sprites_farmland[GetFieldType(ti->tile)] + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
 118                         DrawClearLandFence(ti);
 119                         break;
 120
 121                 case CLEAR_SNOW:
 122                 case CLEAR_DESERT:
 123                         DrawGroundSprite(_clear_land_sprites_snow_desert[GetClearDensity(ti->tile)] + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
 124                         break;
 125         }
 126
 127         DrawBridgeMiddle(ti);
 128 }
 129
 130 static int GetSlopePixelZ_Clear(TileIndex tile, uint x, uint y)
 131 {
 132         int z;
 133         Slope tileh = GetTilePixelSlope(tile, &z);
 134
 135         return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 136 }
 137
 138 static Foundation GetFoundation_Clear(TileIndex tile, Slope tileh)
 139 {
 140         return FOUNDATION_NONE;
 141 }
 142
 143 static void UpdateFences(TileIndex tile)
 144 {
 145         assert(IsTileType(tile, MP_CLEAR) && IsClearGround(tile, CLEAR_FIELDS));
 146         bool dirty = false;
 147
 148         bool neighbour = (IsTileType(TILE_ADDXY(tile, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 1, 0), CLEAR_FIELDS));
 149         if (!neighbour && GetFence(tile, DIAGDIR_SW) == 0) {
 150                 SetFence(tile, DIAGDIR_SW, 3);
 151                 dirty = true;
 152         }
 153
 154         neighbour = (IsTileType(TILE_ADDXY(tile, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 0, 1), CLEAR_FIELDS));
 155         if (!neighbour && GetFence(tile, DIAGDIR_SE) == 0) {
 156                 SetFence(tile, DIAGDIR_SE, 3);
 157                 dirty = true;
 158         }
 159
 160         neighbour = (IsTileType(TILE_ADDXY(tile, -1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, -1, 0), CLEAR_FIELDS));
 161         if (!neighbour && GetFence(tile, DIAGDIR_NE) == 0) {
 162                 SetFence(tile, DIAGDIR_NE, 3);
 163                 dirty = true;
 164         }
 165
 166         neighbour = (IsTileType(TILE_ADDXY(tile, 0, -1), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 0, -1), CLEAR_FIELDS));
 167         if (!neighbour && GetFence(tile, DIAGDIR_NW) == 0) {
 168                 SetFence(tile, DIAGDIR_NW, 3);
 169                 dirty = true;
 170         }
 171
 172         if (dirty) MarkTileDirtyByTile(tile);
 173 }
 174
 175
 176 /** Convert to or from snowy tiles. */
 177 static void TileLoopClearAlps(TileIndex tile)
 178 {
 179         int k = GetTileZ(tile) - GetSnowLine() + 1;
 180
 181         if (k < 0) {
 182                 /* Below the snow line, do nothing if no snow. */
 183                 if (!IsSnowTile(tile)) return;
 184         } else {
 185                 /* At or above the snow line, make snow tile if needed. */
 186                 if (!IsSnowTile(tile)) {
 187                         MakeSnow(tile);
 188                         MarkTileDirtyByTile(tile);
 189                         return;
 190                 }
 191         }
 192         /* Update snow density. */
 193         uint current_density = GetClearDensity(tile);
 194         uint req_density = (k < 0) ? 0u : std::min<uint>(k, 3u);
 195
 196         if (current_density < req_density) {
 197                 AddClearDensity(tile, 1);
 198         } else if (current_density > req_density) {
 199                 AddClearDensity(tile, -1);
 200         } else {
 201                 /* Density at the required level. */
 202                 if (k >= 0) return;
 203                 ClearSnow(tile);
 204         }
 205         MarkTileDirtyByTile(tile);
 206 }
 207
 208 /**
 209  * Tests if at least one surrounding tile is non-desert
 210  * @param tile tile to check
 211  * @return does this tile have at least one non-desert tile around?
 212  */
 213 static inline bool NeighbourIsNormal(TileIndex tile)
 214 {
 215         for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
 216                 TileIndex t = tile + TileOffsByDiagDir(dir);
 217                 if (!IsValidTile(t)) continue;
 218                 if (GetTropicZone(t) != TROPICZONE_DESERT) return true;
 219                 if (HasTileWaterClass(t) && GetWaterClass(t) == WATER_CLASS_SEA) return true;
 220         }
 221         return false;
 222 }
 223
 224 static void TileLoopClearDesert(TileIndex tile)
 225 {
 226         /* Current desert level - 0 if it is not desert */
 227         uint current = 0;
 228         if (IsClearGround(tile, CLEAR_DESERT)) current = GetClearDensity(tile);
 229
 230         /* Expected desert level - 0 if it shouldn't be desert */
 231         uint expected = 0;
 232         if (GetTropicZone(tile) == TROPICZONE_DESERT) {
 233                 expected = NeighbourIsNormal(tile) ? 1 : 3;
 234         }
 235
 236         if (current == expected) return;
 237
 238         if (expected == 0) {
 239                 SetClearGroundDensity(tile, CLEAR_GRASS, 3);
 240         } else {
 241                 /* Transition from clear to desert is not smooth (after clearing desert tile) */
 242                 SetClearGroundDensity(tile, CLEAR_DESERT, expected);
 243         }
 244
 245         MarkTileDirtyByTile(tile);
 246 }
 247
 248 static void TileLoop_Clear(TileIndex tile)
 249 {
 250         /* If the tile is at any edge flood it to prevent maps without water. */
 251         if (_settings_game.construction.freeform_edges && DistanceFromEdge(tile) == 1) {
 252                 int z;
 253                 if (IsTileFlat(tile, &z) && z == 0) {
 254                         DoFloodTile(tile);
 255                         MarkTileDirtyByTile(tile);
 256                         return;
 257                 }
 258         }
 259         AmbientSoundEffect(tile);
 260
 261         switch (_settings_game.game_creation.landscape) {
 262                 case LT_TROPIC: TileLoopClearDesert(tile); break;
 263                 case LT_ARCTIC: TileLoopClearAlps(tile);   break;
 264         }
 265
 266         switch (GetClearGround(tile)) {
 267                 case CLEAR_GRASS:
 268                         if (GetClearDensity(tile) == 3) return;
 269
 270                         if (_game_mode != GM_EDITOR) {
 271                                 if (GetClearCounter(tile) < 7) {
 272                                         AddClearCounter(tile, 1);
 273                                         return;
 274                                 } else {
 275                                         SetClearCounter(tile, 0);
 276                                         AddClearDensity(tile, 1);
 277                                 }
 278                         } else {
 279                                 SetClearGroundDensity(tile, GB(Random(), 0, 8) > 21 ? CLEAR_GRASS : CLEAR_ROUGH, 3);
 280                         }
 281                         break;
 282
 283                 case CLEAR_FIELDS:
 284                         UpdateFences(tile);
 285
 286                         if (_game_mode == GM_EDITOR) return;
 287
 288                         if (GetClearCounter(tile) < 7) {
 289                                 AddClearCounter(tile, 1);
 290                                 return;
 291                         } else {
 292                                 SetClearCounter(tile, 0);
 293                         }
 294
 295                         if (GetIndustryIndexOfField(tile) == INVALID_INDUSTRY && GetFieldType(tile) >= 7) {
 296                                 /* This farmfield is no longer farmfield, so make it grass again */
 297                                 MakeClear(tile, CLEAR_GRASS, 2);
 298                         } else {
 299                                 uint field_type = GetFieldType(tile);
 300                                 field_type = (field_type < 8) ? field_type + 1 : 0;
 301                                 SetFieldType(tile, field_type);
 302                         }
 303                         break;
 304
 305                 default:
 306                         return;
 307         }
 308
 309         MarkTileDirtyByTile(tile);
 310 }
 311
 312 void GenerateClearTile()
 313 {
 314         uint i, gi;
 315         TileIndex tile;
 316
 317         /* add rough tiles */
 318         i = ScaleByMapSize(GB(Random(), 0, 10) + 0x400);
 319         gi = ScaleByMapSize(GB(Random(), 0, 7) + 0x80);
 320
 321         SetGeneratingWorldProgress(GWP_ROUGH_ROCKY, gi + i);
 322         do {
 323                 IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);
 324                 tile = RandomTile();
 325                 if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) SetClearGroundDensity(tile, CLEAR_ROUGH, 3);
 326         } while (--i);
 327
 328         /* add rocky tiles */
 329         i = gi;
 330         do {
 331                 uint32 r = Random();
 332                 tile = RandomTileSeed(r);
 333
 334                 IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);
 335                 if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) {
 336                         uint j = GB(r, 16, 4) + 5;
 337                         for (;;) {
 338                                 TileIndex tile_new;
 339
 340                                 SetClearGroundDensity(tile, CLEAR_ROCKS, 3);
 341                                 MarkTileDirtyByTile(tile);
 342                                 do {
 343                                         if (--j == 0) goto get_out;
 344                                         tile_new = tile + TileOffsByDiagDir((DiagDirection)GB(Random(), 0, 2));
 345                                 } while (!IsTileType(tile_new, MP_CLEAR) || IsClearGround(tile_new, CLEAR_DESERT));
 346                                 tile = tile_new;
 347                         }
 348 get_out:;
 349                 }
 350         } while (--i);
 351 }
 352
 353 static TrackStatus GetTileTrackStatus_Clear(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
 354 {
 355         return 0;
 356 }
 357
 358 static const StringID _clear_land_str[] = {
 359         STR_LAI_CLEAR_DESCRIPTION_GRASS,
 360         STR_LAI_CLEAR_DESCRIPTION_ROUGH_LAND,
 361         STR_LAI_CLEAR_DESCRIPTION_ROCKS,
 362         STR_LAI_CLEAR_DESCRIPTION_FIELDS,
 363         STR_LAI_CLEAR_DESCRIPTION_SNOW_COVERED_LAND,
 364         STR_LAI_CLEAR_DESCRIPTION_DESERT
 365 };
 366
 367 static void GetTileDesc_Clear(TileIndex tile, TileDesc *td)
 368 {
 369         if (IsClearGround(tile, CLEAR_GRASS) && GetClearDensity(tile) == 0) {
 370                 td->str = STR_LAI_CLEAR_DESCRIPTION_BARE_LAND;
 371         } else {
 372                 td->str = _clear_land_str[GetClearGround(tile)];
 373         }
 374         td->owner[0] = GetTileOwner(tile);
 375 }
 376
 377 static void ChangeTileOwner_Clear(TileIndex tile, Owner old_owner, Owner new_owner)
 378 {
 379         return;
 380 }
 381
 382 static CommandCost TerraformTile_Clear(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
 383 {
 384         return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 385 }
 386
 387 extern const TileTypeProcs _tile_type_clear_procs = {
 388         DrawTile_Clear,           ///< draw_tile_proc
 389         GetSlopePixelZ_Clear,     ///< get_slope_z_proc
 390         ClearTile_Clear,          ///< clear_tile_proc
 391         nullptr,                     ///< add_accepted_cargo_proc
 392         GetTileDesc_Clear,        ///< get_tile_desc_proc
 393         GetTileTrackStatus_Clear, ///< get_tile_track_status_proc
 394         nullptr,                     ///< click_tile_proc
 395         nullptr,                     ///< animate_tile_proc
 396         TileLoop_Clear,           ///< tile_loop_proc
 397         ChangeTileOwner_Clear,    ///< change_tile_owner_proc
 398         nullptr,                     ///< add_produced_cargo_proc
 399         nullptr,                     ///< vehicle_enter_tile_proc
 400         GetFoundation_Clear,      ///< get_foundation_proc
 401         TerraformTile_Clear,      ///< terraform_tile_proc
 402 };