mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

(svn r1386) Move TileIndexDiff to map.h 

Move _tileoffs_by_dir to map.[ch] and encapsulate it in TileOffsByDir()
release/0.4.5
tron 2005-01-05 13:32:03 +00:00
parent 2543158c8e
commit 67161506ad
20 changed files with 87 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
ai.c
View File

@ -1716,7 +1716,7 @@ static void AiDoTerraformLand(TileIndex tile, int dir, int unk, int mode)
unk &= (int)r; unk &= (int)r;
do { do {
tile = TILE_MASK(tile + _tileoffs_by_dir[dir]); tile = TILE_MASK(tile + TileOffsByDir(dir));
r >>= 2; r >>= 2;
if (r&2) { if (r&2) {
@ -1822,7 +1822,7 @@ static TileIndex AiGetEdgeOfDefaultRailBlock(byte rule, TileIndex tile, byte cmd
while (p->mode != 3 || !((--cmd) & 0x80)) p++; while (p->mode != 3 || !((--cmd) & 0x80)) p++;
return tile + p->tileoffs - _tileoffs_by_dir[*dir = p->attr]; return tile + p->tileoffs - TileOffsByDir(*dir = p->attr);
} }
typedef struct AiRailPathFindData { typedef struct AiRailPathFindData {
@ -1855,7 +1855,7 @@ static bool AiDoFollowTrack(Player *p)
arpfd.tile2 = p->ai.cur_tile_a; arpfd.tile2 = p->ai.cur_tile_a;
arpfd.flag = false; arpfd.flag = false;
arpfd.count = 0; arpfd.count = 0;
FollowTrack(p->ai.cur_tile_a + _tileoffs_by_dir[p->ai.cur_dir_a], 0x2000 | TRANSPORT_RAIL, p->ai.cur_dir_a^2, FollowTrack(p->ai.cur_tile_a + TileOffsByDir(p->ai.cur_dir_a), 0x2000 | TRANSPORT_RAIL, p->ai.cur_dir_a^2,
(TPFEnumProc*)AiEnumFollowTrack, NULL, &arpfd); (TPFEnumProc*)AiEnumFollowTrack, NULL, &arpfd);
return arpfd.count > 8; return arpfd.count > 8;
} }
@ -1961,8 +1961,8 @@ static inline void AiCheckBuildRailBridgeHere(AiRailFinder *arf, TileIndex tile,
// Allow bridges directly over bottom tiles // Allow bridges directly over bottom tiles
flag = arf->ti.z == 0; flag = arf->ti.z == 0;
for(;;) { for(;;) {
if (tile_new < -_tileoffs_by_dir[dir2]) return; // Wraping around map, no bridge possible! if (tile_new < -TileOffsByDir(dir2)) return; // Wraping around map, no bridge possible!
tile_new = TILE_MASK(tile_new + _tileoffs_by_dir[dir2]); tile_new = TILE_MASK(tile_new + TileOffsByDir(dir2));
FindLandscapeHeightByTile(&arf->ti, tile_new); FindLandscapeHeightByTile(&arf->ti, tile_new);
if (arf->ti.tileh != 0 || arf->ti.type == MP_CLEAR || arf->ti.type == MP_TREES) { if (arf->ti.tileh != 0 || arf->ti.type == MP_CLEAR || arf->ti.type == MP_TREES) {
if (!flag) return; if (!flag) return;
@ -2008,7 +2008,7 @@ static void AiBuildRailRecursive(AiRailFinder *arf, TileIndex tile, int dir)
{ {
const byte *p; const byte *p;
tile = TILE_MASK(tile + _tileoffs_by_dir[dir]); tile = TILE_MASK(tile + TileOffsByDir(dir));
// Reached destination? // Reached destination?
if (tile == arf->final_tile) { if (tile == arf->final_tile) {
@ -2126,7 +2126,7 @@ static void AiBuildRailConstruct(Player *p)
return; return;
} }
p->ai.cur_tile_a += _tileoffs_by_dir[p->ai.cur_dir_a]; p->ai.cur_tile_a += TileOffsByDir(p->ai.cur_dir_a);
if (arf.best_ptr[0]&0x80) { if (arf.best_ptr[0]&0x80) {
int i; int i;
@ -2183,7 +2183,7 @@ static bool AiRemoveTileAndGoForward(Player *p)
// Clear the tunnel and continue at the other side of it. // Clear the tunnel and continue at the other side of it.
if (DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR) == CMD_ERROR) if (DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR) == CMD_ERROR)
return false; return false;
p->ai.cur_tile_a = TILE_MASK(_build_tunnel_endtile - _tileoffs_by_dir[p->ai.cur_dir_a]); p->ai.cur_tile_a = TILE_MASK(_build_tunnel_endtile - TileOffsByDir(p->ai.cur_dir_a));
return true; return true;
} }
@ -2195,7 +2195,7 @@ static bool AiRemoveTileAndGoForward(Player *p)
return false; return false;
// Find other side of bridge. // Find other side of bridge.
offs = _tileoffs_by_dir[p->ai.cur_dir_a]; offs = TileOffsByDir(p->ai.cur_dir_a);
do { do {
tile = TILE_MASK(tile - offs); tile = TILE_MASK(tile - offs);
} while (_map5[tile] & 0x40); } while (_map5[tile] & 0x40);
@ -2233,7 +2233,7 @@ static bool AiRemoveTileAndGoForward(Player *p)
p->ai.cur_dir_a = ptr[1] ^ 2; p->ai.cur_dir_a = ptr[1] ^ 2;
// And then also switch tile. // And then also switch tile.
p->ai.cur_tile_a = TILE_MASK(p->ai.cur_tile_a - _tileoffs_by_dir[p->ai.cur_dir_a]); p->ai.cur_tile_a = TILE_MASK(p->ai.cur_tile_a - TileOffsByDir(p->ai.cur_dir_a));
return true; return true;
} }
@ -2332,7 +2332,7 @@ static void AiStateBuildRail(Player *p)
p->ai.cur_tile_a = tile; p->ai.cur_tile_a = tile;
p->ai.start_dir_a = dir; p->ai.start_dir_a = dir;
p->ai.cur_dir_a = dir; p->ai.cur_dir_a = dir;
DoCommandByTile(TILE_MASK(tile + _tileoffs_by_dir[dir]), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL); DoCommandByTile(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
assert(TILE_MASK(tile) != 0xFF00); assert(TILE_MASK(tile) != 0xFF00);
@ -2343,7 +2343,7 @@ static void AiStateBuildRail(Player *p)
p->ai.cur_tile_b = tile; p->ai.cur_tile_b = tile;
p->ai.start_dir_b = dir; p->ai.start_dir_b = dir;
p->ai.cur_dir_b = dir; p->ai.cur_dir_b = dir;
DoCommandByTile(TILE_MASK(tile + _tileoffs_by_dir[dir]), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL); DoCommandByTile(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
assert(TILE_MASK(tile) != 0xFF00); assert(TILE_MASK(tile) != 0xFF00);
@ -2771,7 +2771,7 @@ static bool AiEnumFollowRoad(uint tile, AiRoadEnum *a, int track, uint length, b
uint tile2; uint tile2;
if (dist <= a->best_dist) { if (dist <= a->best_dist) {
tile2 = TILE_MASK(tile + _tileoffs_by_dir[_dir_by_track[track]]); tile2 = TILE_MASK(tile + TileOffsByDir(_dir_by_track[track]));
if (IS_TILETYPE(tile2, MP_STREET) && if (IS_TILETYPE(tile2, MP_STREET) &&
(_map5[tile2]&0xF0) == 0) { (_map5[tile2]&0xF0) == 0) {
a->best_dist = dist; a->best_dist = dist;
@ -2799,7 +2799,7 @@ static bool AiCheckRoadFinished(Player *p)
int i; int i;
are.dest = p->ai.cur_tile_b; are.dest = p->ai.cur_tile_b;
tile = TILE_MASK(p->ai.cur_tile_a + _tileoffs_by_dir[dir]); tile = TILE_MASK(p->ai.cur_tile_a + TileOffsByDir(dir));
bits = GetTileTrackStatus(tile, TRANSPORT_ROAD) & _ai_road_table_and[dir]; bits = GetTileTrackStatus(tile, TRANSPORT_ROAD) & _ai_road_table_and[dir];
if (bits == 0) { if (bits == 0) {
@ -2850,8 +2850,8 @@ static inline void AiCheckBuildRoadBridgeHere(AiRoadFinder *arf, TileIndex tile,
// Allow bridges directly over bottom tiles // Allow bridges directly over bottom tiles
flag = arf->ti.z == 0; flag = arf->ti.z == 0;
for(;;) { for(;;) {
if (tile_new < -_tileoffs_by_dir[dir2]) return; // Wraping around map, no bridge possible! if (tile_new < -TileOffsByDir(dir2)) return; // Wraping around map, no bridge possible!
tile_new = TILE_MASK(tile_new + _tileoffs_by_dir[dir2]); tile_new = TILE_MASK(tile_new + TileOffsByDir(dir2));
FindLandscapeHeightByTile(&arf->ti, tile_new); FindLandscapeHeightByTile(&arf->ti, tile_new);
if (arf->ti.tileh != 0 || arf->ti.type == MP_CLEAR || arf->ti.type == MP_TREES) { if (arf->ti.tileh != 0 || arf->ti.type == MP_CLEAR || arf->ti.type == MP_TREES) {
// Allow a bridge if either we have a tile that's water, rail or street, // Allow a bridge if either we have a tile that's water, rail or street,
@ -2899,7 +2899,7 @@ static void AiBuildRoadRecursive(AiRoadFinder *arf, TileIndex tile, int dir)
{ {
const byte *p; const byte *p;
tile = TILE_MASK(tile + _tileoffs_by_dir[dir]); tile = TILE_MASK(tile + TileOffsByDir(dir));
// Reached destination? // Reached destination?
if (tile == arf->final_tile) { if (tile == arf->final_tile) {
@ -3001,14 +3001,14 @@ do_some_terraform:
if (++p->ai.state_counter == 21) { if (++p->ai.state_counter == 21) {
p->ai.state_mode = 1; p->ai.state_mode = 1;
p->ai.cur_tile_a = TILE_MASK(p->ai.cur_tile_a + _tileoffs_by_dir[p->ai.cur_dir_a]); p->ai.cur_tile_a = TILE_MASK(p->ai.cur_tile_a + TileOffsByDir(p->ai.cur_dir_a));
p->ai.cur_dir_a ^= 2; p->ai.cur_dir_a ^= 2;
p->ai.state_counter = 0; p->ai.state_counter = 0;
} }
return; return;
} }
tile = TILE_MASK(p->ai.cur_tile_a + _tileoffs_by_dir[p->ai.cur_dir_a]); tile = TILE_MASK(p->ai.cur_tile_a + TileOffsByDir(p->ai.cur_dir_a));
if (arf.best_ptr[0]&0x80) { if (arf.best_ptr[0]&0x80) {
int i; int i;
@ -3696,7 +3696,7 @@ pos_3:
static const byte _depot_bits[] = {0x19,0x16,0x25,0x2A}; static const byte _depot_bits[] = {0x19,0x16,0x25,0x2A};
m5 &= 3; m5 &= 3;
if (GetRailTrackStatus(tile + _tileoffs_by_dir[m5]) & _depot_bits[m5]) if (GetRailTrackStatus(tile + TileOffsByDir(m5)) & _depot_bits[m5])
return; return;
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
@ -3732,7 +3732,7 @@ pos_3:
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR); DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommandByTile( DoCommandByTile(
TILE_MASK(tile + _tileoffs_by_dir[dir]), TILE_MASK(tile + TileOffsByDir(dir)),
8 >> (dir ^ 2), 8 >> (dir ^ 2),
0, 0,
DC_EXEC, DC_EXEC,

2
ai_build.c
View File

@ -250,7 +250,7 @@ int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag) {
r = DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT); r = DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);
if (r == CMD_ERROR) return r; if (r == CMD_ERROR) return r;
// Try to build the road from the depot // Try to build the road from the depot
r2 = DoCommandByTile(tile + _tileoffs_by_dir[direction], _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD); r2 = DoCommandByTile(tile + TileOffsByDir(direction), _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
// If it fails, ignore it.. // If it fails, ignore it..
if (r2 == CMD_ERROR) return r; if (r2 == CMD_ERROR) return r;
return r + r2; return r + r2;

38
ai_new.c
View File

@ -745,16 +745,16 @@ static void AiNew_State_FindDepot(Player *p) {
for (i=2;i<p->ainew.path_info.route_length-2;i++) { for (i=2;i<p->ainew.path_info.route_length-2;i++) {
tile = p->ainew.path_info.route[i]; tile = p->ainew.path_info.route[i];
for (j=0;j<lengthof(_tileoffs_by_dir);j++) { for (j = 0; j < 4; j++) {
if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_STREET)) { if (IS_TILETYPE(tile + TileOffsByDir(j), MP_STREET)) {
// Its a street, test if it is a depot // Its a street, test if it is a depot
if (_map5[tile + _tileoffs_by_dir[j]] & 0x20) { if (_map5[tile + TileOffsByDir(j)] & 0x20) {
// We found a depot, is it ours? (TELL ME!!!) // We found a depot, is it ours? (TELL ME!!!)
if (_map_owner[tile + _tileoffs_by_dir[j]] == _current_player) { if (_map_owner[tile + TileOffsByDir(j)] == _current_player) {
// Now, is it pointing to the right direction......... // Now, is it pointing to the right direction.........
if ((_map5[tile + _tileoffs_by_dir[j]] & 3) == (j ^ 2)) { if ((_map5[tile + TileOffsByDir(j)] & 3) == (j ^ 2)) {
// Yeah!!! // Yeah!!!
p->ainew.depot_tile = tile + _tileoffs_by_dir[j]; p->ainew.depot_tile = tile + TileOffsByDir(j);
p->ainew.depot_direction = j ^ 2; // Reverse direction p->ainew.depot_direction = j ^ 2; // Reverse direction
p->ainew.state = AI_STATE_VERIFY_ROUTE; p->ainew.state = AI_STATE_VERIFY_ROUTE;
return; return;
@ -781,28 +781,28 @@ static void AiNew_State_FindDepot(Player *p) {
tile = p->ainew.path_info.route[i]; tile = p->ainew.path_info.route[i];
for (j=0;j<lengthof(_tileoffs_by_dir);j++) { for (j = 0; j < 4; j++) {
// It may not be placed on the road/rail itself // It may not be placed on the road/rail itself
// And because it is not build yet, we can't see it on the tile.. // And because it is not build yet, we can't see it on the tile..
// So check the surrounding tiles :) // So check the surrounding tiles :)
if (tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i-1] || if (tile + TileOffsByDir(j) == p->ainew.path_info.route[i-1] ||
tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i+1]) continue; tile + TileOffsByDir(j) == p->ainew.path_info.route[i+1]) continue;
// Not around a bridge? // Not around a bridge?
if (p->ainew.path_info.route_extra[i] != 0) continue; if (p->ainew.path_info.route_extra[i] != 0) continue;
if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) continue; if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) continue;
// Is the terrain clear? // Is the terrain clear?
if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_CLEAR) || if (IS_TILETYPE(tile + TileOffsByDir(j), MP_CLEAR) ||
IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_TREES)) { IS_TILETYPE(tile + TileOffsByDir(j), MP_TREES)) {
TileInfo ti; TileInfo ti;
FindLandscapeHeightByTile(&ti, tile); FindLandscapeHeightByTile(&ti, tile);
// If the current tile is on a slope (tileh != 0) then we do not allow this // If the current tile is on a slope (tileh != 0) then we do not allow this
if (ti.tileh != 0) continue; if (ti.tileh != 0) continue;
// Check if everything went okay.. // Check if everything went okay..
r = AiNew_Build_Depot(p, tile + _tileoffs_by_dir[j], j ^ 2, 0); r = AiNew_Build_Depot(p, tile + TileOffsByDir(j), j ^ 2, 0);
if (r == CMD_ERROR) continue; if (r == CMD_ERROR) continue;
// Found a spot! // Found a spot!
p->ainew.new_cost += r; p->ainew.new_cost += r;
p->ainew.depot_tile = tile + _tileoffs_by_dir[j]; p->ainew.depot_tile = tile + TileOffsByDir(j);
p->ainew.depot_direction = j ^ 2; // Reverse direction p->ainew.depot_direction = j ^ 2; // Reverse direction
p->ainew.state = AI_STATE_VERIFY_ROUTE; p->ainew.state = AI_STATE_VERIFY_ROUTE;
return; return;
@ -984,14 +984,14 @@ static void AiNew_State_BuildPath(Player *p) {
int i, r; int i, r;
for (i=0;i<2;i++) { for (i=0;i<2;i++) {
if (i == 0) { if (i == 0) {
tile = p->ainew.from_tile + _tileoffs_by_dir[p->ainew.from_direction]; tile = p->ainew.from_tile + TileOffsByDir(p->ainew.from_direction);
dir1 = p->ainew.from_direction - 1; dir1 = p->ainew.from_direction - 1;
if (dir1 < 0) dir1 = 3; if (dir1 < 0) dir1 = 3;
dir2 = p->ainew.from_direction + 1; dir2 = p->ainew.from_direction + 1;
if (dir2 > 3) dir2 = 0; if (dir2 > 3) dir2 = 0;
dir3 = p->ainew.from_direction; dir3 = p->ainew.from_direction;
} else { } else {
tile = p->ainew.to_tile + _tileoffs_by_dir[p->ainew.to_direction]; tile = p->ainew.to_tile + TileOffsByDir(p->ainew.to_direction);
dir1 = p->ainew.to_direction - 1; dir1 = p->ainew.to_direction - 1;
if (dir1 < 0) dir1 = 3; if (dir1 < 0) dir1 = 3;
dir2 = p->ainew.to_direction + 1; dir2 = p->ainew.to_direction + 1;
@ -1001,7 +1001,7 @@ static void AiNew_State_BuildPath(Player *p) {
r = DoCommandByTile(tile, _roadbits_by_dir[dir1], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile, _roadbits_by_dir[dir1], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
dir1 = _tileoffs_by_dir[dir1]; dir1 = TileOffsByDir(dir1);
if (IS_TILETYPE(tile+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1, MP_TREES)) { if (IS_TILETYPE(tile+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1, MP_TREES)) {
r = DoCommandByTile(tile+dir1, AiNew_GetRoadDirection(tile, tile+dir1, tile+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile+dir1, AiNew_GetRoadDirection(tile, tile+dir1, tile+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
@ -1013,7 +1013,7 @@ static void AiNew_State_BuildPath(Player *p) {
r = DoCommandByTile(tile, _roadbits_by_dir[dir2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile, _roadbits_by_dir[dir2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
dir2 = _tileoffs_by_dir[dir2]; dir2 = TileOffsByDir(dir2);
if (IS_TILETYPE(tile+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2, MP_TREES)) { if (IS_TILETYPE(tile+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2, MP_TREES)) {
r = DoCommandByTile(tile+dir2, AiNew_GetRoadDirection(tile, tile+dir2, tile+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile+dir2, AiNew_GetRoadDirection(tile, tile+dir2, tile+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
@ -1025,7 +1025,7 @@ static void AiNew_State_BuildPath(Player *p) {
r = DoCommandByTile(tile, _roadbits_by_dir[dir3^2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile, _roadbits_by_dir[dir3^2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
dir3 = _tileoffs_by_dir[dir3]; dir3 = TileOffsByDir(dir3);
if (IS_TILETYPE(tile+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3, MP_TREES)) { if (IS_TILETYPE(tile+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3, MP_TREES)) {
r = DoCommandByTile(tile+dir3, AiNew_GetRoadDirection(tile, tile+dir3, tile+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD); r = DoCommandByTile(tile+dir3, AiNew_GetRoadDirection(tile, tile+dir3, tile+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
if (r != CMD_ERROR) { if (r != CMD_ERROR) {
@ -1061,7 +1061,7 @@ static void AiNew_State_BuildDepot(Player *p) {
} }
// There is a bus on the tile we want to build road on... idle till he is gone! (BAD PERSON! :p) // There is a bus on the tile we want to build road on... idle till he is gone! (BAD PERSON! :p)
if (!EnsureNoVehicle(p->ainew.depot_tile + _tileoffs_by_dir[p->ainew.depot_direction])) if (!EnsureNoVehicle(p->ainew.depot_tile + TileOffsByDir(p->ainew.depot_direction)))
return; return;
res = AiNew_Build_Depot(p, p->ainew.depot_tile, p->ainew.depot_direction, DC_EXEC); res = AiNew_Build_Depot(p, p->ainew.depot_tile, p->ainew.depot_direction, DC_EXEC);

2
clear_cmd.c
View File

@ -751,7 +751,7 @@ void GenerateClearTile()
_map5[tile] = (byte)((_map5[tile] & ~(3<<2)) | (2<<2)); _map5[tile] = (byte)((_map5[tile] & ~(3<<2)) | (2<<2));
do { do {
if (--j == 0) goto get_out; if (--j == 0) goto get_out;
tile_new = tile + _tileoffs_by_dir[Random() & 3]; tile_new = tile + TileOffsByDir(Random() & 3);
} while (!IS_TILETYPE(tile_new, MP_CLEAR)); } while (!IS_TILETYPE(tile_new, MP_CLEAR));
tile = tile_new; tile = tile_new;
} }

4
disaster_cmd.c
View File

@ -646,7 +646,7 @@ static void DisasterTick_5_and_6(Vehicle *v)
if (!(v->tick_counter&1)) if (!(v->tick_counter&1))
return; return;
tile = v->tile + _tileoffs_by_dir[v->direction >> 1]; tile = v->tile + TileOffsByDir(v->direction >> 1);
if (IsValidTile(tile) && if (IsValidTile(tile) &&
(r=GetTileTrackStatus(tile,TRANSPORT_WATER),(byte)(r+(r >> 8)) == 0x3F) && (r=GetTileTrackStatus(tile,TRANSPORT_WATER),(byte)(r+(r >> 8)) == 0x3F) &&
!CHANCE16(1,90)) { !CHANCE16(1,90)) {
@ -909,7 +909,7 @@ static void Disaster7_Init()
{ {
uint tile = i->xy; uint tile = i->xy;
int step = _tileoffs_by_dir[Random() & 3]; int step = TileOffsByDir(Random() & 3);
int count = 30; int count = 30;
do { do {
DisasterClearSquare(tile); DisasterClearSquare(tile);

8
macros.h
View File

@ -148,13 +148,7 @@ static inline int FindFirstBit2x64(int value)
} }
#if TILE_X_BITS + TILE_Y_BITS <= 16 typedef uint16 TileIndex;
typedef uint16 TileIndex;
typedef int16 TileIndexDiff;
#else
typedef uint32 TileIndex;
typedef int32 TileIndexDiff;
#endif
/* [min,max), strictly less than */ /* [min,max), strictly less than */
#define IS_BYTE_INSIDE(a,min,max) ((byte)((a)-(min)) < (byte)((max)-(min))) #define IS_BYTE_INSIDE(a,min,max) ((byte)((a)-(min)) < (byte)((max)-(min)))

7
map.c
View File

@ -14,3 +14,10 @@ byte _map3_hi [MAP_SIZE];
byte _map_owner [MAP_SIZE]; byte _map_owner [MAP_SIZE];
uint16 _map2 [MAP_SIZE]; uint16 _map2 [MAP_SIZE];
byte _map_extra_bits [MAP_SIZE / 4]; byte _map_extra_bits [MAP_SIZE / 4];
const TileIndexDiff _tileoffs_by_dir[4] = {
TILE_XY(-1, 0),
TILE_XY(0, 1),
TILE_XY(1, 0),
TILE_XY(0, -1),
};

11
map.h
View File

@ -24,4 +24,15 @@ static inline uint MapMaxY(void) { return MapSizeY() - 1; }
/* The number of tiles in the map */ /* The number of tiles in the map */
static inline uint MapSize(void) { return MapSizeX() * MapSizeY(); } static inline uint MapSize(void) { return MapSizeX() * MapSizeY(); }
typedef int16 TileIndexDiff;
static inline TileIndexDiff TileOffsByDir(uint dir)
{
extern const TileIndexDiff _tileoffs_by_dir[4];
assert(dir < lengthof(_tileoffs_by_dir));
return _tileoffs_by_dir[dir];
}
#endif #endif

7
misc.c
View File

@ -361,13 +361,6 @@ StringID RealAllocateName(const byte *name, byte skip, bool check_double)
return free_item | 0x7800 | (skip << 8); return free_item | 0x7800 | (skip << 8);
} }
const TileIndexDiff _tileoffs_by_dir[4] = {
TILE_XY(-1, 0),
TILE_XY(0, 1),
TILE_XY(1, 0),
TILE_XY(0, -1),
};
#define M(a,b) ((a<<5)|b) #define M(a,b) ((a<<5)|b)
static const uint16 _month_date_from_year_day[] = { static const uint16 _month_date_from_year_day[] = {

6
pathfind.c
View File

@ -140,7 +140,7 @@ static void TPFMode2(TrackPathFinder *tpf, uint tile, int direction)
// This addition will sometimes overflow by a single tile. // This addition will sometimes overflow by a single tile.
// The use of TILE_MASK here makes sure that we still point at a valid // The use of TILE_MASK here makes sure that we still point at a valid
// tile, and then this tile will be in the sentinel row/col, so GetTileTrackStatus will fail. // tile, and then this tile will be in the sentinel row/col, so GetTileTrackStatus will fail.
tile = TILE_MASK(tile + _tileoffs_by_dir[direction]); tile = TILE_MASK(tile + TileOffsByDir(direction));
/* Check in case of rail if the owner is the same */ /* Check in case of rail if the owner is the same */
if (tpf->tracktype == TRANSPORT_RAIL) { if (tpf->tracktype == TRANSPORT_RAIL) {
@ -283,7 +283,7 @@ static void TPFMode1(TrackPathFinder *tpf, uint tile, int direction)
return; return;
tile = SkipToEndOfTunnel(tpf, tile, direction); tile = SkipToEndOfTunnel(tpf, tile, direction);
} }
tile += _tileoffs_by_dir[direction]; tile += TileOffsByDir(direction);
/* Check in case of rail if the owner is the same */ /* Check in case of rail if the owner is the same */
if (tpf->tracktype == TRANSPORT_RAIL) { if (tpf->tracktype == TRANSPORT_RAIL) {
@ -638,7 +638,7 @@ restart:
tile_org = tile; tile_org = tile;
for(;;) { for(;;) {
tile += _tileoffs_by_dir[direction]; tile += TileOffsByDir(direction);
// too long search length? bail out. // too long search length? bail out.
if (++si.cur_length >= tpf->maxlength) if (++si.cur_length >= tpf->maxlength)

2
rail_gui.c
View File

@ -98,7 +98,7 @@ void CcRailDepot(bool success, uint tile, uint32 p1, uint32 p2)
SndPlayTileFx(SND_20_SPLAT_2, tile); SndPlayTileFx(SND_20_SPLAT_2, tile);
ResetObjectToPlace(); ResetObjectToPlace();
tile += _tileoffs_by_dir[dir]; tile += TileOffsByDir(dir);
if (IS_TILETYPE(tile, MP_RAILWAY)) { if (IS_TILETYPE(tile, MP_RAILWAY)) {
PlaceExtraDepotRail(tile, _place_depot_extra[dir]); PlaceExtraDepotRail(tile, _place_depot_extra[dir]);

2
road_gui.c
View File

@ -65,7 +65,7 @@ static void PlaceRoad_Tunnel(uint tile)
static void BuildRoadOutsideStation(uint tile, int direction) static void BuildRoadOutsideStation(uint tile, int direction)
{ {
static const byte _roadbits_by_dir[4] = {2,1,8,4}; static const byte _roadbits_by_dir[4] = {2,1,8,4};
tile += _tileoffs_by_dir[direction]; tile += TileOffsByDir(direction);
// if there is a roadpiece just outside of the station entrance, build a connecting route // if there is a roadpiece just outside of the station entrance, build a connecting route
if (IS_TILETYPE(tile, MP_STREET) && !(_map5[tile]&0x20)) { if (IS_TILETYPE(tile, MP_STREET) && !(_map5[tile]&0x20)) {
DoCommandP(tile, _roadbits_by_dir[direction], 0, NULL, CMD_BUILD_ROAD); DoCommandP(tile, _roadbits_by_dir[direction], 0, NULL, CMD_BUILD_ROAD);

6
roadveh_cmd.c
View File

@ -866,7 +866,7 @@ static void RoadVehCheckOvertake(Vehicle *v, Vehicle *u)
if (FindRoadVehToOvertake(&od)) if (FindRoadVehToOvertake(&od))
return; return;
od.tile = v->tile + _tileoffs_by_dir[v->direction>>1]; od.tile = v->tile + TileOffsByDir(v->direction >> 1);
if (FindRoadVehToOvertake(&od)) if (FindRoadVehToOvertake(&od))
return; return;
@ -1009,7 +1009,7 @@ static int RoadFindPathToDest(Vehicle *v, uint tile, int direction)
if (IS_BYTE_INSIDE(m5, 0x43, 0x4B)) { if (IS_BYTE_INSIDE(m5, 0x43, 0x4B)) {
m5 -= 0x43; m5 -= 0x43;
do_it:; do_it:;
desttile += _tileoffs_by_dir[m5&3]; desttile += TileOffsByDir(m5 & 3);
if (desttile == tile && bitmask&_road_pf_table_3[m5&3]) { if (desttile == tile && bitmask&_road_pf_table_3[m5&3]) {
return_track(FindFirstBit2x64(bitmask&_road_pf_table_3[m5&3])); return_track(FindFirstBit2x64(bitmask&_road_pf_table_3[m5&3]));
} }
@ -1178,7 +1178,7 @@ static void RoadVehEventHandler(Vehicle *v)
// switch to another tile // switch to another tile
if (rd.x & 0x80) { if (rd.x & 0x80) {
uint tile = v->tile + _tileoffs_by_dir[rd.x&3]; uint tile = v->tile + TileOffsByDir(rd.x & 3);
int dir = RoadFindPathToDest(v, tile, rd.x&3); int dir = RoadFindPathToDest(v, tile, rd.x&3);
int tmp; int tmp;
uint32 r; uint32 r;

2
ship_cmd.c
View File

@ -546,7 +546,7 @@ static int ChooseShipTrack(Vehicle *v, uint tile, int dir, uint tracks)
uint tile2; uint tile2;
assert(dir>=0 && dir<=3); assert(dir>=0 && dir<=3);
tile2 = TILE_ADD(tile, -_tileoffs_by_dir[dir]); tile2 = TILE_ADD(tile, -TileOffsByDir(dir));
dir ^= 2; dir ^= 2;
tot_dist = (uint)-1; tot_dist = (uint)-1;
b = GetTileShipTrackStatus(tile2) & _ship_sometracks[dir] & v->u.ship.state; b = GetTileShipTrackStatus(tile2) & _ship_sometracks[dir] & v->u.ship.state;

10
station_cmd.c
View File

@ -1812,7 +1812,7 @@ int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (cost == CMD_ERROR) if (cost == CMD_ERROR)
return CMD_ERROR; return CMD_ERROR;
tile_cur = (tile=ti.tile) + _tileoffs_by_dir[direction]; tile_cur = (tile=ti.tile) + TileOffsByDir(direction);
if (!EnsureNoVehicle(tile_cur)) if (!EnsureNoVehicle(tile_cur))
return CMD_ERROR; return CMD_ERROR;
@ -1825,7 +1825,7 @@ int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (cost == CMD_ERROR) if (cost == CMD_ERROR)
return CMD_ERROR; return CMD_ERROR;
tile_cur = tile_cur + _tileoffs_by_dir[direction]; tile_cur = tile_cur + TileOffsByDir(direction);
FindLandscapeHeightByTile(&ti, tile_cur); FindLandscapeHeightByTile(&ti, tile_cur);
if (ti.tileh != 0 || ti.type != MP_WATER) if (ti.tileh != 0 || ti.type != MP_WATER)
return_cmd_error(STR_304B_SITE_UNSUITABLE); return_cmd_error(STR_304B_SITE_UNSUITABLE);
@ -1887,7 +1887,7 @@ int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
st->index, st->index,
direction + 0x4C); direction + 0x4C);
ModifyTile(tile + _tileoffs_by_dir[direction], ModifyTile(tile + TileOffsByDir(direction),
MP_SETTYPE(MP_STATION) | MP_MAPOWNER_CURRENT | MP_SETTYPE(MP_STATION) | MP_MAPOWNER_CURRENT |
MP_MAP2 | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAP2 | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR |
MP_MAP5, MP_MAP5,
@ -1909,7 +1909,7 @@ static int32 RemoveDock(Station *st, uint32 flags)
return CMD_ERROR; return CMD_ERROR;
tile1 = st->dock_tile; tile1 = st->dock_tile;
tile2 = tile1 + _tileoffs_by_dir[_map5[tile1] - 0x4C]; tile2 = tile1 + TileOffsByDir(_map5[tile1] - 0x4C);
if (!EnsureNoVehicle(tile1)) if (!EnsureNoVehicle(tile1))
return CMD_ERROR; return CMD_ERROR;
@ -2174,7 +2174,7 @@ static uint32 VehicleEnter_Station(Vehicle *v, uint tile, int x, int y)
if (v->type == VEH_Train) { if (v->type == VEH_Train) {
if (IS_BYTE_INSIDE(_map5[tile], 0, 8) && v->subtype == 0 && if (IS_BYTE_INSIDE(_map5[tile], 0, 8) && v->subtype == 0 &&
!IsTrainStationTile(tile + _tileoffs_by_dir[v->direction >> 1])) { !IsTrainStationTile(tile + TileOffsByDir(v->direction >> 1))) {
station_id = _map2[tile]; station_id = _map2[tile];
if ((!(v->current_order.flags & OF_NON_STOP) && !_patches.new_nonstop) || if ((!(v->current_order.flags & OF_NON_STOP) && !_patches.new_nonstop) ||

2
town_cmd.c
View File

@ -655,7 +655,7 @@ build_road_and_exit:
do { do {
if (++j == 0) if (++j == 0)
goto build_road_and_exit; goto build_road_and_exit;
tmptile = TILE_MASK(tmptile + _tileoffs_by_dir[i]); tmptile = TILE_MASK(tmptile + TileOffsByDir(i));
} while (IS_WATER_TILE(tmptile)); } while (IS_WATER_TILE(tmptile));
// no water tiles in between? // no water tiles in between?

8
train_cmd.c
View File

@ -984,7 +984,7 @@ static void ReverseTrainDirection(Vehicle *v)
t = (t - 1) & 3; t = (t - 1) & 3;
} }
/* Calculate next tile */ /* Calculate next tile */
tile += _tileoffs_by_dir[t]; tile += TileOffsByDir(t);
/* Test if we have a rail/road-crossing */ /* Test if we have a rail/road-crossing */
if (IS_TILETYPE(tile, MP_STREET) && (_map5[tile] & 0xF0)==0x10) { if (IS_TILETYPE(tile, MP_STREET) && (_map5[tile] & 0xF0)==0x10) {
/* Check if there is a train on the tile itself */ /* Check if there is a train on the tile itself */
@ -1471,7 +1471,7 @@ static byte ChooseTrainTrack(Vehicle *v, uint tile, int direction, byte trackbit
fd.best_bird_dist = (uint)-1; fd.best_bird_dist = (uint)-1;
fd.best_track_dist = (uint)-1; fd.best_track_dist = (uint)-1;
fd.best_track = 0xFF; fd.best_track = 0xFF;
NewTrainPathfind(tile - _tileoffs_by_dir[direction], direction, (TPFEnumProc*)TrainTrackFollower, &fd, NULL); NewTrainPathfind(tile - TileOffsByDir(direction), direction, (TPFEnumProc*)TrainTrackFollower, &fd, NULL);
// printf("Train %d %s\n", v->unitnumber, fd.best_track_dist == -1 ? "NOTFOUND" : "FOUND"); // printf("Train %d %s\n", v->unitnumber, fd.best_track_dist == -1 ? "NOTFOUND" : "FOUND");
@ -2271,7 +2271,7 @@ red_light: {
v->subspeed = 0; v->subspeed = 0;
v->progress = 255-10; v->progress = 255-10;
if (++v->load_unload_time_rem < _patches.wait_twoway_signal * 73) { if (++v->load_unload_time_rem < _patches.wait_twoway_signal * 73) {
uint o_tile = gp.new_tile + _tileoffs_by_dir[dir>>1]; uint o_tile = gp.new_tile + TileOffsByDir(dir >> 1);
/* check if a train is waiting on the other side */ /* check if a train is waiting on the other side */
if (VehicleFromPos(o_tile, (void*)( (o_tile<<8) | (dir^4)), (VehicleFromPosProc*)CheckVehicleAtSignal) == NULL) if (VehicleFromPos(o_tile, (void*)( (o_tile<<8) | (dir^4)), (VehicleFromPosProc*)CheckVehicleAtSignal) == NULL)
return; return;
@ -2452,7 +2452,7 @@ static bool TrainCheckIfLineEnds(Vehicle *v)
t = (t - 1) & 3; t = (t - 1) & 3;
} }
/* Calculate next tile */ /* Calculate next tile */
tile += _tileoffs_by_dir[t]; tile += TileOffsByDir(t);
// determine the track status on the next tile. // determine the track status on the next tile.
ts = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _reachable_tracks[t]; ts = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _reachable_tracks[t];

5
tunnelbridge_cmd.c
View File

@ -397,7 +397,7 @@ static bool DoCheckTunnelInWay(uint tile, uint z, uint dir)
TileInfo ti; TileInfo ti;
int delta; int delta;
delta = _tileoffs_by_dir[dir]; delta = TileOffsByDir(dir);
do { do {
tile -= delta; tile -= delta;
@ -588,7 +588,8 @@ uint CheckTunnelBusy(uint tile, int *length)
{ {
int z = GetTileZ(tile); int z = GetTileZ(tile);
byte m5 = _map5[tile]; byte m5 = _map5[tile];
int delta = _tileoffs_by_dir[m5 & 3], len = 0; int delta = TileOffsByDir(m5 & 3);
int len = 0;
uint starttile = tile; uint starttile = tile;
Vehicle *v; Vehicle *v;

2
variables.h
View File

@ -416,8 +416,6 @@ extern const TileTypeProcs * const _tile_type_procs[16];
extern const byte _airport_size_x[5]; extern const byte _airport_size_x[5];
extern const byte _airport_size_y[5]; extern const byte _airport_size_y[5];
extern const TileIndexDiff _tileoffs_by_dir[4];
/* misc */ /* misc */
VARDEF byte str_buffr[512]; VARDEF byte str_buffr[512];
VARDEF char _screenshot_name[128]; VARDEF char _screenshot_name[128];

4
water_cmd.c
View File

@ -121,7 +121,7 @@ static int32 DoBuildShiplift(uint tile, int dir, uint32 flags)
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR); ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret == CMD_ERROR) return CMD_ERROR; if (ret == CMD_ERROR) return CMD_ERROR;
delta = _tileoffs_by_dir[dir]; delta = TileOffsByDir(dir);
// lower tile // lower tile
ret = DoCommandByTile(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR); ret = DoCommandByTile(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret == CMD_ERROR) return CMD_ERROR; if (ret == CMD_ERROR) return CMD_ERROR;
@ -143,7 +143,7 @@ static int32 DoBuildShiplift(uint tile, int dir, uint32 flags)
static int32 RemoveShiplift(uint tile, uint32 flags) static int32 RemoveShiplift(uint tile, uint32 flags)
{ {
int delta = _tileoffs_by_dir[_map5[tile] & 3]; int delta = TileOffsByDir(_map5[tile] & 3);
// make sure no vehicle is on the tile. // make sure no vehicle is on the tile.
if (!EnsureNoVehicle(tile) || !EnsureNoVehicle(tile + delta) || !EnsureNoVehicle(tile - delta)) if (!EnsureNoVehicle(tile) || !EnsureNoVehicle(tile + delta) || !EnsureNoVehicle(tile - delta))