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