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((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);
break;
case CLEAR_FIELDS:
DrawGroundSprite(_clear_land_sprites_farmland[GetFieldType(ti->tile)] + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
DrawClearLandFence(ti);
break;
case CLEAR_SNOW:
case CLEAR_DESERT:
DrawGroundSprite(_clear_land_sprites_snow_desert[GetClearDensity(ti->tile)] + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
break;
}
DrawBridgeMiddle(ti);
}
/** Convert to or from snowy tiles. */
static void TileLoopClearAlps(TileIndex tile)
{
int k = GetTileZ(tile) - GetSnowLine() + 1;
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 current_density = GetClearDensity(tile);
uint req_density = (k < 0) ? 0u : min((uint)k, 3);
if (current_density < req_density) {
AddClearDensity(tile, 1);
} else if (current_density > req_density) {
AddClearDensity(tile, -1);
} else {
/* Density at the required level. */
if (k >= 0) return;
ClearSnow(tile);
}
MarkTileDirtyByTile(tile);
}
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);
}
/**
* Creates a tree tile
* Ground type and density is preserved.
*
* @pre the tile must be suitable for trees.
*
* @param tile where to plant the trees.
* @param treetype The type of the tree
* @param count the number of trees (minus 1)
* @param growth the growth status
*/
static void PlantTreesOnTile(TileIndex tile, TreeType treetype, uint count, uint growth)
{
assert(treetype != TREE_INVALID);
assert(CanPlantTreesOnTile(tile, true));
TreeGround ground;
uint density = 3;
switch (GetTileType(tile)) {
case MP_WATER:
ground = TREE_GROUND_SHORE;
break;
case MP_CLEAR:
switch (GetClearGround(tile)) {
case CLEAR_GRASS: ground = TREE_GROUND_GRASS; break;
case CLEAR_ROUGH: ground = TREE_GROUND_ROUGH; break;
case CLEAR_SNOW: ground = GetRawClearGround(tile) == CLEAR_ROUGH ? TREE_GROUND_ROUGH_SNOW : TREE_GROUND_SNOW_DESERT; break;
default: ground = TREE_GROUND_SNOW_DESERT; break;
}
if (GetClearGround(tile) != CLEAR_ROUGH) density = GetClearDensity(tile);
break;
default: NOT_REACHED();
}
MakeTree(tile, treetype, count, growth, ground, density);
}
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 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;
}
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) {
int z;
if (IsTileFlat(tile, &z) && z == 0) {
DoFloodTile(tile);
MarkTileDirtyByTile(tile);
return;
}
}
AmbientSoundEffect(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:
UpdateFences(tile);
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 {
uint field_type = GetFieldType(tile);
field_type = (field_type < 8) ? field_type + 1 : 0;
SetFieldType(tile, field_type);
}
break;
default:
return;
}
MarkTileDirtyByTile(tile);
}
static void TileLoop_Trees(TileIndex tile)
{
if (GetTreeGround(tile) == TREE_GROUND_SHORE) {
TileLoop_Water(tile);
} else {
switch (_settings_game.game_creation.landscape) {
case LT_TROPIC: TileLoopTreesDesert(tile); break;
case LT_ARCTIC: TileLoopTreesAlps(tile); break;
}
}
TileLoopClearHelper(tile);
uint treeCounter = GetTreeCounter(tile);
/* Handle growth of grass (under trees/on MP_TREES tiles) at every 8th processings, like it's done for grass on MP_CLEAR tiles. */
if ((treeCounter & 7) == 7 && GetTreeGround(tile) == TREE_GROUND_GRASS) {
uint density = GetTreeDensity(tile);
if (density < 3) {
SetTreeGroundDensity(tile, TREE_GROUND_GRASS, density + 1);
MarkTileDirtyByTile(tile);
}
}
if (GetTreeCounter(tile) < 15) {
AddTreeCounter(tile, 1);
return;
}
SetTreeCounter(tile, 0);
switch (GetTreeGrowth(tile)) {
case 3: // regular sized tree
if (_settings_game.game_creation.landscape == LT_TROPIC &&
GetTreeType(tile) != TREE_CACTUS &&
GetTropicZone(tile) == TROPICZONE_DESERT) {
AddTreeGrowth(tile, 1);
} else {
switch (GB(Random(), 0, 3)) {
case 0: // start destructing
AddTreeGrowth(tile, 1);
break;
case 1: // add a tree
if (GetTreeCount(tile) < 4) {
AddTreeCount(tile, 1);
SetTreeGrowth(tile, 0);
break;
}
/* FALL THROUGH */
case 2: { // add a neighbouring tree
/* Don't plant extra trees if that's not allowed. */
if ((_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) == TROPICZONE_RAINFOREST) ?
_settings_game.construction.extra_tree_placement == ETP_NONE :
_settings_game.construction.extra_tree_placement != ETP_ALL) {
break;
}
TreeType treetype = GetTreeType(tile);
tile += TileOffsByDir((Direction)(Random() & 7));
/* Cacti don't spread */
if (!CanPlantTreesOnTile(tile, false)) return;
/* Don't plant trees, if ground was freshly cleared */
if (IsTileType(tile, MP_CLEAR) && GetClearGround(tile) == CLEAR_GRASS && GetClearDensity(tile) != 3) return;
PlantTreesOnTile(tile, treetype, 0, 0);
break;
}
default:
return;
}
}
break;
case 6: // final stage of tree destruction
if (GetTreeCount(tile) > 1) {
/* more than one tree, delete it */
AddTreeCount(tile, -1);
SetTreeGrowth(tile, 3);
} else {
/* just one tree, change type into MP_CLEAR */
switch (GetTreeGround(tile)) {
case TREE_GROUND_SHORE: MakeShore(tile); break;
case TREE_GROUND_GRASS: MakeClear(tile, CLEAR_GRASS, GetTreeDensity(tile)); break;
case TREE_GROUND_ROUGH: MakeClear(tile, CLEAR_ROUGH, 3); break;
case TREE_GROUND_ROUGH_SNOW: {
uint density = GetTreeDensity(tile);
MakeClear(tile, CLEAR_ROUGH, 3);
MakeSnow(tile, density);
break;
}
default: // snow or desert
if (_settings_game.game_creation.landscape == LT_TROPIC) {
MakeClear(tile, CLEAR_DESERT, GetTreeDensity(tile));
} else {
uint density = GetTreeDensity(tile);
MakeClear(tile, CLEAR_GRASS, 3);
MakeSnow(tile, density);
}
break;
}
}
break;
default:
AddTreeGrowth(tile, 1);
break;
}
MarkTileDirtyByTile(tile);
}
