/**
* 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);
}
void OnTick_Trees()
{
/* Don't place trees if that's not allowed */
if (_settings_game.construction.extra_tree_placement == ETP_NONE) return;
uint32 r;
TileIndex tile;
TreeType tree;
/* place a tree at a random rainforest spot */
if (_settings_game.game_creation.landscape == LT_TROPIC &&
(r = Random(), tile = RandomTileSeed(r), GetTropicZone(tile) == TROPICZONE_RAINFOREST) &&
CanPlantTreesOnTile(tile, false) &&
(tree = GetRandomTreeType(tile, GB(r, 24, 8))) != TREE_INVALID) {
PlantTreesOnTile(tile, tree, 0, 0);
}
/* byte underflow */
if (--_trees_tick_ctr != 0 || _settings_game.construction.extra_tree_placement != ETP_ALL) return;
/* place a tree at a random spot */
r = Random();
tile = RandomTileSeed(r);
if (CanPlantTreesOnTile(tile, false) && (tree = GetRandomTreeType(tile, GB(r, 24, 8))) != TREE_INVALID) {
PlantTreesOnTile(tile, tree, 0, 0);
}
}
static void TileLoopTreesDesert(TileIndex tile)
{
switch (GetTropicZone(tile)) {
case TROPICZONE_DESERT:
if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) {
SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);
MarkTileDirtyByTile(tile);
}
break;
case TROPICZONE_RAINFOREST: {
static const SoundFx forest_sounds[] = {
SND_42_LOON_BIRD,
SND_43_LION,
SND_44_MONKEYS,
SND_48_DISTANT_BIRD
};
uint32 r = Random();
if (Chance16I(1, 200, r)) SndPlayTileFx(forest_sounds[GB(r, 16, 2)], tile);
break;
}
default: break;
}
}
/**
* Tests if at least one surrounding tile is non-desert
* @param tile tile to check
* @return does this tile have at least one non-desert tile around?
*/
static inline bool NeighbourIsNormal(TileIndex tile)
{
for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
TileIndex t = tile + TileOffsByDiagDir(dir);
if (!IsValidTile(t)) continue;
if (GetTropicZone(t) != TROPICZONE_DESERT) return true;
if (HasTileWaterClass(t) && GetWaterClass(t) == WATER_CLASS_SEA) return true;
}
return false;
}
/**
* Place some trees randomly
*
* This function just place some trees randomly on the map.
*/
void PlaceTreesRandomly()
{
uint i, j, ht;
i = ScaleByMapSize(DEFAULT_TREE_STEPS);
if (_game_mode == GM_EDITOR) i /= EDITOR_TREE_DIV;
do {
uint32 r = Random();
TileIndex tile = RandomTileSeed(r);
IncreaseGeneratingWorldProgress(GWP_TREE);
if (CanPlantTreesOnTile(tile, true)) {
PlaceTree(tile, r);
if (_settings_game.game_creation.tree_placer != TP_IMPROVED) continue;
/* Place a number of trees based on the tile height.
* This gives a cool effect of multiple trees close together.
* It is almost real life ;) */
ht = GetTileZ(tile);
/* The higher we get, the more trees we plant */
j = GetTileZ(tile) / TILE_HEIGHT * 2;
/* Above snowline more trees! */
if (_settings_game.game_creation.landscape == LT_ARCTIC && ht > GetSnowLine()) j *= 3;
while (j--) {
PlaceTreeAtSameHeight(tile, ht);
}
}
} while (--i);
/* place extra trees at rainforest area */
if (_settings_game.game_creation.landscape == LT_TROPIC) {
i = ScaleByMapSize(DEFAULT_RAINFOREST_TREE_STEPS);
if (_game_mode == GM_EDITOR) i /= EDITOR_TREE_DIV;
do {
uint32 r = Random();
TileIndex tile = RandomTileSeed(r);
IncreaseGeneratingWorldProgress(GWP_TREE);
if (GetTropicZone(tile) == TROPICZONE_RAINFOREST && CanPlantTreesOnTile(tile, false)) {
PlaceTree(tile, r);
}
} while (--i);
}
}
/* static */ uint32 ScriptTown::GetCargoGoal(TownID town_id, ScriptCargo::TownEffect towneffect_id)
{
if (!IsValidTown(town_id)) return -1;
if (!ScriptCargo::IsValidTownEffect(towneffect_id)) return -1;
const Town *t = ::Town::Get(town_id);
switch (t->goal[towneffect_id]) {
case TOWN_GROWTH_WINTER:
if (TileHeight(t->xy) >= GetSnowLine() && t->cache.population > 90) return 1;
return 0;
case TOWN_GROWTH_DESERT:
if (GetTropicZone(t->xy) == TROPICZONE_DESERT && t->cache.population > 60) return 1;
return 0;
default: return t->goal[towneffect_id];
}
}
/**
* Get a random TreeType for the given tile based on a given seed
*
* This function returns a random TreeType which can be placed on the given tile.
* The seed for randomness must be less or equal 256, use #GB on the value of Random()
* to get such a value.
*
* @param tile The tile to get a random TreeType from
* @param seed The seed for randomness, must be less or equal 256
* @return The random tree type
*/
static TreeType GetRandomTreeType(TileIndex tile, uint seed)
{
switch (_settings_game.game_creation.landscape) {
case LT_TEMPERATE:
return (TreeType)(seed * TREE_COUNT_TEMPERATE / 256 + TREE_TEMPERATE);
case LT_ARCTIC:
return (TreeType)(seed * TREE_COUNT_SUB_ARCTIC / 256 + TREE_SUB_ARCTIC);
case LT_TROPIC:
switch (GetTropicZone(tile)) {
case TROPICZONE_NORMAL: return (TreeType)(seed * TREE_COUNT_SUB_TROPICAL / 256 + TREE_SUB_TROPICAL);
case TROPICZONE_DESERT: return (TreeType)((seed > 12) ? TREE_INVALID : TREE_CACTUS);
default: return (TreeType)(seed * TREE_COUNT_RAINFOREST / 256 + TREE_RAINFOREST);
}
default:
return (TreeType)(seed * TREE_COUNT_TOYLAND / 256 + TREE_TOYLAND);
}
}
/** Callback to create non-desert around a river tile. */
bool RiverModifyDesertZone(TileIndex tile, void *)
{
if (GetTropicZone(tile) == TROPICZONE_DESERT) SetTropicZone(tile, TROPICZONE_NORMAL);
return false;
}
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);
}
/**
* Plant a tree.
* @param tile start tile of area-drag of tree plantation
* @param flags type of operation
* @param p1 tree type, TREE_INVALID means random.
* @param p2 end tile of area-drag
* @param text unused
* @return the cost of this operation or an error
*/
CommandCost CmdPlantTree(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
StringID msg = INVALID_STRING_ID;
CommandCost cost(EXPENSES_OTHER);
const byte tree_to_plant = GB(p1, 0, 8); // We cannot use Extract as min and max are climate specific.
if (p2 >= MapSize()) return CMD_ERROR;
/* Check the tree type within the current climate */
if (tree_to_plant != TREE_INVALID && !IsInsideBS(tree_to_plant, _tree_base_by_landscape[_settings_game.game_creation.landscape], _tree_count_by_landscape[_settings_game.game_creation.landscape])) return CMD_ERROR;
TileArea ta(tile, p2);
TILE_AREA_LOOP(tile, ta) {
switch (GetTileType(tile)) {
case MP_TREES:
/* no more space for trees? */
if (_game_mode != GM_EDITOR && GetTreeCount(tile) == 4) {
msg = STR_ERROR_TREE_ALREADY_HERE;
continue;
}
if (flags & DC_EXEC) {
AddTreeCount(tile, 1);
MarkTileDirtyByTile(tile);
}
/* 2x as expensive to add more trees to an existing tile */
cost.AddCost(_price[PR_BUILD_TREES] * 2);
break;
case MP_WATER:
if (!IsCoast(tile) || IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL))) {
msg = STR_ERROR_CAN_T_BUILD_ON_WATER;
continue;
}
/* FALL THROUGH */
case MP_CLEAR: {
if (IsBridgeAbove(tile)) {
msg = STR_ERROR_SITE_UNSUITABLE;
continue;
}
TreeType treetype = (TreeType)tree_to_plant;
/* Be a bit picky about which trees go where. */
if (_settings_game.game_creation.landscape == LT_TROPIC && treetype != TREE_INVALID && (
/* No cacti outside the desert */
(treetype == TREE_CACTUS && GetTropicZone(tile) != TROPICZONE_DESERT) ||
/* No rain forest trees outside the rain forest, except in the editor mode where it makes those tiles rain forest tile */
(IsInsideMM(treetype, TREE_RAINFOREST, TREE_CACTUS) && GetTropicZone(tile) != TROPICZONE_RAINFOREST && _game_mode != GM_EDITOR) ||
/* And no subtropical trees in the desert/rain forest */
(IsInsideMM(treetype, TREE_SUB_TROPICAL, TREE_TOYLAND) && GetTropicZone(tile) != TROPICZONE_NORMAL))) {
msg = STR_ERROR_TREE_WRONG_TERRAIN_FOR_TREE_TYPE;
continue;
}
if (IsTileType(tile, MP_CLEAR)) {
/* Remove fields or rocks. Note that the ground will get barrened */
switch (GetRawClearGround(tile)) {
case CLEAR_FIELDS:
case CLEAR_ROCKS: {
CommandCost ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret.Failed()) return ret;
cost.AddCost(ret);
break;
}
default: break;
}
}
if (_game_mode != GM_EDITOR && Company::IsValidID(_current_company)) {
Town *t = ClosestTownFromTile(tile, _settings_game.economy.dist_local_authority);
if (t != NULL) ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM, flags);
}
if (flags & DC_EXEC) {
if (treetype == TREE_INVALID) {
treetype = GetRandomTreeType(tile, GB(Random(), 24, 8));
if (treetype == TREE_INVALID) treetype = TREE_CACTUS;
}
/* Plant full grown trees in scenario editor */
PlantTreesOnTile(tile, treetype, 0, _game_mode == GM_EDITOR ? 3 : 0);
MarkTileDirtyByTile(tile);
/* When planting rainforest-trees, set tropiczone to rainforest in editor. */
if (_game_mode == GM_EDITOR && IsInsideMM(treetype, TREE_RAINFOREST, TREE_CACTUS)) {
SetTropicZone(tile, TROPICZONE_RAINFOREST);
}
}
cost.AddCost(_price[PR_BUILD_TREES]);
break;
}
default:
msg = STR_ERROR_SITE_UNSUITABLE;
break;
}
}
if (cost.GetCost() == 0) {
return_cmd_error(msg);
} else {
return cost;
}
}
