mirror of https://github.com/OpenTTD/OpenTTD.git
(svn r3514) -Codechange: Replace direct fiddling of bits for the ground type and density of clear tiles with symbolic names and accessors.
See clear.h for details
This commit is contained in:
tron
parent
2b98509692
commit
ac4f4e30d5
|
|
@ -0,0 +1,36 @@
|
|||
/* $Id$ */
|
||||
|
||||
#ifndef CLEAR_H
|
||||
#define CLEAR_H
|
||||
|
||||
#include "macros.h"
|
||||
|
||||
/* ground type, m5 bits 2...4
|
||||
* valid densities (bits 0...1) in comments after the enum
|
||||
*/
|
||||
typedef enum ClearGround {
|
||||
CL_GRASS = 0, // 0-3
|
||||
CL_ROUGH = 1, // 3
|
||||
CL_ROCKS = 2, // 3
|
||||
CL_FIELDS = 3, // 3
|
||||
CL_SNOW = 4, // 0-3
|
||||
CL_DESERT = 5 // 1,3
|
||||
} ClearGround;
|
||||
|
||||
static inline ClearGround GetClearGround(TileIndex t) { return GB(_m[t].m5, 2, 3); }
|
||||
static inline bool IsClearGround(TileIndex t, ClearGround ct) { return GetClearGround(t) == ct; }
|
||||
|
||||
static inline void AddClearDensity(TileIndex t, int d) { _m[t].m5 += d; }
|
||||
static inline uint GetClearDensity(TileIndex t) { return GB(_m[t].m5, 0, 2); }
|
||||
|
||||
static inline void AddClearCounter(TileIndex t, int c) { _m[t].m5 += c << 5; }
|
||||
static inline uint GetClearCounter(TileIndex t) { return GB(_m[t].m5, 5, 3); }
|
||||
static inline void SetClearCounter(TileIndex t, uint c) { SB(_m[t].m5, 5, 3, c); }
|
||||
|
||||
/* Sets type and density in one go, also sets the counter to 0 */
|
||||
static inline void SetClearGroundDensity(TileIndex t, ClearGround type, uint density)
|
||||
{
|
||||
_m[t].m5 = 0 << 5 | type << 2 | density;
|
||||
}
|
||||
|
||||
#endif
|
||||
262
clear_cmd.c
262
clear_cmd.c
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "table/strings.h"
|
||||
#include "functions.h"
|
||||
#include "map.h"
|
||||
|
|
@ -413,42 +414,26 @@ int32 CmdPurchaseLandArea(int x, int y, uint32 flags, uint32 p1, uint32 p2)
|
|||
|
||||
static int32 ClearTile_Clear(TileIndex tile, byte flags)
|
||||
{
|
||||
static const int32 null = 0;
|
||||
static const int32* clear_price_table[] = {
|
||||
&null,
|
||||
&_price.clear_1,
|
||||
&_price.clear_1,
|
||||
&_price.clear_1,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_3,
|
||||
&_price.clear_3,
|
||||
&_price.clear_3,
|
||||
&_price.clear_3,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.purchase_land,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2,
|
||||
&_price.clear_2, // XXX unused?
|
||||
};
|
||||
const int32 *price = clear_price_table[GB(_m[tile].m5, 0, 5)];
|
||||
int32 price;
|
||||
|
||||
if (IsClearGround(tile, CL_GRASS) && GetClearDensity(tile) == 0) {
|
||||
price = 0;
|
||||
} else {
|
||||
price = *clear_price_table[GetClearGround(tile)];
|
||||
}
|
||||
|
||||
if (flags & DC_EXEC) DoClearSquare(tile);
|
||||
|
||||
return *price;
|
||||
return price;
|
||||
}
|
||||
|
||||
/** Sell a land area. Actually you only sell one tile, so
|
||||
|
|
@ -517,29 +502,29 @@ void DrawClearLandFence(const TileInfo *ti)
|
|||
static void DrawTile_Clear(TileInfo *ti)
|
||||
{
|
||||
switch (GB(ti->map5, 2, 3)) {
|
||||
case 0:
|
||||
DrawClearLandTile(ti, GB(ti->map5, 0, 2));
|
||||
break;
|
||||
case CL_GRASS:
|
||||
DrawClearLandTile(ti, GB(ti->map5, 0, 2));
|
||||
break;
|
||||
|
||||
case 1:
|
||||
DrawHillyLandTile(ti);
|
||||
break;
|
||||
case CL_ROUGH:
|
||||
DrawHillyLandTile(ti);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
DrawGroundSprite(SPR_FLAT_ROCKY_LAND_1 + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
case CL_ROCKS:
|
||||
DrawGroundSprite(SPR_FLAT_ROCKY_LAND_1 + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
|
||||
case 3:
|
||||
DrawGroundSprite(_clear_land_sprites_1[GB(_m[ti->tile].m3, 0, 4)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
case CL_FIELDS:
|
||||
DrawGroundSprite(_clear_land_sprites_1[GB(_m[ti->tile].m3, 0, 4)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
|
||||
case 4:
|
||||
DrawGroundSprite(_clear_land_sprites_2[GB(ti->map5, 0, 2)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
case CL_SNOW:
|
||||
DrawGroundSprite(_clear_land_sprites_2[GB(ti->map5, 0, 2)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
|
||||
case 5:
|
||||
DrawGroundSprite(_clear_land_sprites_3[GB(ti->map5, 0, 2)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
case CL_DESERT:
|
||||
DrawGroundSprite(_clear_land_sprites_3[GB(ti->map5, 0, 2)] + _tileh_to_sprite[ti->tileh]);
|
||||
break;
|
||||
}
|
||||
|
||||
DrawClearLandFence(ti);
|
||||
|
|
@ -571,26 +556,9 @@ void TileLoopClearHelper(TileIndex tile)
|
|||
byte neighbour;
|
||||
TileIndex dirty = INVALID_TILE;
|
||||
|
||||
switch (GetTileType(tile)) {
|
||||
case MP_CLEAR:
|
||||
self = (GB(_m[tile].m5, 0, 5) == 15);
|
||||
break;
|
||||
|
||||
default:
|
||||
self = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (GetTileType(TILE_ADDXY(tile, 1, 0))) {
|
||||
case MP_CLEAR:
|
||||
neighbour = (GB(_m[TILE_ADDXY(tile, 1, 0)].m5, 0, 5) == 15);
|
||||
break;
|
||||
|
||||
default:
|
||||
neighbour = 0;
|
||||
break;
|
||||
}
|
||||
self = (IsTileType(tile, MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 1, 0), CL_FIELDS));
|
||||
|
||||
neighbour = (IsTileType(TILE_ADDXY(tile, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 1, 0), CL_FIELDS));
|
||||
if (GB(_m[tile].m4, 5, 3) == 0) {
|
||||
if (self != neighbour) {
|
||||
SB(_m[tile].m4, 5, 3, 3);
|
||||
|
|
@ -603,16 +571,7 @@ void TileLoopClearHelper(TileIndex tile)
|
|||
}
|
||||
}
|
||||
|
||||
switch (GetTileType(TILE_ADDXY(tile, 0, 1))) {
|
||||
case MP_CLEAR:
|
||||
neighbour = (GB(_m[TILE_ADDXY(tile, 0, 1)].m5, 0, 5) == 15);
|
||||
break;
|
||||
|
||||
default:
|
||||
neighbour = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
neighbour = (IsTileType(TILE_ADDXY(tile, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 0, 1), CL_FIELDS));
|
||||
if (GB(_m[tile].m4, 2, 3) == 0) {
|
||||
if (self != neighbour) {
|
||||
SB(_m[tile].m4, 2, 3, 3);
|
||||
|
|
@ -632,78 +591,44 @@ void TileLoopClearHelper(TileIndex tile)
|
|||
/* convert into snowy tiles */
|
||||
static void TileLoopClearAlps(TileIndex tile)
|
||||
{
|
||||
int k;
|
||||
byte m5,tmp;
|
||||
|
||||
/* distance from snow line, in steps of 8 */
|
||||
k = GetTileZ(tile) - _opt.snow_line;
|
||||
int k = GetTileZ(tile) - _opt.snow_line;
|
||||
|
||||
m5 = _m[tile].m5 & 0x1C;
|
||||
tmp = _m[tile].m5 & 3;
|
||||
|
||||
if (k < -8) {
|
||||
/* snow_m2_down */
|
||||
if (m5 != 0x10)
|
||||
return;
|
||||
if (tmp == 0)
|
||||
m5 = 3;
|
||||
} else if (k == -8) {
|
||||
/* snow_m1 */
|
||||
if (m5 != 0x10) {
|
||||
m5 = 0x10;
|
||||
} else if (tmp != 0) {
|
||||
m5 = (tmp - 1) + 0x10;
|
||||
} else
|
||||
return;
|
||||
} else if (k < 8) {
|
||||
/* snow_0 */
|
||||
if (m5 != 0x10) {
|
||||
m5 = 0x10;
|
||||
} else if (tmp != 1) {
|
||||
m5 = 1;
|
||||
if (tmp != 0)
|
||||
m5 = tmp - 1;
|
||||
m5 += 0x10;
|
||||
} else
|
||||
return;
|
||||
} else if (k == 8) {
|
||||
/* snow_p1 */
|
||||
if (m5 != 0x10) {
|
||||
m5 = 0x10;
|
||||
} else if (tmp != 2) {
|
||||
m5 = 2;
|
||||
if (tmp <= 2)
|
||||
m5 = tmp + 1;
|
||||
m5 += 0x10;
|
||||
} else
|
||||
return;
|
||||
if (k < -8) { // well below the snow line
|
||||
if (!IsClearGround(tile, CL_SNOW)) return;
|
||||
if (GetClearDensity(tile) == 0) SetClearGroundDensity(tile, CL_GRASS, 3);
|
||||
} else {
|
||||
/* snow_p2_up */
|
||||
if (m5 != 0x10) {
|
||||
m5 = 0x10;
|
||||
} else if (tmp != 3) {
|
||||
m5 = tmp + 1 + 0x10;
|
||||
} else
|
||||
return;
|
||||
if (!IsClearGround(tile, CL_SNOW)) {
|
||||
SetClearGroundDensity(tile, CL_SNOW, 0);
|
||||
} else {
|
||||
uint density = min((uint)(k + 8) / 8, 3);
|
||||
|
||||
if (GetClearDensity(tile) < density) {
|
||||
AddClearDensity(tile, 1);
|
||||
} else if (GetClearDensity(tile) > density) {
|
||||
AddClearDensity(tile, -1);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_m[tile].m5 = m5;
|
||||
MarkTileDirtyByTile(tile);
|
||||
}
|
||||
|
||||
static void TileLoopClearDesert(TileIndex tile)
|
||||
{
|
||||
if ((_m[tile].m5 & 0x1C) == 0x14) return;
|
||||
if (IsClearGround(tile, CL_DESERT)) return;
|
||||
|
||||
if (GetMapExtraBits(tile) == 1) {
|
||||
_m[tile].m5 = 0x17;
|
||||
SetClearGroundDensity(tile, CL_DESERT, 3);
|
||||
} else {
|
||||
if (GetMapExtraBits(tile + TileDiffXY( 1, 0)) != 1 &&
|
||||
GetMapExtraBits(tile + TileDiffXY(-1, 0)) != 1 &&
|
||||
GetMapExtraBits(tile + TileDiffXY( 0, 1)) != 1 &&
|
||||
GetMapExtraBits(tile + TileDiffXY( 0, -1)) != 1)
|
||||
return;
|
||||
_m[tile].m5 = 0x15;
|
||||
SetClearGroundDensity(tile, CL_DESERT, 1);
|
||||
}
|
||||
|
||||
MarkTileDirtyByTile(tile);
|
||||
|
|
@ -711,8 +636,6 @@ static void TileLoopClearDesert(TileIndex tile)
|
|||
|
||||
static void TileLoop_Clear(TileIndex tile)
|
||||
{
|
||||
byte m5,m3;
|
||||
|
||||
TileLoopClearHelper(tile);
|
||||
|
||||
if (_opt.landscape == LT_DESERT) {
|
||||
|
|
@ -721,41 +644,45 @@ static void TileLoop_Clear(TileIndex tile)
|
|||
TileLoopClearAlps(tile);
|
||||
}
|
||||
|
||||
m5 = _m[tile].m5;
|
||||
if ((m5 & 0x1C) == 0x10 || (m5 & 0x1C) == 0x14) return;
|
||||
switch (GetClearGround(tile)) {
|
||||
case CL_GRASS:
|
||||
if (GetClearDensity(tile) == 3) return;
|
||||
|
||||
if ((m5 & 0x1C) != 0xC) {
|
||||
if ((m5 & 3) == 3) return;
|
||||
|
||||
if (_game_mode != GM_EDITOR) {
|
||||
m5 += 0x20;
|
||||
if (m5 >= 0x20) {
|
||||
// Didn't overflow
|
||||
_m[tile].m5 = m5;
|
||||
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 ? CL_GRASS : CL_ROUGH, 3);
|
||||
}
|
||||
/* did overflow, so continue */
|
||||
} else {
|
||||
m5 = (GB(Random(), 0, 8) > 21) ? 2 : 6;
|
||||
break;
|
||||
|
||||
case CL_FIELDS: {
|
||||
uint field_type;
|
||||
|
||||
if (_game_mode == GM_EDITOR) return;
|
||||
|
||||
if (GetClearCounter(tile) < 7) {
|
||||
AddClearCounter(tile, 1);
|
||||
return;
|
||||
} else {
|
||||
SetClearCounter(tile, 0);
|
||||
}
|
||||
|
||||
field_type = GB(_m[tile].m3, 0, 4);
|
||||
field_type = (field_type < 8) ? field_type + 1 : 0;
|
||||
SB(_m[tile].m3, 0, 4, field_type);
|
||||
break;
|
||||
}
|
||||
m5++;
|
||||
} else if (_game_mode != GM_EDITOR) {
|
||||
/* handle farm field */
|
||||
m5 += 0x20;
|
||||
if (m5 >= 0x20) {
|
||||
// Didn't overflow
|
||||
_m[tile].m5 = m5;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
/* overflowed */
|
||||
m3 = _m[tile].m3 + 1;
|
||||
assert( (m3 & 0xF) != 0);
|
||||
if ( (m3 & 0xF) >= 9) /* NOTE: will not work properly if m3&0xF == 0xF */
|
||||
m3 &= ~0xF;
|
||||
_m[tile].m3 = m3;
|
||||
}
|
||||
|
||||
_m[tile].m5 = m5;
|
||||
MarkTileDirtyByTile(tile);
|
||||
}
|
||||
|
||||
|
|
@ -768,7 +695,7 @@ void GenerateClearTile(void)
|
|||
i = ScaleByMapSize(GB(Random(), 0, 10) + 0x400);
|
||||
do {
|
||||
tile = RandomTile();
|
||||
if (IsTileType(tile, MP_CLEAR)) SB(_m[tile].m5, 2, 2, 1);
|
||||
if (IsTileType(tile, MP_CLEAR)) SetClearGroundDensity(tile, CL_ROUGH, 3);
|
||||
} while (--i);
|
||||
|
||||
/* add grey squares */
|
||||
|
|
@ -781,7 +708,7 @@ void GenerateClearTile(void)
|
|||
for (;;) {
|
||||
TileIndex tile_new;
|
||||
|
||||
SB(_m[tile].m5, 2, 2, 2);
|
||||
SetClearGroundDensity(tile, CL_ROCKS, 3);
|
||||
do {
|
||||
if (--j == 0) goto get_out;
|
||||
tile_new = tile + TileOffsByDir(GB(Random(), 0, 2));
|
||||
|
|
@ -804,24 +731,21 @@ static uint32 GetTileTrackStatus_Clear(TileIndex tile, TransportType mode)
|
|||
}
|
||||
|
||||
static const StringID _clear_land_str[] = {
|
||||
STR_080D_GRASS,
|
||||
STR_080B_ROUGH_LAND,
|
||||
STR_080A_ROCKS,
|
||||
STR_080E_FIELDS,
|
||||
STR_080F_SNOW_COVERED_LAND,
|
||||
STR_0810_DESERT,
|
||||
0,
|
||||
0,
|
||||
STR_080C_BARE_LAND,
|
||||
STR_080D_GRASS,
|
||||
STR_080D_GRASS,
|
||||
STR_080D_GRASS,
|
||||
STR_0810_DESERT
|
||||
};
|
||||
|
||||
static void GetTileDesc_Clear(TileIndex tile, TileDesc *td)
|
||||
{
|
||||
uint i = GB(_m[tile].m5, 2, 3);
|
||||
if (i == 0) i = GB(_m[tile].m5, 0, 2) + 8;
|
||||
td->str = _clear_land_str[i - 1];
|
||||
if (IsClearGround(tile, CL_GRASS) && GetClearDensity(tile) == 0) {
|
||||
td->str = STR_080C_BARE_LAND;
|
||||
} else {
|
||||
td->str = _clear_land_str[GetClearGround(tile)];
|
||||
}
|
||||
td->owner = GetTileOwner(tile);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "table/strings.h"
|
||||
#include "table/sprites.h"
|
||||
#include "functions.h"
|
||||
|
|
@ -885,32 +886,18 @@ static const byte _plantfarmfield_type[] = {1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 5, 5,
|
|||
static bool IsBadFarmFieldTile(TileIndex tile)
|
||||
{
|
||||
switch (GetTileType(tile)) {
|
||||
case MP_CLEAR: {
|
||||
byte m5 = _m[tile].m5 & 0x1C;
|
||||
return m5 == 0xC || m5 == 0x10;
|
||||
}
|
||||
|
||||
case MP_TREES:
|
||||
return false;
|
||||
|
||||
default:
|
||||
return true;
|
||||
case MP_CLEAR: return IsClearGround(tile, CL_FIELDS) || IsClearGround(tile, CL_SNOW);
|
||||
case MP_TREES: return false;
|
||||
default: return true;
|
||||
}
|
||||
}
|
||||
|
||||
static bool IsBadFarmFieldTile2(TileIndex tile)
|
||||
{
|
||||
switch (GetTileType(tile)) {
|
||||
case MP_CLEAR: {
|
||||
byte m5 = _m[tile].m5 & 0x1C;
|
||||
return m5 == 0x10;
|
||||
}
|
||||
|
||||
case MP_TREES:
|
||||
return false;
|
||||
|
||||
default:
|
||||
return true;
|
||||
case MP_CLEAR: return IsClearGround(tile, CL_SNOW);
|
||||
case MP_TREES: return false;
|
||||
default: return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
16
landscape.c
16
landscape.c
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "functions.h"
|
||||
#include "map.h"
|
||||
#include "player.h"
|
||||
|
|
@ -237,12 +238,13 @@ void DrawFoundation(TileInfo *ti, uint f)
|
|||
|
||||
void DoClearSquare(TileIndex tile)
|
||||
{
|
||||
ModifyTile(tile,
|
||||
MP_SETTYPE(MP_CLEAR) |
|
||||
MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,
|
||||
OWNER_NONE, /* map_owner */
|
||||
_generating_world ? 3 : 0 /* map5 */
|
||||
);
|
||||
SetTileType(tile, MP_CLEAR);
|
||||
SetTileOwner(tile, OWNER_NONE);
|
||||
_m[tile].m2 = 0;
|
||||
_m[tile].m3 = 0;
|
||||
_m[tile].m4 = 0;
|
||||
SetClearGroundDensity(tile, CL_GRASS, _generating_world ? 3 : 0);
|
||||
MarkTileDirtyByTile(tile);
|
||||
}
|
||||
|
||||
uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)
|
||||
|
|
@ -615,7 +617,7 @@ static void CreateDesertOrRainForest(void)
|
|||
for (data = _make_desert_or_rainforest_data;
|
||||
data != endof(_make_desert_or_rainforest_data); ++data) {
|
||||
TileIndex t = TILE_MASK(tile + ToTileIndexDiff(*data));
|
||||
if (IsTileType(t, MP_CLEAR) && (_m[t].m5 & 0x1c) == 0x14) break;
|
||||
if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CL_DESERT)) break;
|
||||
}
|
||||
if (data == endof(_make_desert_or_rainforest_data))
|
||||
SetMapExtraBits(tile, 2);
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "functions.h"
|
||||
#include "spritecache.h"
|
||||
#include "table/strings.h"
|
||||
|
|
@ -458,12 +459,8 @@ static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)
|
|||
}
|
||||
|
||||
|
||||
static const uint32 _vegetation_clear_bits[4 + 7] = {
|
||||
MKCOLOR(0x37373737), ///< bare land
|
||||
MKCOLOR(0x37373737), ///< 1/3 grass
|
||||
MKCOLOR(0x37373737), ///< 2/3 grass
|
||||
static const uint32 _vegetation_clear_bits[] = {
|
||||
MKCOLOR(0x54545454), ///< full grass
|
||||
|
||||
MKCOLOR(0x52525252), ///< rough land
|
||||
MKCOLOR(0x0A0A0A0A), ///< rocks
|
||||
MKCOLOR(0x25252525), ///< fields
|
||||
|
|
@ -476,14 +473,15 @@ static const uint32 _vegetation_clear_bits[4 + 7] = {
|
|||
static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)
|
||||
{
|
||||
TileType t = GetEffectiveTileType(tile);
|
||||
int i;
|
||||
uint32 bits;
|
||||
|
||||
switch (t) {
|
||||
case MP_CLEAR:
|
||||
i = (_m[tile].m5 & 0x1F) - 4;
|
||||
if (i >= 0) i >>= 2;
|
||||
bits = _vegetation_clear_bits[i + 4];
|
||||
if (IsClearGround(tile, CL_GRASS) && GetClearDensity(tile) < 3) {
|
||||
bits = MKCOLOR(0x37373737);
|
||||
} else {
|
||||
bits = _vegetation_clear_bits[GetClearGround(tile)];
|
||||
}
|
||||
break;
|
||||
|
||||
case MP_INDUSTRY:
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "table/sprites.h"
|
||||
#include "table/strings.h"
|
||||
#include "functions.h"
|
||||
|
|
@ -81,7 +82,9 @@ static void GenerateRockyArea(TileIndex end, TileIndex start)
|
|||
|
||||
BEGIN_TILE_LOOP(tile, size_x, size_y, TileXY(sx, sy)) {
|
||||
if (IsTileType(tile, MP_CLEAR) || IsTileType(tile, MP_TREES)) {
|
||||
ModifyTile(tile, MP_SETTYPE(MP_CLEAR) | MP_MAP5, (_m[tile].m5 & ~0x1C) | 0xB);
|
||||
SetTileType(tile, MP_CLEAR);
|
||||
SetClearGroundDensity(tile, CL_ROCKS, 3);
|
||||
MarkTileDirtyByTile(tile);
|
||||
success = true;
|
||||
}
|
||||
} END_TILE_LOOP(tile, size_x, size_y, 0);
|
||||
|
|
|
|||
90
tree_cmd.c
90
tree_cmd.c
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "openttd.h"
|
||||
#include "clear.h"
|
||||
#include "table/strings.h"
|
||||
#include "table/sprites.h"
|
||||
#include "table/tree_land.h"
|
||||
|
|
@ -73,10 +74,10 @@ static void DoPlaceMoreTrees(TileIndex tile)
|
|||
uint dist = myabs(x) + myabs(y);
|
||||
TileIndex cur_tile = TILE_MASK(tile + TileDiffXY(x, y));
|
||||
|
||||
/* Only on tiles within 13 squares from tile,
|
||||
on clear tiles, and NOT on farm-tiles or rocks */
|
||||
if (dist <= 13 && IsTileType(cur_tile, MP_CLEAR) &&
|
||||
(_m[cur_tile].m5 & 0x1F) != 0x0F && (_m[cur_tile].m5 & 0x1C) != 8) {
|
||||
if (dist <= 13 &&
|
||||
IsTileType(cur_tile, MP_CLEAR) &&
|
||||
!IsClearGround(cur_tile, CL_FIELDS) &&
|
||||
!IsClearGround(cur_tile, CL_ROCKS)) {
|
||||
PlaceTree(cur_tile, r, dist <= 6 ? 0xC0 : 0);
|
||||
}
|
||||
}
|
||||
|
|
@ -98,8 +99,9 @@ void PlaceTreesRandomly(void)
|
|||
do {
|
||||
uint32 r = Random();
|
||||
TileIndex tile = RandomTileSeed(r);
|
||||
/* Only on clear tiles, and NOT on farm-tiles or rocks */
|
||||
if (IsTileType(tile, MP_CLEAR) && (_m[tile].m5 & 0x1F) != 0x0F && (_m[tile].m5 & 0x1C) != 8) {
|
||||
if (IsTileType(tile, MP_CLEAR) &&
|
||||
!IsClearGround(tile, CL_FIELDS) &&
|
||||
!IsClearGround(tile, CL_ROCKS)) {
|
||||
PlaceTree(tile, r, 0);
|
||||
}
|
||||
} while (--i);
|
||||
|
|
@ -182,11 +184,11 @@ int32 CmdPlantTree(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
|
|||
continue;
|
||||
}
|
||||
|
||||
// it's expensive to clear farmland
|
||||
if ((_m[tile].m5 & 0x1F) == 0xF)
|
||||
cost += _price.clear_3;
|
||||
else if ((_m[tile].m5 & 0x1C) == 8)
|
||||
cost += _price.clear_2;
|
||||
switch (GetClearGround(tile)) {
|
||||
case CL_FIELDS: cost += _price.clear_3; break;
|
||||
case CL_ROCKS: cost += _price.clear_2; break;
|
||||
default: break;
|
||||
}
|
||||
|
||||
if (flags & DC_EXEC) {
|
||||
int treetype;
|
||||
|
|
@ -198,18 +200,10 @@ int32 CmdPlantTree(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
|
|||
ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);
|
||||
}
|
||||
|
||||
switch (_m[tile].m5 & 0x1C) {
|
||||
case 0x04:
|
||||
m2 = 16;
|
||||
break;
|
||||
|
||||
case 0x10:
|
||||
m2 = ((_m[tile].m5 & 3) << 6) | 0x20;
|
||||
break;
|
||||
|
||||
default:
|
||||
m2 = 0;
|
||||
break;
|
||||
switch (GetClearGround(tile)) {
|
||||
case CL_ROUGH: m2 = 16; break;
|
||||
case CL_SNOW: m2 = GetClearDensity(tile) << 6 | 0x20; break;
|
||||
default: m2 = 0; break;
|
||||
}
|
||||
|
||||
treetype = p1;
|
||||
|
|
@ -456,7 +450,6 @@ static void TileLoopTreesAlps(TileIndex tile)
|
|||
static void TileLoop_Trees(TileIndex tile)
|
||||
{
|
||||
byte m5;
|
||||
uint16 m2;
|
||||
|
||||
static const TileIndexDiffC _tileloop_trees_dir[] = {
|
||||
{-1, -1},
|
||||
|
|
@ -504,13 +497,15 @@ static void TileLoop_Trees(TileIndex tile)
|
|||
|
||||
if (!IsTileType(tile, MP_CLEAR)) return;
|
||||
|
||||
if ( (_m[tile].m5 & 0x1C) == 4) {
|
||||
_m[tile].m2 = 0x10;
|
||||
} else if ((_m[tile].m5 & 0x1C) == 16) {
|
||||
_m[tile].m2 = ((_m[tile].m5 & 3) << 6) | 0x20;
|
||||
} else {
|
||||
if ((_m[tile].m5 & 0x1F) != 3) return;
|
||||
_m[tile].m2 = 0;
|
||||
switch (GetClearGround(tile)) {
|
||||
case CL_GRASS:
|
||||
if (GetClearDensity(tile) != 3) return;
|
||||
_m[tile].m2 = 0;
|
||||
break;
|
||||
|
||||
case CL_ROUGH: _m[tile].m2 = 0x10; break;
|
||||
case CL_SNOW: _m[tile].m2 = GetClearDensity(tile) << 6 | 0x20; break;
|
||||
default: return;
|
||||
}
|
||||
|
||||
_m[tile].m4 = 0;
|
||||
|
|
@ -532,15 +527,14 @@ static void TileLoop_Trees(TileIndex tile)
|
|||
} else {
|
||||
/* just one tree, change type into MP_CLEAR */
|
||||
SetTileType(tile, MP_CLEAR);
|
||||
|
||||
m5 = 3;
|
||||
m2 = _m[tile].m2;
|
||||
if ((m2 & 0x30) != 0) { // on snow/desert or rough land
|
||||
m5 = (m2 >> 6) | 0x10;
|
||||
if ((m2 & 0x30) != 0x20) // if not on snow/desert, then on rough land
|
||||
m5 = 7;
|
||||
}
|
||||
SetTileOwner(tile, OWNER_NONE);
|
||||
switch (_m[tile].m2 & 0x30) {
|
||||
case 0x00: SetClearGroundDensity(tile, CL_GRASS, 3); break;
|
||||
case 0x10: SetClearGroundDensity(tile, CL_ROUGH, 3); break;
|
||||
default: SetClearGroundDensity(tile, CL_SNOW, GB(_m[tile].m2, 6, 2)); break;
|
||||
}
|
||||
MarkTileDirtyByTile(tile);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
/* in the middle of a transition, change to next */
|
||||
|
|
@ -555,20 +549,20 @@ void OnTick_Trees(void)
|
|||
{
|
||||
uint32 r;
|
||||
TileIndex tile;
|
||||
byte m;
|
||||
ClearGround ct;
|
||||
int tree;
|
||||
|
||||
/* place a tree at a random rainforest spot */
|
||||
if (_opt.landscape == LT_DESERT &&
|
||||
(r = Random(), tile = RandomTileSeed(r), GetMapExtraBits(tile) == 2) &&
|
||||
IsTileType(tile, MP_CLEAR) &&
|
||||
(m = _m[tile].m5 & 0x1C, m <= 4) &&
|
||||
(ct = GetClearGround(tile), ct == CL_GRASS || ct == CL_ROUGH) &&
|
||||
(tree = GetRandomTreeType(tile, GB(r, 24, 8))) >= 0) {
|
||||
|
||||
ModifyTile(tile,
|
||||
MP_SETTYPE(MP_TREES) |
|
||||
MP_MAP2 | MP_MAP3LO | MP_MAP3HI | MP_MAP5,
|
||||
(m == 4 ? 0x10 : 0),
|
||||
(ct == CL_ROUGH ? 0x10 : 0),
|
||||
tree,
|
||||
_m[tile].m4 & ~3,
|
||||
0
|
||||
|
|
@ -582,16 +576,14 @@ void OnTick_Trees(void)
|
|||
r = Random();
|
||||
tile = TILE_MASK(r);
|
||||
if (IsTileType(tile, MP_CLEAR) &&
|
||||
(m = _m[tile].m5 & 0x1C, m == 0 || m == 4 || m == 0x10) &&
|
||||
(ct = GetClearGround(tile), ct == CL_GRASS || ct == CL_ROUGH || ct == CL_SNOW) &&
|
||||
(tree = GetRandomTreeType(tile, GB(r, 24, 8))) >= 0) {
|
||||
int m2;
|
||||
|
||||
if (m == 0) {
|
||||
m2 = 0;
|
||||
} else if (m == 4) {
|
||||
m2 = 0x10;
|
||||
} else {
|
||||
m2 = ((_m[tile].m5 & 3) << 6) | 0x20;
|
||||
switch (ct) {
|
||||
case CL_GRASS: m2 = 0;
|
||||
case CL_ROUGH: m2 = 0x10;
|
||||
default: m2 = (GetClearDensity(tile) << 6) | 0x20;
|
||||
}
|
||||
|
||||
ModifyTile(tile,
|
||||
|
|
|
|||
Loading…
Reference in New Issue