mirror of
https://github.com/JGRennison/OpenTTD-patches.git
synced 2024-10-31 15:20:10 +00:00
644 lines
13 KiB
C
644 lines
13 KiB
C
/* $Id$ */
|
|
|
|
#include "stdafx.h"
|
|
#include "openttd.h"
|
|
#include "clear_map.h"
|
|
#include "functions.h"
|
|
#include "map.h"
|
|
#include "player.h"
|
|
#include "spritecache.h"
|
|
#include "table/sprites.h"
|
|
#include "tile.h"
|
|
#include <stdarg.h>
|
|
#include "viewport.h"
|
|
#include "command.h"
|
|
#include "vehicle.h"
|
|
#include "variables.h"
|
|
#include "void_map.h"
|
|
#include "water_map.h"
|
|
|
|
extern const TileTypeProcs
|
|
_tile_type_clear_procs,
|
|
_tile_type_rail_procs,
|
|
_tile_type_road_procs,
|
|
_tile_type_town_procs,
|
|
_tile_type_trees_procs,
|
|
_tile_type_station_procs,
|
|
_tile_type_water_procs,
|
|
_tile_type_dummy_procs,
|
|
_tile_type_industry_procs,
|
|
_tile_type_tunnelbridge_procs,
|
|
_tile_type_unmovable_procs;
|
|
|
|
const TileTypeProcs * const _tile_type_procs[16] = {
|
|
&_tile_type_clear_procs,
|
|
&_tile_type_rail_procs,
|
|
&_tile_type_road_procs,
|
|
&_tile_type_town_procs,
|
|
&_tile_type_trees_procs,
|
|
&_tile_type_station_procs,
|
|
&_tile_type_water_procs,
|
|
&_tile_type_dummy_procs,
|
|
&_tile_type_industry_procs,
|
|
&_tile_type_tunnelbridge_procs,
|
|
&_tile_type_unmovable_procs,
|
|
};
|
|
|
|
/* landscape slope => sprite */
|
|
const byte _tileh_to_sprite[32] = {
|
|
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,0,
|
|
0,0,0,0,0,0,0,16,0,0,0,17,0,15,18,0,
|
|
};
|
|
|
|
const byte _inclined_tileh[] = {
|
|
3, 9, 3, 6, 12, 6, 12, 9
|
|
};
|
|
|
|
|
|
/* find the landscape height for the coordinates x y */
|
|
void FindLandscapeHeight(TileInfo *ti, uint x, uint y)
|
|
{
|
|
ti->x = x;
|
|
ti->y = y;
|
|
|
|
if (x >= MapMaxX() * TILE_SIZE - 1 || y >= MapMaxY() * TILE_SIZE - 1) {
|
|
ti->tileh = 0;
|
|
ti->type = MP_VOID;
|
|
ti->tile = 0;
|
|
ti->z = 0;
|
|
} else {
|
|
TileIndex tile = TileVirtXY(x, y);
|
|
|
|
ti->tile = tile;
|
|
ti->type = GetTileType(tile);
|
|
ti->tileh = GetTileSlope(tile, &ti->z);
|
|
}
|
|
}
|
|
|
|
uint GetPartialZ(int x, int y, int corners)
|
|
{
|
|
int z = 0;
|
|
|
|
switch (corners) {
|
|
case 1:
|
|
if (x - y >= 0)
|
|
z = (x - y) >> 1;
|
|
break;
|
|
|
|
case 2:
|
|
y^=0xF;
|
|
if ( (x - y) >= 0)
|
|
z = (x - y) >> 1;
|
|
break;
|
|
|
|
case 3:
|
|
z = (x>>1) + 1;
|
|
break;
|
|
|
|
case 4:
|
|
if (y - x >= 0)
|
|
z = (y - x) >> 1;
|
|
break;
|
|
|
|
case 5:
|
|
case 10:
|
|
case 15:
|
|
z = 4;
|
|
break;
|
|
|
|
case 6:
|
|
z = (y>>1) + 1;
|
|
break;
|
|
|
|
case 7:
|
|
z = 8;
|
|
y^=0xF;
|
|
if (x - y < 0)
|
|
z += (x - y) >> 1;
|
|
break;
|
|
|
|
case 8:
|
|
y ^= 0xF;
|
|
if (y - x >= 0)
|
|
z = (y - x) >> 1;
|
|
break;
|
|
|
|
case 9:
|
|
z = (y^0xF)>>1;
|
|
break;
|
|
|
|
case 11:
|
|
z = 8;
|
|
if (x - y < 0)
|
|
z += (x - y) >> 1;
|
|
break;
|
|
|
|
case 12:
|
|
z = (x^0xF)>>1;
|
|
break;
|
|
|
|
case 13:
|
|
z = 8;
|
|
y ^= 0xF;
|
|
if (y - x < 0)
|
|
z += (y - x) >> 1;
|
|
break;
|
|
|
|
case 14:
|
|
z = 8;
|
|
if (y - x < 0)
|
|
z += (y - x) >> 1;
|
|
break;
|
|
|
|
case 23:
|
|
z = 1 + ((x+y)>>1);
|
|
break;
|
|
|
|
case 27:
|
|
z = 1 + ((x+(y^0xF))>>1);
|
|
break;
|
|
|
|
case 29:
|
|
z = 1 + (((x^0xF)+(y^0xF))>>1);
|
|
break;
|
|
|
|
case 30:
|
|
z = 1 + (((x^0xF)+(y^0xF))>>1);
|
|
break;
|
|
}
|
|
|
|
return z;
|
|
}
|
|
|
|
uint GetSlopeZ(int x, int y)
|
|
{
|
|
TileInfo ti;
|
|
|
|
FindLandscapeHeight(&ti, x, y);
|
|
|
|
return _tile_type_procs[ti.type]->get_slope_z_proc(&ti);
|
|
}
|
|
|
|
// direction=true: check for foundation in east and south corner
|
|
// direction=false: check for foundation in west and south corner
|
|
static bool HasFoundation(TileIndex tile, bool direction)
|
|
{
|
|
bool south, other; // southern corner and east/west corner
|
|
uint tileh = GetTileSlope(tile, NULL);
|
|
uint slope = _tile_type_procs[GetTileType(tile)]->get_slope_tileh_proc(tile, tileh);
|
|
|
|
if (slope == 0 && slope != tileh) tileh = 15;
|
|
south = (tileh & 2) != (slope & 2);
|
|
|
|
if (direction) {
|
|
other = (tileh & 4) != (slope & 4);
|
|
} else {
|
|
other = (tileh & 1) != (slope & 1);
|
|
}
|
|
return south || other;
|
|
}
|
|
|
|
void DrawFoundation(TileInfo *ti, uint f)
|
|
{
|
|
uint32 sprite_base = SPR_SLOPES_BASE-14;
|
|
|
|
if (HasFoundation(TILE_ADDXY(ti->tile, 0, -1), true)) sprite_base += 22; // foundation in NW direction
|
|
if (HasFoundation(TILE_ADDXY(ti->tile, -1, 0), false)) sprite_base += 44; // foundation in NE direction
|
|
|
|
if (f < 15) {
|
|
// leveled foundation
|
|
if (sprite_base < SPR_SLOPES_BASE) sprite_base = SPR_FOUNDATION_BASE + 1; // use original slope sprites
|
|
|
|
AddSortableSpriteToDraw(f - 1 + sprite_base, ti->x, ti->y, 16, 16, 7, ti->z);
|
|
ti->z += 8;
|
|
ti->tileh = 0;
|
|
OffsetGroundSprite(31, 1);
|
|
} else {
|
|
// inclined foundation
|
|
sprite_base += 14;
|
|
|
|
AddSortableSpriteToDraw(
|
|
HASBIT((1<<1) | (1<<2) | (1<<4) | (1<<8), ti->tileh) ? sprite_base + (f - 15) : SPR_FOUNDATION_BASE + ti->tileh,
|
|
ti->x, ti->y, 1, 1, 1, ti->z
|
|
);
|
|
|
|
ti->tileh = _inclined_tileh[f - 15];
|
|
OffsetGroundSprite(31, 9);
|
|
}
|
|
}
|
|
|
|
void DoClearSquare(TileIndex tile)
|
|
{
|
|
MakeClear(tile, CLEAR_GRASS, _generating_world ? 3 : 0);
|
|
MarkTileDirtyByTile(tile);
|
|
}
|
|
|
|
uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)
|
|
{
|
|
return _tile_type_procs[GetTileType(tile)]->get_tile_track_status_proc(tile, mode);
|
|
}
|
|
|
|
void ChangeTileOwner(TileIndex tile, byte old_player, byte new_player)
|
|
{
|
|
_tile_type_procs[GetTileType(tile)]->change_tile_owner_proc(tile, old_player, new_player);
|
|
}
|
|
|
|
void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)
|
|
{
|
|
memset(ac, 0, sizeof(AcceptedCargo));
|
|
_tile_type_procs[GetTileType(tile)]->get_accepted_cargo_proc(tile, ac);
|
|
}
|
|
|
|
void AnimateTile(TileIndex tile)
|
|
{
|
|
_tile_type_procs[GetTileType(tile)]->animate_tile_proc(tile);
|
|
}
|
|
|
|
void ClickTile(TileIndex tile)
|
|
{
|
|
_tile_type_procs[GetTileType(tile)]->click_tile_proc(tile);
|
|
}
|
|
|
|
void DrawTile(TileInfo *ti)
|
|
{
|
|
_tile_type_procs[ti->type]->draw_tile_proc(ti);
|
|
}
|
|
|
|
void GetTileDesc(TileIndex tile, TileDesc *td)
|
|
{
|
|
_tile_type_procs[GetTileType(tile)]->get_tile_desc_proc(tile, td);
|
|
}
|
|
|
|
/** Clear a piece of landscape
|
|
* @param tile tile to clear
|
|
* @param p1 unused
|
|
* @param p2 unused
|
|
*/
|
|
int32 CmdLandscapeClear(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
|
|
{
|
|
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
|
|
|
|
return _tile_type_procs[GetTileType(tile)]->clear_tile_proc(tile, flags);
|
|
}
|
|
|
|
/** Clear a big piece of landscape
|
|
* @param tile end tile of area dragging
|
|
* @param p1 start tile of area dragging
|
|
* @param p2 unused
|
|
*/
|
|
int32 CmdClearArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
|
|
{
|
|
int32 cost, ret, money;
|
|
int ex;
|
|
int ey;
|
|
int sx,sy;
|
|
int x,y;
|
|
bool success = false;
|
|
|
|
if (p1 >= MapSize()) return CMD_ERROR;
|
|
|
|
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
|
|
|
|
// make sure sx,sy are smaller than ex,ey
|
|
ex = TileX(tile);
|
|
ey = TileY(tile);
|
|
sx = TileX(p1);
|
|
sy = TileY(p1);
|
|
if (ex < sx) intswap(ex, sx);
|
|
if (ey < sy) intswap(ey, sy);
|
|
|
|
money = GetAvailableMoneyForCommand();
|
|
cost = 0;
|
|
|
|
for (x = sx; x <= ex; ++x) {
|
|
for (y = sy; y <= ey; ++y) {
|
|
ret = DoCommand(TileXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
|
|
if (CmdFailed(ret)) continue;
|
|
cost += ret;
|
|
success = true;
|
|
|
|
if (flags & DC_EXEC) {
|
|
if (ret > 0 && (money -= ret) < 0) {
|
|
_additional_cash_required = ret;
|
|
return cost - ret;
|
|
}
|
|
DoCommand(TileXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);
|
|
|
|
// draw explosion animation...
|
|
if ((x == sx || x == ex) && (y == sy || y == ey)) {
|
|
// big explosion in each corner, or small explosion for single tiles
|
|
CreateEffectVehicleAbove(x * TILE_SIZE + 8, y * TILE_SIZE + 8, 2,
|
|
sy == ey && sx == ex ? EV_EXPLOSION_SMALL : EV_EXPLOSION_LARGE
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (success) ? cost : CMD_ERROR;
|
|
}
|
|
|
|
|
|
#define TILELOOP_BITS 4
|
|
#define TILELOOP_SIZE (1 << TILELOOP_BITS)
|
|
#define TILELOOP_ASSERTMASK ((TILELOOP_SIZE-1) + ((TILELOOP_SIZE-1) << MapLogX()))
|
|
#define TILELOOP_CHKMASK (((1 << (MapLogX() - TILELOOP_BITS))-1) << TILELOOP_BITS)
|
|
|
|
void RunTileLoop(void)
|
|
{
|
|
TileIndex tile;
|
|
uint count;
|
|
|
|
tile = _cur_tileloop_tile;
|
|
|
|
assert( (tile & ~TILELOOP_ASSERTMASK) == 0);
|
|
count = (MapSizeX() / TILELOOP_SIZE) * (MapSizeY() / TILELOOP_SIZE);
|
|
do {
|
|
_tile_type_procs[GetTileType(tile)]->tile_loop_proc(tile);
|
|
|
|
if (TileX(tile) < MapSizeX() - TILELOOP_SIZE) {
|
|
tile += TILELOOP_SIZE; /* no overflow */
|
|
} else {
|
|
tile = TILE_MASK(tile - TILELOOP_SIZE * (MapSizeX() / TILELOOP_SIZE - 1) + TileDiffXY(0, TILELOOP_SIZE)); /* x would overflow, also increase y */
|
|
}
|
|
} while (--count);
|
|
assert( (tile & ~TILELOOP_ASSERTMASK) == 0);
|
|
|
|
tile += 9;
|
|
if (tile & TILELOOP_CHKMASK)
|
|
tile = (tile + MapSizeX()) & TILELOOP_ASSERTMASK;
|
|
_cur_tileloop_tile = tile;
|
|
}
|
|
|
|
void InitializeLandscape(void)
|
|
{
|
|
uint maxx = MapMaxX();
|
|
uint maxy = MapMaxY();
|
|
uint sizex = MapSizeX();
|
|
uint x;
|
|
uint y;
|
|
|
|
for (y = 0; y < maxy; y++) {
|
|
for (x = 0; x < maxx; x++) {
|
|
MakeClear(sizex * y + x, CLEAR_GRASS, 3);
|
|
SetTileHeight(sizex * y + x, 0);
|
|
}
|
|
MakeVoid(sizex * y + x);
|
|
}
|
|
for (x = 0; x < sizex; x++) MakeVoid(sizex * y + x);
|
|
}
|
|
|
|
void ConvertGroundTilesIntoWaterTiles(void)
|
|
{
|
|
TileIndex tile = 0;
|
|
uint h;
|
|
|
|
for (tile = 0; tile < MapSize(); ++tile) {
|
|
if (IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == 0 && h == 0) {
|
|
MakeWater(tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const byte _genterrain_tbl_1[5] = { 10, 22, 33, 37, 4 };
|
|
static const byte _genterrain_tbl_2[5] = { 0, 0, 0, 0, 33 };
|
|
|
|
static void GenerateTerrain(int type, int flag)
|
|
{
|
|
uint32 r;
|
|
uint x;
|
|
uint y;
|
|
uint w;
|
|
uint h;
|
|
const Sprite* template;
|
|
const byte *p;
|
|
Tile* tile;
|
|
byte direction;
|
|
|
|
r = Random();
|
|
template = GetSprite((((r >> 24) * _genterrain_tbl_1[type]) >> 8) + _genterrain_tbl_2[type] + 4845);
|
|
|
|
x = r & MapMaxX();
|
|
y = (r >> MapLogX()) & MapMaxY();
|
|
|
|
|
|
if (x < 2 || y < 2) return;
|
|
|
|
direction = GB(r, 22, 2);
|
|
if (direction & 1) {
|
|
w = template->height;
|
|
h = template->width;
|
|
} else {
|
|
w = template->width;
|
|
h = template->height;
|
|
}
|
|
p = template->data;
|
|
|
|
if (flag & 4) {
|
|
uint xw = x * MapSizeY();
|
|
uint yw = y * MapSizeX();
|
|
uint bias = (MapSizeX() + MapSizeY()) * 16;
|
|
|
|
switch (flag & 3) {
|
|
case 0:
|
|
if (xw + yw > MapSize() - bias) return;
|
|
break;
|
|
|
|
case 1:
|
|
if (yw < xw + bias) return;
|
|
break;
|
|
|
|
case 2:
|
|
if (xw + yw < MapSize() + bias) return;
|
|
break;
|
|
|
|
case 3:
|
|
if (xw < yw + bias) return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (x + w >= MapMaxX() - 1) return;
|
|
if (y + h >= MapMaxY() - 1) return;
|
|
|
|
tile = &_m[TileXY(x, y)];
|
|
|
|
switch (direction) {
|
|
case 0:
|
|
do {
|
|
Tile* tile_cur = tile;
|
|
uint w_cur;
|
|
|
|
for (w_cur = w; w_cur != 0; --w_cur) {
|
|
if (*p >= tile_cur->type_height) tile_cur->type_height = *p;
|
|
p++;
|
|
tile_cur++;
|
|
}
|
|
tile += TileDiffXY(0, 1);
|
|
} while (--h != 0);
|
|
break;
|
|
|
|
case 1:
|
|
do {
|
|
Tile* tile_cur = tile;
|
|
uint h_cur;
|
|
|
|
for (h_cur = h; h_cur != 0; --h_cur) {
|
|
if (*p >= tile_cur->type_height) tile_cur->type_height = *p;
|
|
p++;
|
|
tile_cur += TileDiffXY(0, 1);
|
|
}
|
|
tile++;
|
|
} while (--w != 0);
|
|
break;
|
|
|
|
case 2:
|
|
tile += TileDiffXY(w - 1, 0);
|
|
do {
|
|
Tile* tile_cur = tile;
|
|
uint w_cur;
|
|
|
|
for (w_cur = w; w_cur != 0; --w_cur) {
|
|
if (*p >= tile_cur->type_height) tile_cur->type_height = *p;
|
|
p++;
|
|
tile_cur--;
|
|
}
|
|
tile += TileDiffXY(0, 1);
|
|
} while (--h != 0);
|
|
break;
|
|
|
|
case 3:
|
|
tile += TileDiffXY(0, h - 1);
|
|
do {
|
|
Tile* tile_cur = tile;
|
|
uint h_cur;
|
|
|
|
for (h_cur = h; h_cur != 0; --h_cur) {
|
|
if (*p >= tile_cur->type_height) tile_cur->type_height = *p;
|
|
p++;
|
|
tile_cur -= TileDiffXY(0, 1);
|
|
}
|
|
tile++;
|
|
} while (--w != 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
#include "table/genland.h"
|
|
|
|
static void CreateDesertOrRainForest(void)
|
|
{
|
|
TileIndex tile;
|
|
const TileIndexDiffC *data;
|
|
uint i;
|
|
|
|
for (tile = 0; tile != MapSize(); ++tile) {
|
|
for (data = _make_desert_or_rainforest_data;
|
|
data != endof(_make_desert_or_rainforest_data); ++data) {
|
|
TileIndex t = TILE_MASK(tile + ToTileIndexDiff(*data));
|
|
if (TileHeight(t) >= 4 || IsTileType(t, MP_WATER)) break;
|
|
}
|
|
if (data == endof(_make_desert_or_rainforest_data))
|
|
SetTropicZone(tile, TROPICZONE_DESERT);
|
|
}
|
|
|
|
for (i = 0; i != 256; i++)
|
|
RunTileLoop();
|
|
|
|
for (tile = 0; tile != MapSize(); ++tile) {
|
|
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) && IsClearGround(t, CLEAR_DESERT)) break;
|
|
}
|
|
if (data == endof(_make_desert_or_rainforest_data))
|
|
SetTropicZone(tile, TROPICZONE_RAINFOREST);
|
|
}
|
|
}
|
|
|
|
void GenerateLandscape(void)
|
|
{
|
|
uint i;
|
|
uint flag;
|
|
uint32 r;
|
|
|
|
switch (_opt.landscape) {
|
|
case LT_HILLY:
|
|
for (i = ScaleByMapSize((Random() & 0x7F) + 950); i != 0; --i) {
|
|
GenerateTerrain(2, 0);
|
|
}
|
|
|
|
r = Random();
|
|
flag = GB(r, 0, 2) | 4;
|
|
for (i = ScaleByMapSize(GB(r, 16, 7) + 450); i != 0; --i) {
|
|
GenerateTerrain(4, flag);
|
|
}
|
|
break;
|
|
|
|
case LT_DESERT:
|
|
for (i = ScaleByMapSize((Random() & 0x7F) + 170); i != 0; --i) {
|
|
GenerateTerrain(0, 0);
|
|
}
|
|
|
|
r = Random();
|
|
flag = GB(r, 0, 2) | 4;
|
|
for (i = ScaleByMapSize(GB(r, 16, 8) + 1700); i != 0; --i) {
|
|
GenerateTerrain(0, flag);
|
|
}
|
|
|
|
flag ^= 2;
|
|
|
|
for (i = ScaleByMapSize((Random() & 0x7F) + 410); i != 0; --i) {
|
|
GenerateTerrain(3, flag);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
i = ScaleByMapSize((Random() & 0x7F) + (3 - _opt.diff.quantity_sea_lakes) * 256 + 100);
|
|
for (; i != 0; --i) {
|
|
GenerateTerrain(_opt.diff.terrain_type, 0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
ConvertGroundTilesIntoWaterTiles();
|
|
|
|
if (_opt.landscape == LT_DESERT) CreateDesertOrRainForest();
|
|
}
|
|
|
|
void OnTick_Town(void);
|
|
void OnTick_Trees(void);
|
|
void OnTick_Station(void);
|
|
void OnTick_Industry(void);
|
|
|
|
void OnTick_Players(void);
|
|
void OnTick_Train(void);
|
|
|
|
void CallLandscapeTick(void)
|
|
{
|
|
OnTick_Town();
|
|
OnTick_Trees();
|
|
OnTick_Station();
|
|
OnTick_Industry();
|
|
|
|
OnTick_Players();
|
|
OnTick_Train();
|
|
}
|
|
|
|
TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng)
|
|
{
|
|
int rn = rng;
|
|
uint32 r = Random();
|
|
|
|
return TILE_MASK(TileXY(
|
|
TileX(a) + (GB(r, 0, 8) * rn * 2 >> 8) - rn,
|
|
TileY(a) + (GB(r, 8, 8) * rn * 2 >> 8) - rn
|
|
));
|
|
}
|
|
|
|
bool IsValidTile(TileIndex tile)
|
|
{
|
|
return (tile < MapSizeX() * MapMaxY() && TileX(tile) != MapMaxX());
|
|
}
|