55d78a23be
# Conflicts: # src/3rdparty/squirrel/include/squirrel.h # src/blitter/32bpp_sse_func.hpp # src/bridge_map.h # src/clear_map.h # src/company_manager_face.h # src/console_func.h # src/core/bitmath_func.hpp # src/core/endian_func.hpp # src/core/random_func.hpp # src/depot_map.h # src/elrail_func.h # src/fontcache.h # src/industry_map.h # src/map_func.h # src/newgrf_spritegroup.h # src/object_map.h # src/rail.h # src/rail_map.h # src/road_func.h # src/road_map.h # src/saveload/saveload.h # src/saveload/saveload_error.hpp # src/settings_gui.cpp # src/sl/oldloader.h # src/sprite.h # src/spritecache.h # src/station_func.h # src/station_map.h # src/story_base.h # src/strings_func.h # src/tile_cmd.h # src/tile_map.h # src/tile_type.h # src/town.h # src/town_map.h # src/tree_map.h # src/tunnel_map.h # src/tunnelbridge_map.h # src/vehicle_func.h # src/viewport_func.h # src/void_map.h # src/water.h # src/water_map.h # src/widget_type.h
256 lines
8.8 KiB
C
256 lines
8.8 KiB
C
/*
|
|
* 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 tree_map.h Map accessors for tree tiles. */
|
|
|
|
#ifndef TREE_MAP_H
|
|
#define TREE_MAP_H
|
|
|
|
#include "tile_map.h"
|
|
#include "water_map.h"
|
|
|
|
/**
|
|
* List of tree types along all landscape types.
|
|
*
|
|
* This enumeration contains a list of the different tree types along
|
|
* all landscape types. The values for the enumerations may be used for
|
|
* offsets from the grfs files. These points to the start of
|
|
* the tree list for a landscape. See the TREE_COUNT_* enumerations
|
|
* for the amount of different trees for a specific landscape.
|
|
*/
|
|
enum TreeType {
|
|
TREE_TEMPERATE = 0x00, ///< temperate tree
|
|
TREE_SUB_ARCTIC = 0x0C, ///< tree on a sub_arctic landscape
|
|
TREE_RAINFOREST = 0x14, ///< tree on the 'green part' on a sub-tropical map
|
|
TREE_CACTUS = 0x1B, ///< a cactus for the 'desert part' on a sub-tropical map
|
|
TREE_SUB_TROPICAL = 0x1C, ///< tree on a sub-tropical map, non-rainforest, non-desert
|
|
TREE_TOYLAND = 0x20, ///< tree on a toyland map
|
|
TREE_INVALID = 0xFF, ///< An invalid tree
|
|
};
|
|
|
|
/* Counts the number of tree types for each landscape.
|
|
*
|
|
* This list contains the counts of different tree types for each landscape. This list contains
|
|
* 5 entries instead of 4 (as there are only 4 landscape types) as the sub tropic landscape
|
|
* has two types of area, one for normal trees and one only for cacti.
|
|
*/
|
|
static const uint TREE_COUNT_TEMPERATE = TREE_SUB_ARCTIC - TREE_TEMPERATE; ///< number of tree types on a temperate map.
|
|
static const uint TREE_COUNT_SUB_ARCTIC = TREE_RAINFOREST - TREE_SUB_ARCTIC; ///< number of tree types on a sub arctic map.
|
|
static const uint TREE_COUNT_RAINFOREST = TREE_CACTUS - TREE_RAINFOREST; ///< number of tree types for the 'rainforest part' of a sub-tropic map.
|
|
static const uint TREE_COUNT_SUB_TROPICAL = TREE_TOYLAND - TREE_SUB_TROPICAL; ///< number of tree types for the 'sub-tropic part' of a sub-tropic map.
|
|
static const uint TREE_COUNT_TOYLAND = 9; ///< number of tree types on a toyland map.
|
|
|
|
/**
|
|
* Enumeration for ground types of tiles with trees.
|
|
*
|
|
* This enumeration defines the ground types for tiles with trees on it.
|
|
*/
|
|
enum TreeGround {
|
|
TREE_GROUND_GRASS = 0, ///< normal grass
|
|
TREE_GROUND_ROUGH = 1, ///< some rough tile
|
|
TREE_GROUND_SNOW_DESERT = 2, ///< a desert or snow tile, depend on landscape
|
|
TREE_GROUND_SHORE = 3, ///< shore
|
|
TREE_GROUND_ROUGH_SNOW = 4, ///< A snow tile that is rough underneath.
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns the treetype of a tile.
|
|
*
|
|
* This function returns the treetype of a given tile. As there are more
|
|
* possible treetypes for a tile in a game as the enumeration #TreeType defines
|
|
* this function may be return a value which isn't catch by an entry of the
|
|
* enumeration #TreeType. But there is no problem known about it.
|
|
*
|
|
* @param t The tile to get the treetype from
|
|
* @return The treetype of the given tile with trees
|
|
* @pre Tile t must be of type MP_TREES
|
|
*/
|
|
inline TreeType GetTreeType(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
return (TreeType)_m[t].m3;
|
|
}
|
|
|
|
/**
|
|
* Returns the groundtype for tree tiles.
|
|
*
|
|
* This function returns the groundtype of a tile with trees.
|
|
*
|
|
* @param t The tile to get the groundtype from
|
|
* @return The groundtype of the tile
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline TreeGround GetTreeGround(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
return (TreeGround)GB(_m[t].m2, 6, 3);
|
|
}
|
|
|
|
/**
|
|
* Returns the 'density' of a tile with trees.
|
|
*
|
|
* This function returns the density of a tile which got trees. Note
|
|
* that this value doesn't count the number of trees on a tile, use
|
|
* #GetTreeCount instead. This function instead returns some kind of
|
|
* groundtype of the tile. As the map-array is finite in size and
|
|
* the information about the trees must be saved somehow other
|
|
* information about a tile must be saved somewhere encoded in the
|
|
* tile. So this function returns the density of a tile for sub arctic
|
|
* and sub tropical games. This means for sub arctic the type of snowline
|
|
* (0 to 3 for all 4 types of snowtiles) and for sub tropical the value
|
|
* 3 for a desert (and 0 for non-desert). The function name is not read as
|
|
* "get the tree density of a tile" but "get the density of a tile which got trees".
|
|
*
|
|
* @param t The tile to get the 'density'
|
|
* @pre Tile must be of type MP_TREES
|
|
* @see GetTreeCount
|
|
*/
|
|
inline uint GetTreeDensity(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
return GB(_m[t].m2, 4, 2);
|
|
}
|
|
|
|
/**
|
|
* Set the density and ground type of a tile with trees.
|
|
*
|
|
* This functions saves the ground type and the density which belongs to it
|
|
* for a given tile.
|
|
*
|
|
* @param t The tile to set the density and ground type
|
|
* @param g The ground type to save
|
|
* @param d The density to save with
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline void SetTreeGroundDensity(TileIndex t, TreeGround g, uint d)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t); // XXX incomplete
|
|
SB(_m[t].m2, 4, 2, d);
|
|
SB(_m[t].m2, 6, 3, g);
|
|
SetWaterClass(t, g == TREE_GROUND_SHORE ? WATER_CLASS_SEA : WATER_CLASS_INVALID);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of trees on a tile.
|
|
*
|
|
* This function returns the number of trees of a tile (1-4).
|
|
* The tile must be contains at least one tree or be more specific: it must be
|
|
* of type MP_TREES.
|
|
*
|
|
* @param t The index to get the number of trees
|
|
* @return The number of trees (1-4)
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline uint GetTreeCount(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
return GB(_m[t].m5, 6, 2) + 1;
|
|
}
|
|
|
|
/**
|
|
* Add a amount to the tree-count value of a tile with trees.
|
|
*
|
|
* This function add a value to the tree-count value of a tile. This
|
|
* value may be negative to reduce the tree-counter. If the resulting
|
|
* value reach 0 it doesn't get converted to a "normal" tile.
|
|
*
|
|
* @param t The tile to change the tree amount
|
|
* @param c The value to add (or reduce) on the tree-count value
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline void AddTreeCount(TileIndex t, int c)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t); // XXX incomplete
|
|
_m[t].m5 += ((uint) c) << 6;
|
|
}
|
|
|
|
/**
|
|
* Returns the tree growth status.
|
|
*
|
|
* This function returns the tree growth status of a tile with trees.
|
|
*
|
|
* @param t The tile to get the tree growth status
|
|
* @return The tree growth status
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline uint GetTreeGrowth(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
return GB(_m[t].m5, 0, 3);
|
|
}
|
|
|
|
/**
|
|
* Add a value to the tree growth status.
|
|
*
|
|
* This function adds a value to the tree grow status of a tile.
|
|
*
|
|
* @param t The tile to add the value on
|
|
* @param a The value to add on the tree growth status
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline void AddTreeGrowth(TileIndex t, int a)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t); // XXX incomplete
|
|
_m[t].m5 += a;
|
|
}
|
|
|
|
/**
|
|
* Sets the tree growth status of a tile.
|
|
*
|
|
* This function sets the tree growth status of a tile directly with
|
|
* the given value.
|
|
*
|
|
* @param t The tile to change the tree growth status
|
|
* @param g The new value
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline void SetTreeGrowth(TileIndex t, uint g)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t); // XXX incomplete
|
|
SB(_m[t].m5, 0, 3, g);
|
|
}
|
|
|
|
/**
|
|
* Clear the old tick counter for a tree-tile
|
|
*
|
|
* @param t The tile to clear the old tick counter
|
|
* @pre Tile must be of type MP_TREES
|
|
*/
|
|
inline void ClearOldTreeCounter(TileIndex t)
|
|
{
|
|
dbg_assert_tile(IsTileType(t, MP_TREES), t);
|
|
SB(_m[t].m2, 0, 4, 0);
|
|
}
|
|
|
|
/**
|
|
* Make a tree-tile.
|
|
*
|
|
* This functions change the tile to a tile with trees and all information which belongs to it.
|
|
*
|
|
* @param t The tile to make a tree-tile from
|
|
* @param type The type of the tree
|
|
* @param count the number of trees
|
|
* @param growth the growth status
|
|
* @param ground the ground type
|
|
* @param density the density (not the number of trees)
|
|
*/
|
|
inline void MakeTree(TileIndex t, TreeType type, uint count, uint growth, TreeGround ground, uint density)
|
|
{
|
|
SetTileType(t, MP_TREES);
|
|
SetTileOwner(t, OWNER_NONE);
|
|
SetWaterClass(t, ground == TREE_GROUND_SHORE ? WATER_CLASS_SEA : WATER_CLASS_INVALID);
|
|
_m[t].m2 = ground << 6 | density << 4 | 0;
|
|
_m[t].m3 = type;
|
|
_m[t].m4 = 0 << 5 | 0 << 2;
|
|
_m[t].m5 = count << 6 | growth;
|
|
SB(_me[t].m6, 2, 4, 0);
|
|
_me[t].m7 = 0;
|
|
}
|
|
|
|
#endif /* TREE_MAP_H */
|