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

(svn r4258) -Codechange: Add and make use of map accessors dealing with road ground types (including roadworks).

release/0.5
celestar 2006-04-03 13:35:19 +00:00
parent 13812b08ec
commit 961b44e697
2 changed files with 114 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
road_cmd.c
View File

@ -701,22 +701,14 @@ const byte _road_sloped_sprites[14] = {
* Draw ground sprite and road pieces * Draw ground sprite and road pieces
* @param ti TileInfo * @param ti TileInfo
* @param road RoadBits to draw * @param road RoadBits to draw
* @param ground_type Ground type
* @param snow Draw snow
* @param flat Draw foundation
*/ */
static void DrawRoadBits(TileInfo* ti, RoadBits road, byte ground_type, bool snow, bool flat) static void DrawRoadBits(TileInfo* ti, RoadBits road)
{ {
const DrawRoadTileStruct *drts; const DrawRoadTileStruct *drts;
PalSpriteID image = 0; PalSpriteID image = 0;
if (ti->tileh != 0) { if (ti->tileh != 0) {
int foundation; int foundation = GetRoadFoundation(ti->tileh, road);
if (flat) {
foundation = ti->tileh;
} else {
foundation = GetRoadFoundation(ti->tileh, road);
}
if (foundation != 0) DrawFoundation(ti, foundation); if (foundation != 0) DrawFoundation(ti, foundation);
@ -727,11 +719,11 @@ static void DrawRoadBits(TileInfo* ti, RoadBits road, byte ground_type, bool sno
if (image == 0) image = _road_tile_sprites_1[road]; if (image == 0) image = _road_tile_sprites_1[road];
if (ground_type == 0) image |= PALETTE_TO_BARE_LAND; if (GetGroundType(ti->tile) == RGT_BARREN) image |= PALETTE_TO_BARE_LAND;
if (snow) { if (IsOnSnow(ti->tile)) {
image += 19; image += 19;
} else if (ground_type > 1 && ground_type != 6) { } else if (HasPavement(ti->tile)) {
// Pavement tiles. // Pavement tiles.
image -= 19; image -= 19;
} }
@ -741,14 +733,14 @@ static void DrawRoadBits(TileInfo* ti, RoadBits road, byte ground_type, bool sno
// Return if full detail is disabled, or we are zoomed fully out. // Return if full detail is disabled, or we are zoomed fully out.
if (!(_display_opt & DO_FULL_DETAIL) || _cur_dpi->zoom == 2) return; if (!(_display_opt & DO_FULL_DETAIL) || _cur_dpi->zoom == 2) return;
if (ground_type >= 6) { if (HasRoadWorks(ti->tile)) {
// Road works // Road works
DrawGroundSprite(road & ROAD_X ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y); DrawGroundSprite(road & ROAD_X ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y);
return; return;
} }
// Draw extra details. // Draw extra details.
for (drts = _road_display_table[ground_type][road]; drts->image != 0; drts++) { for (drts = _road_display_table[GetGroundType(ti->tile)][road]; drts->image != 0; drts++) {
int x = ti->x | drts->subcoord_x; int x = ti->x | drts->subcoord_x;
int y = ti->y | drts->subcoord_y; int y = ti->y | drts->subcoord_y;
byte z = ti->z; byte z = ti->z;
@ -760,11 +752,10 @@ static void DrawRoadBits(TileInfo* ti, RoadBits road, byte ground_type, bool sno
static void DrawTile_Road(TileInfo *ti) static void DrawTile_Road(TileInfo *ti)
{ {
PalSpriteID image; PalSpriteID image;
uint16 m2;
switch (GetRoadType(ti->tile)) { switch (GetRoadType(ti->tile)) {
case ROAD_NORMAL: case ROAD_NORMAL:
DrawRoadBits(ti, GetRoadBits(ti->tile), GB(_m[ti->tile].m4, 4, 3), HASBIT(_m[ti->tile].m4, 7), false); DrawRoadBits(ti, GetRoadBits(ti->tile));
break; break;
case ROAD_CROSSING: { case ROAD_CROSSING: {
@ -776,12 +767,11 @@ static void DrawTile_Road(TileInfo *ti)
if (IsCrossingBarred(ti->tile)) image += 2; if (IsCrossingBarred(ti->tile)) image += 2;
if ( _m[ti->tile].m4 & 0x80) { if (IsOnSnow(ti->tile)) {
image += 8; image += 8;
} else { } else {
m2 = GB(_m[ti->tile].m4, 4, 3); if (GetGroundType(ti->tile) == RGT_BARREN) image |= PALETTE_TO_BARE_LAND;
if (m2 == 0) image |= PALETTE_TO_BARE_LAND; if (HasPavement(ti->tile)) image += 4;
if (m2 > 1) image += 4;
} }
DrawGroundSprite(image); DrawGroundSprite(image);
@ -887,20 +877,20 @@ static void AnimateTile_Road(TileIndex tile)
if (IsLevelCrossing(tile)) MarkTileDirtyByTile(tile); if (IsLevelCrossing(tile)) MarkTileDirtyByTile(tile);
} }
static const byte _town_road_types[5][2] = { static const RoadGroundType _town_road_types[5][2] = {
{1,1}, {RGT_GRASS,RGT_GRASS},
{2,2}, {RGT_PAVED,RGT_PAVED},
{2,2}, {RGT_PAVED,RGT_PAVED},
{5,5}, {RGT_ALLEY,RGT_ALLEY},
{3,2}, {RGT_LIGHT,RGT_PAVED},
}; };
static const byte _town_road_types_2[5][2] = { static const RoadGroundType _town_road_types_2[5][2] = {
{1,1}, {RGT_GRASS,RGT_GRASS},
{2,2}, {RGT_PAVED,RGT_PAVED},
{3,2}, {RGT_LIGHT,RGT_PAVED},
{3,2}, {RGT_LIGHT,RGT_PAVED},
{3,2}, {RGT_LIGHT,RGT_PAVED},
}; };
@ -911,15 +901,15 @@ static void TileLoop_Road(TileIndex tile)
switch (_opt.landscape) { switch (_opt.landscape) {
case LT_HILLY: case LT_HILLY:
if ((_m[tile].m4 & 0x80) != (GetTileZ(tile) > _opt.snow_line ? 0x80 : 0x00)) { if (IsOnSnow(tile) != (GetTileZ(tile) > _opt.snow_line)) {
_m[tile].m4 ^= 0x80; ToggleSnow(tile);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
} }
break; break;
case LT_DESERT: case LT_DESERT:
if (GetTropicZone(tile) == TROPICZONE_DESERT && !(_m[tile].m4 & 0x80)) { if (GetTropicZone(tile) == TROPICZONE_DESERT && !IsOnDesert(tile)) {
_m[tile].m4 |= 0x80; ToggleDesert(tile);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
} }
break; break;
@ -927,7 +917,7 @@ static void TileLoop_Road(TileIndex tile)
if (GetRoadType(tile) == ROAD_DEPOT) return; if (GetRoadType(tile) == ROAD_DEPOT) return;
if (GB(_m[tile].m4, 4, 3) < 6) { if (!HasRoadWorks(tile)) {
t = ClosestTownFromTile(tile, (uint)-1); t = ClosestTownFromTile(tile, (uint)-1);
grp = 0; grp = 0;
@ -937,9 +927,9 @@ static void TileLoop_Road(TileIndex tile)
// Show an animation to indicate road work // Show an animation to indicate road work
if (t->road_build_months != 0 && if (t->road_build_months != 0 &&
!(DistanceManhattan(t->xy, tile) >= 8 && grp == 0) && !(DistanceManhattan(t->xy, tile) >= 8 && grp == 0) &&
(_m[tile].m5 == ROAD_Y || _m[tile].m5 == ROAD_X)) { GetRoadType(tile) == ROAD_NORMAL && (GetRoadBits(tile) == ROAD_X || GetRoadBits(tile) == ROAD_Y)) {
if (GetTileSlope(tile, NULL) == 0 && EnsureNoVehicle(tile) && CHANCE16(1, 20)) { if (GetTileSlope(tile, NULL) == 0 && EnsureNoVehicle(tile) && CHANCE16(1, 20)) {
SB(_m[tile].m4, 4, 3, (GB(_m[tile].m4, 4, 3) <= 1 ? 6 : 7)); StartRoadWorks(tile);
SndPlayTileFx(SND_21_JACKHAMMER, tile); SndPlayTileFx(SND_21_JACKHAMMER, tile);
CreateEffectVehicleAbove( CreateEffectVehicleAbove(
@ -954,35 +944,28 @@ static void TileLoop_Road(TileIndex tile)
} }
{ {
const byte *p = (_opt.landscape == LT_CANDY) ? _town_road_types_2[grp] : _town_road_types[grp]; /* Adjust road ground type depending on 'grp' (grp is the distance to the center) */
byte b = GB(_m[tile].m4, 4, 3); const RoadGroundType *target_rgt = (_opt.landscape == LT_CANDY) ? _town_road_types_2[grp] : _town_road_types[grp];
RoadGroundType rgt = GetGroundType(tile);
if (b == p[0]) return; /* We have our desired type, do nothing */
if (rgt == target_rgt[0]) return;
if (b == p[1]) { /* We have the pre-type of the desired type, switch to the desired type */
b = p[0]; if (rgt == target_rgt[1]) {
} else if (b == 0) { rgt = target_rgt[0];
b = p[1]; /* We have barren land, install the pre-type */
} else if (rgt == RGT_BARREN) {
rgt = target_rgt[1];
/* We're totally off limits, remove any installation and make barren land */
} else { } else {
b = 0; rgt = RGT_BARREN;
} }
SB(_m[tile].m4, 4, 3, b); SetGroundType(tile, rgt);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
} }
} else { } else if (IncreaseRoadWorksCounter(tile)) {
// Handle road work TerminateRoadWorks(tile);
//XXX undocumented
byte b = _m[tile].m4;
//roadworks take place only
//keep roadworks running for 16 loops
//lower 4 bits of map3_hi store the counter now
if ((b & 0xF) != 0xF) {
_m[tile].m4 = b + 1;
return;
}
//roadworks finished
_m[tile].m4 = (GB(b, 4, 3) == 6 ? 1 : 2) << 4;
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
} }
} }
@ -1008,8 +991,7 @@ static uint32 GetTileTrackStatus_Road(TileIndex tile, TransportType mode)
case TRANSPORT_ROAD: case TRANSPORT_ROAD:
switch (GetRoadType(tile)) { switch (GetRoadType(tile)) {
case ROAD_NORMAL: case ROAD_NORMAL:
return GB(_m[tile].m4, 4, 3) >= 6 ? return HasRoadWorks(tile) ? 0 : _road_trackbits[GetRoadBits(tile)] * 0x101;
0 : _road_trackbits[GetRoadBits(tile)] * 0x101;
case ROAD_CROSSING: { case ROAD_CROSSING: {
uint32 r = (GetCrossingRoadAxis(tile) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y) * 0x101; uint32 r = (GetCrossingRoadAxis(tile) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y) * 0x101;
@ -1046,7 +1028,7 @@ static void GetTileDesc_Road(TileIndex tile, TileDesc *td)
switch (GetRoadType(tile)) { switch (GetRoadType(tile)) {
case ROAD_CROSSING: td->str = STR_1818_ROAD_RAIL_LEVEL_CROSSING; break; case ROAD_CROSSING: td->str = STR_1818_ROAD_RAIL_LEVEL_CROSSING; break;
case ROAD_DEPOT: td->str = STR_1817_ROAD_VEHICLE_DEPOT; break; case ROAD_DEPOT: td->str = STR_1817_ROAD_VEHICLE_DEPOT; break;
default: td->str = _road_tile_strings[GB(_m[tile].m4, 4, 3)]; break; default: td->str = _road_tile_strings[GetGroundType(tile)]; break;
} }
} }

66
road_map.h
View File

@ -102,6 +102,72 @@ static inline bool IsCrossingBarred(TileIndex t)
return HASBIT(_m[t].m5, 2); return HASBIT(_m[t].m5, 2);
} }
#define IsOnDesert IsOnSnow
static inline bool IsOnSnow(TileIndex t)
{
return HASBIT(_m[t].m4, 7);
}
#define ToggleDesert ToggleSnow
static inline void ToggleSnow(TileIndex t)
{
TOGGLEBIT(_m[t].m4, 7);
}
typedef enum RoadGroundType {
RGT_BARREN,
RGT_GRASS,
RGT_PAVED,
RGT_LIGHT,
RGT_NOT_IN_USE, /* Has something to do with fund buildings */
RGT_ALLEY,
RGT_ROADWORK_GRASS,
RGT_ROADWORK_PAVED,
RGT_ROADWORK_OFFSET = RGT_ROADWORK_GRASS - RGT_GRASS
} RoadGroundType;
static inline RoadGroundType GetGroundType(TileIndex t)
{
return (RoadGroundType)GB(_m[t].m4, 4, 3);
}
static inline void SetGroundType(TileIndex t, RoadGroundType rgt)
{
SB(_m[t].m4, 4, 3, rgt);
}
static inline bool HasRoadWorks(TileIndex t)
{
return GetGroundType(t) >= RGT_ROADWORK_GRASS;
}
static inline bool IncreaseRoadWorksCounter(TileIndex t)
{
AB(_m[t].m4, 0, 4, 1);
return GB(_m[t].m4, 0, 4) == 15;
}
static inline void StartRoadWorks(TileIndex t)
{
assert(!HasRoadWorks(t));
/* Remove any trees or lamps in case or roadwork */
SetGroundType(t, min(GetGroundType(t), RGT_PAVED) + RGT_ROADWORK_OFFSET);
}
static inline void TerminateRoadWorks(TileIndex t)
{
assert(HasRoadWorks(t));
SetGroundType(t, GetGroundType(t) - RGT_ROADWORK_OFFSET);
/* Stop the counter */
SB(_m[t].m4, 0, 4, 0);
}
static inline bool HasPavement(TileIndex t)
{
return GetGroundType(t) >= RGT_PAVED && GetGroundType(t) != RGT_ROADWORK_GRASS;
}
static inline DiagDirection GetRoadDepotDirection(TileIndex t) static inline DiagDirection GetRoadDepotDirection(TileIndex t)
{ {