src/terraform_cmd.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file terraform_cmd.cpp Commands related to terraforming. */
  11
  12 #include "stdafx.h"
  13 #include "command_func.h"
  14 #include "map/zoneheight.h"
  15 #include "map/tunnel.h"
  16 #include "map/bridge.h"
  17 #include "bridge.h"
  18 #include "viewport_func.h"
  19 #include "genworld.h"
  20 #include "object_base.h"
  21 #include "company_base.h"
  22 #include "company_func.h"
  23 #include "landscape_type.h"
  24
  25 #include "table/strings.h"
  26
  27 /*
  28  * In one terraforming command all four corners of a initial tile can be raised/lowered (though this is not available to the player).
  29  * The maximal amount of height modifications is achieved when raising a complete flat land from sea level to MAX_TILE_HEIGHT or vice versa.
  30  * This affects all corners with a manhatten distance smaller than MAX_TILE_HEIGHT to one of the initial 4 corners.
  31  * Their maximal amount is computed to 4 * \sum_{i=1}^{h_max} i  =  2 * h_max * (h_max + 1).
  32  */
  33 static const int TERRAFORMER_MODHEIGHT_SIZE = 2 * MAX_TILE_HEIGHT * (MAX_TILE_HEIGHT + 1);
  34
  35 /*
  36  * The maximal amount of affected tiles (i.e. the tiles that incident with one of the corners above, is computed similar to
  37  * 1 + 4 * \sum_{i=1}^{h_max} (i+1)  =  1 + 2 * h_max + (h_max + 3).
  38  */
  39 static const int TERRAFORMER_TILE_TABLE_SIZE = 1 + 2 * MAX_TILE_HEIGHT * (MAX_TILE_HEIGHT + 3);
  40
  41 struct TerraformerHeightMod {
  42         TileIndex tile;   ///< Referenced tile.
  43         byte height;      ///< New TileHeight (height of north corner) of the tile.
  44 };
  45
  46 struct TerraformerState {
  47         int modheight_count;  ///< amount of entries in "modheight".
  48         int tile_table_count; ///< amount of entries in "tile_table".
  49
  50         /**
  51          * Dirty tiles, i.e.\ at least one corner changed.
  52          *
  53          * This array contains the tiles which are or will be marked as dirty.
  54          *
  55          * @ingroup dirty
  56          */
  57         TileIndex tile_table[TERRAFORMER_TILE_TABLE_SIZE];
  58         TerraformerHeightMod modheight[TERRAFORMER_MODHEIGHT_SIZE];  ///< Height modifications.
  59 };
  60
  61 TileIndex _terraform_err_tile; ///< first tile we couldn't terraform
  62
  63 /**
  64  * Gets the TileHeight (height of north corner) of a tile as of current terraforming progress.
  65  *
  66  * @param ts TerraformerState.
  67  * @param tile Tile.
  68  * @return TileHeight.
  69  */
  70 static int TerraformGetHeightOfTile(const TerraformerState *ts, TileIndex tile)
  71 {
  72         const TerraformerHeightMod *mod = ts->modheight;
  73
  74         for (int count = ts->modheight_count; count != 0; count--, mod++) {
  75                 if (mod->tile == tile) return mod->height;
  76         }
  77
  78         /* TileHeight unchanged so far, read value from map. */
  79         return TileHeight(tile);
  80 }
  81
  82 /**
  83  * Stores the TileHeight (height of north corner) of a tile in a TerraformerState.
  84  *
  85  * @param ts TerraformerState.
  86  * @param tile Tile.
  87  * @param height New TileHeight.
  88  */
  89 static void TerraformSetHeightOfTile(TerraformerState *ts, TileIndex tile, int height)
  90 {
  91         /* Find tile in the "modheight" table.
  92          * Note: In a normal user-terraform command the tile will not be found in the "modheight" table.
  93          *       But during house- or industry-construction multiple corners can be terraformed at once. */
  94         TerraformerHeightMod *mod = ts->modheight;
  95         int count = ts->modheight_count;
  96
  97         while ((count > 0) && (mod->tile != tile)) {
  98                 mod++;
  99                 count--;
 100         }
 101
 102         /* New entry? */
 103         if (count == 0) {
 104                 assert(ts->modheight_count < TERRAFORMER_MODHEIGHT_SIZE);
 105                 ts->modheight_count++;
 106         }
 107
 108         /* Finally store the new value */
 109         mod->tile = tile;
 110         mod->height = (byte)height;
 111 }
 112
 113 /**
 114  * Adds a tile to the "tile_table" in a TerraformerState.
 115  *
 116  * @param ts TerraformerState.
 117  * @param tile Tile.
 118  * @ingroup dirty
 119  */
 120 static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)
 121 {
 122         int count = ts->tile_table_count;
 123
 124         for (TileIndex *t = ts->tile_table; count != 0; count--, t++) {
 125                 if (*t == tile) return;
 126         }
 127
 128         assert(ts->tile_table_count < TERRAFORMER_TILE_TABLE_SIZE);
 129
 130         ts->tile_table[ts->tile_table_count++] = tile;
 131 }
 132
 133 /**
 134  * Adds all tiles that incident with the north corner of a specific tile to the "tile_table" in a TerraformerState.
 135  *
 136  * @param ts TerraformerState.
 137  * @param tile Tile.
 138  * @ingroup dirty
 139  */
 140 static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)
 141 {
 142         /* Make sure all tiles passed to TerraformAddDirtyTile are within [0, MapSize()] */
 143         if (TileY(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY( 0, -1));
 144         if (TileY(tile) >= 1 && TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, -1));
 145         if (TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1,  0));
 146         TerraformAddDirtyTile(ts, tile);
 147 }
 148
 149 /**
 150  * Terraform the north corner of a tile to a specific height.
 151  *
 152  * @param ts TerraformerState.
 153  * @param tile Tile.
 154  * @param height Aimed height.
 155  * @return Error code or cost.
 156  */
 157 static CommandCost TerraformTileHeight(TerraformerState *ts, TileIndex tile, int height)
 158 {
 159         assert(tile < MapSize());
 160
 161         /* Check range of destination height */
 162         if (height < 0) return_cmd_error(STR_ERROR_ALREADY_AT_SEA_LEVEL);
 163         if (height > (int)MAX_TILE_HEIGHT) return_cmd_error(STR_ERROR_TOO_HIGH);
 164
 165         /*
 166          * Check if the terraforming has any effect.
 167          * This can only be true, if multiple corners of the start-tile are terraformed (i.e. the terraforming is done by towns/industries etc.).
 168          * In this case the terraforming should fail. (Don't know why.)
 169          */
 170         if (height == TerraformGetHeightOfTile(ts, tile)) return CMD_ERROR;
 171
 172         /* Check "too close to edge of map". Only possible when freeform-edges is off. */
 173         uint x = TileX(tile);
 174         uint y = TileY(tile);
 175         if (!_settings_game.construction.freeform_edges && ((x <= 1) || (y <= 1) || (x >= MapMaxX() - 1) || (y >= MapMaxY() - 1))) {
 176                 /*
 177                  * Determine a sensible error tile
 178                  */
 179                 if (x == 1) x = 0;
 180                 if (y == 1) y = 0;
 181                 _terraform_err_tile = TileXY(x, y);
 182                 return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
 183         }
 184
 185         /* Mark incident tiles that are involved in the terraforming. */
 186         TerraformAddDirtyTileAround(ts, tile);
 187
 188         /* Store the height modification */
 189         TerraformSetHeightOfTile(ts, tile, height);
 190
 191         CommandCost total_cost(EXPENSES_CONSTRUCTION);
 192
 193         /* Increment cost */
 194         total_cost.AddCost(_price[PR_TERRAFORM]);
 195
 196         /* Recurse to neighboured corners if height difference is larger than 1 */
 197         {
 198                 const CoordDiff *ttm;
 199
 200                 TileIndex orig_tile = tile;
 201                 static const CoordDiff _terraform_tilepos[] = {
 202                         { 1,  0}, // move to tile in SE
 203                         {-2,  0}, // undo last move, and move to tile in NW
 204                         { 1,  1}, // undo last move, and move to tile in SW
 205                         { 0, -2}  // undo last move, and move to tile in NE
 206                 };
 207
 208                 for (ttm = _terraform_tilepos; ttm != endof(_terraform_tilepos); ttm++) {
 209                         tile += ToTileIndexDiff(*ttm);
 210
 211                         if (tile >= MapSize()) continue;
 212                         /* Make sure we don't wrap around the map */
 213                         if (Delta(TileX(orig_tile), TileX(tile)) == MapSizeX() - 1) continue;
 214                         if (Delta(TileY(orig_tile), TileY(tile)) == MapSizeY() - 1) continue;
 215
 216                         /* Get TileHeight of neighboured tile as of current terraform progress */
 217                         int r = TerraformGetHeightOfTile(ts, tile);
 218                         int height_diff = height - r;
 219
 220                         /* Is the height difference to the neighboured corner greater than 1? */
 221                         if (abs(height_diff) > 1) {
 222                                 /* Terraform the neighboured corner. The resulting height difference should be 1. */
 223                                 height_diff += (height_diff < 0 ? 1 : -1);
 224                                 CommandCost cost = TerraformTileHeight(ts, tile, r + height_diff);
 225                                 if (cost.Failed()) return cost;
 226                                 total_cost.AddCost(cost);
 227                         }
 228                 }
 229         }
 230
 231         return total_cost;
 232 }
 233
 234 /**
 235  * Terraform land
 236  * @param tile tile to terraform
 237  * @param flags for this command type
 238  * @param p1 corners to terraform (SLOPE_xxx)
 239  * @param p2 direction; eg up (non-zero) or down (zero)
 240  * @param text unused
 241  * @return the cost of this operation or an error
 242  */
 243 CommandCost CmdTerraformLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
 244 {
 245         _terraform_err_tile = INVALID_TILE;
 246
 247         CommandCost total_cost(EXPENSES_CONSTRUCTION);
 248         int direction = (p2 != 0 ? 1 : -1);
 249         TerraformerState ts;
 250
 251         ts.modheight_count = ts.tile_table_count = 0;
 252
 253         /* Compute the costs and the terraforming result in a model of the landscape */
 254         if ((p1 & SLOPE_W) != 0 && tile + TileDiffXY(1, 0) < MapSize()) {
 255                 TileIndex t = tile + TileDiffXY(1, 0);
 256                 CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
 257                 if (cost.Failed()) return cost;
 258                 total_cost.AddCost(cost);
 259         }
 260
 261         if ((p1 & SLOPE_S) != 0 && tile + TileDiffXY(1, 1) < MapSize()) {
 262                 TileIndex t = tile + TileDiffXY(1, 1);
 263                 CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
 264                 if (cost.Failed()) return cost;
 265                 total_cost.AddCost(cost);
 266         }
 267
 268         if ((p1 & SLOPE_E) != 0 && tile + TileDiffXY(0, 1) < MapSize()) {
 269                 TileIndex t = tile + TileDiffXY(0, 1);
 270                 CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
 271                 if (cost.Failed()) return cost;
 272                 total_cost.AddCost(cost);
 273         }
 274
 275         if ((p1 & SLOPE_N) != 0) {
 276                 TileIndex t = tile + TileDiffXY(0, 0);
 277                 CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
 278                 if (cost.Failed()) return cost;
 279                 total_cost.AddCost(cost);
 280         }
 281
 282         /* Check if the terraforming is valid wrt. tunnels, bridges and objects on the surface
 283          * Pass == 0: Collect tileareas which are caused to be auto-cleared.
 284          * Pass == 1: Collect the actual cost. */
 285         for (int pass = 0; pass < 2; pass++) {
 286                 TileIndex *ti = ts.tile_table;
 287
 288                 for (int count = ts.tile_table_count; count != 0; count--, ti++) {
 289                         TileIndex tile = *ti;
 290
 291                         assert(tile < MapSize());
 292                         /* Void tiles can be terraformed but as tunnels and bridges
 293                          * cannot go under / over these tiles they don't need checking. */
 294                         if (IsVoidTile(tile)) continue;
 295
 296                         /* Find new heights of tile corners */
 297                         int z_N = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 0));
 298                         int z_W = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 0));
 299                         int z_S = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 1));
 300                         int z_E = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 1));
 301
 302                         /* Find min and max height of tile */
 303                         int z_min = min(min(z_N, z_W), min(z_S, z_E));
 304                         int z_max = max(max(z_N, z_W), max(z_S, z_E));
 305
 306                         /* Compute tile slope */
 307                         Slope tileh = (z_max > z_min + 1 ? SLOPE_STEEP : SLOPE_FLAT);
 308                         if (z_W > z_min) tileh |= SLOPE_W;
 309                         if (z_S > z_min) tileh |= SLOPE_S;
 310                         if (z_E > z_min) tileh |= SLOPE_E;
 311                         if (z_N > z_min) tileh |= SLOPE_N;
 312
 313                         if (pass == 0) {
 314                                 /* Check if bridge would take damage */
 315                                 if (direction == 1 && HasBridgeAbove(tile) &&
 316                                                 GetBridgeHeight(GetSouthernBridgeEnd(tile)) <= z_max) {
 317                                         _terraform_err_tile = tile; // highlight the tile under the bridge
 318                                         return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
 319                                 }
 320                                 /* Check if tunnel would take damage */
 321                                 if (direction == -1 && IsTunnelInWay(tile, z_min)) {
 322                                         _terraform_err_tile = tile; // highlight the tile above the tunnel
 323                                         return_cmd_error(STR_ERROR_EXCAVATION_WOULD_DAMAGE);
 324                                 }
 325                         }
 326
 327                         /* Is the tile already cleared? */
 328                         const ClearedObjectArea *coa = FindClearedObject(tile);
 329                         bool indirectly_cleared = coa != NULL && coa->first_tile != tile;
 330
 331                         /* Check tiletype-specific things, and add extra-cost */
 332                         const bool curr_gen = _generating_world;
 333                         if (_game_mode == GM_EDITOR) _generating_world = true; // used to create green terraformed land
 334                         DoCommandFlag tile_flags = flags | DC_AUTO | DC_FORCE_CLEAR_TILE;
 335                         if (pass == 0) {
 336                                 tile_flags &= ~DC_EXEC;
 337                                 tile_flags |= DC_NO_MODIFY_TOWN_RATING;
 338                         }
 339                         CommandCost cost;
 340                         if (indirectly_cleared) {
 341                                 cost = DoCommand(tile, 0, 0, tile_flags, CMD_LANDSCAPE_CLEAR);
 342                         } else {
 343                                 cost = GetTileProcs(tile)->terraform_tile_proc(tile, tile_flags, z_min, tileh);
 344                         }
 345                         _generating_world = curr_gen;
 346                         if (cost.Failed()) {
 347                                 _terraform_err_tile = tile;
 348                                 return cost;
 349                         }
 350                         if (pass == 1) total_cost.AddCost(cost);
 351                 }
 352         }
 353
 354         Company *c = Company::GetIfValid(_current_company);
 355         if (c != NULL && (int)GB(c->terraform_limit, 16, 16) < ts.modheight_count) {
 356                 return_cmd_error(STR_ERROR_TERRAFORM_LIMIT_REACHED);
 357         }
 358
 359         if (flags & DC_EXEC) {
 360                 /* change the height */
 361                 {
 362                         int count;
 363                         TerraformerHeightMod *mod;
 364
 365                         mod = ts.modheight;
 366                         for (count = ts.modheight_count; count != 0; count--, mod++) {
 367                                 TileIndex til = mod->tile;
 368
 369                                 SetTileHeight(til, mod->height);
 370                         }
 371                 }
 372
 373                 /* finally mark the dirty tiles dirty */
 374                 {
 375                         int count;
 376                         TileIndex *ti = ts.tile_table;
 377                         for (count = ts.tile_table_count; count != 0; count--, ti++) {
 378                                 MarkTileDirtyByTile(*ti);
 379                         }
 380                 }
 381
 382                 if (c != NULL) c->terraform_limit -= ts.modheight_count << 16;
 383         }
 384         return total_cost;
 385 }
 386
 387
 388 /**
 389  * Levels a selected (rectangle) area of land
 390  * @param tile end tile of area-drag
 391  * @param flags for this command type
 392  * @param p1 start tile of area drag
 393  * @param p2 various bitstuffed data.
 394  *  bit      0: Whether to use the Orthogonal (0) or Diagonal (1) iterator.
 395  *  bits 1 - 2: Mode of leveling \c LevelMode.
 396  * @param text unused
 397  * @return the cost of this operation or an error
 398  */
 399 CommandCost CmdLevelLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
 400 {
 401         if (p1 >= MapSize()) return CMD_ERROR;
 402
 403         _terraform_err_tile = INVALID_TILE;
 404
 405         /* remember level height */
 406         uint oldh = TileHeight(p1);
 407
 408         /* compute new height */
 409         uint h = oldh;
 410         LevelMode lm = (LevelMode)GB(p2, 1, 2);
 411         switch (lm) {
 412                 case LM_LEVEL: break;
 413                 case LM_RAISE: h++; break;
 414                 case LM_LOWER: h--; break;
 415                 default: return CMD_ERROR;
 416         }
 417
 418         /* Check range of destination height */
 419         if (h > MAX_TILE_HEIGHT) return_cmd_error((oldh == 0) ? STR_ERROR_ALREADY_AT_SEA_LEVEL : STR_ERROR_TOO_HIGH);
 420
 421         Money money = GetAvailableMoneyForCommand();
 422         CommandCost cost(EXPENSES_CONSTRUCTION);
 423         CommandCost last_error(lm == LM_LEVEL ? STR_ERROR_ALREADY_LEVELLED : INVALID_STRING_ID);
 424         bool had_success = false;
 425
 426         const Company *c = Company::GetIfValid(_current_company);
 427         int limit = (c == NULL ? INT32_MAX : GB(c->terraform_limit, 16, 16));
 428         if (limit == 0) return_cmd_error(STR_ERROR_TERRAFORM_LIMIT_REACHED);
 429
 430         TileIterator *iter = HasBit(p2, 0) ? (TileIterator *)new DiagonalTileIterator(tile, p1) : new OrthogonalTileIterator(TileArea (tile, p1));
 431         for (; *iter != INVALID_TILE; ++(*iter)) {
 432                 TileIndex t = *iter;
 433                 uint curh = TileHeight(t);
 434                 while (curh != h) {
 435                         CommandCost ret = DoCommand(t, SLOPE_N, (curh > h) ? 0 : 1, flags & ~DC_EXEC, CMD_TERRAFORM_LAND);
 436                         if (ret.Failed()) {
 437                                 last_error = ret;
 438
 439                                 /* Did we reach the limit? */
 440                                 if (ret.GetErrorMessage() == STR_ERROR_TERRAFORM_LIMIT_REACHED) limit = 0;
 441                                 break;
 442                         }
 443
 444                         if (flags & DC_EXEC) {
 445                                 money -= ret.GetCost();
 446                                 if (money < 0) {
 447                                         _additional_cash_required = ret.GetCost();
 448                                         delete iter;
 449                                         return cost;
 450                                 }
 451                                 DoCommand(t, SLOPE_N, (curh > h) ? 0 : 1, flags, CMD_TERRAFORM_LAND);
 452                         } else {
 453                                 /* When we're at the terraform limit we better bail (unneeded) testing as well.
 454                                  * This will probably cause the terraforming cost to be underestimated, but only
 455                                  * when it's near the terraforming limit. Even then, the estimation is
 456                                  * completely off due to it basically counting terraforming double, so it being
 457                                  * cut off earlier might even give a better estimate in some cases. */
 458                                 if (--limit <= 0) {
 459                                         had_success = true;
 460                                         break;
 461                                 }
 462                         }
 463
 464                         cost.AddCost(ret);
 465                         curh += (curh > h) ? -1 : 1;
 466                         had_success = true;
 467                 }
 468
 469                 if (limit <= 0) break;
 470         }
 471
 472         delete iter;
 473         return had_success ? cost : last_error;
 474 }