diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/elrail.cpp | 10 | ||||
| -rw-r--r-- | src/newgrf.cpp | 37 | ||||
| -rw-r--r-- | src/newgrf_railtype.cpp | 112 | ||||
| -rw-r--r-- | src/newgrf_railtype.h | 12 | ||||
| -rw-r--r-- | src/newgrf_spritegroup.h | 3 | ||||
| -rw-r--r-- | src/newgrf_station.cpp | 3 | ||||
| -rw-r--r-- | src/rail.h | 63 | ||||
| -rw-r--r-- | src/rail_cmd.cpp | 256 | ||||
| -rw-r--r-- | src/road_cmd.cpp | 32 | ||||
| -rw-r--r-- | src/station_cmd.cpp | 46 | ||||
| -rw-r--r-- | src/table/railtypes.h | 8 | ||||
| -rw-r--r-- | src/table/road_land.h | 14 | ||||
| -rw-r--r-- | src/tunnelbridge_cmd.cpp | 63 |
13 files changed, 605 insertions, 54 deletions
diff --git a/src/elrail.cpp b/src/elrail.cpp index 0cf7b905d..41b0d5a74 100644 --- a/src/elrail.cpp +++ b/src/elrail.cpp @@ -64,6 +64,8 @@ #include "elrail_func.h" #include "engine_base.h" #include "company_base.h" +#include "rail.h" +#include "newgrf_railtype.h" #include "table/sprites.h" #include "table/elrail_data.h" @@ -165,7 +167,9 @@ static TrackBits MaskWireBits(TileIndex t, TrackBits tracks) */ static inline SpriteID GetWireBase(TileIndex tile) { - return SPR_WIRE_BASE; + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(tile)); + SpriteID wires = GetCustomRailSprite(rti, tile, RTSG_WIRES); + return wires == 0 ? SPR_WIRE_BASE : wires; } /** @@ -173,7 +177,9 @@ static inline SpriteID GetWireBase(TileIndex tile) */ static inline SpriteID GetPylonBase(TileIndex tile) { - return SPR_PYLON_BASE; + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(tile)); + SpriteID pylons = GetCustomRailSprite(rti, tile, RTSG_PYLONS); + return pylons == 0 ? SPR_PYLON_BASE : pylons; } /** Corrects the tileh for certain tile types. Returns an effective tileh for the track on the tile. diff --git a/src/newgrf.cpp b/src/newgrf.cpp index f8d988489..d6db4c6f3 100644 --- a/src/newgrf.cpp +++ b/src/newgrf.cpp @@ -3037,6 +3037,7 @@ static void NewSpriteGroup(ByteReader *buf) case GSF_STATION: case GSF_CANAL: case GSF_CARGOS: + case GSF_RAILTYPES: { byte sprites = _cur_grffile->spriteset_numents; byte num_loaded = type; @@ -3519,6 +3520,35 @@ static void CargoMapSpriteGroup(ByteReader *buf, uint8 idcount) } } +static void RailTypeMapSpriteGroup(ByteReader *buf, uint8 idcount) +{ + uint8 *railtypes = AllocaM(uint8, idcount); + for (uint i = 0; i < idcount; i++) { + railtypes[i] = _cur_grffile->railtype_map[buf->ReadByte()]; + } + + uint8 cidcount = buf->ReadByte(); + for (uint c = 0; c < cidcount; c++) { + uint8 ctype = buf->ReadByte(); + uint16 groupid = buf->ReadWord(); + if (!IsValidGroupID(groupid, "RailTypeMapSpriteGroup")) continue; + + if (ctype >= RTSG_END) continue; + + extern RailtypeInfo _railtypes[RAILTYPE_END]; + for (uint i = 0; i < idcount; i++) { + if (railtypes[i] != INVALID_RAILTYPE) { + RailtypeInfo *rti = &_railtypes[railtypes[i]]; + + rti->group[ctype] = _cur_grffile->spritegroups[groupid]; + } + } + } + + /* Railtypes do not use the default group. */ + buf->ReadWord(); +} + /* Action 0x03 */ static void FeatureMapSpriteGroup(ByteReader *buf) @@ -3594,6 +3624,10 @@ static void FeatureMapSpriteGroup(ByteReader *buf) CargoMapSpriteGroup(buf, idcount); return; + case GSF_RAILTYPES: + RailTypeMapSpriteGroup(buf, idcount); + break; + default: grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature); return; @@ -6446,6 +6480,9 @@ static void AfterLoadGRFs() /* Load old shore sprites in new position, if they were replaced by ActionA */ ActivateOldShore(); + /* Set up custom rail types */ + InitRailTypes(); + Engine *e; FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) { if (_gted[e->index].rv_max_speed != 0) { diff --git a/src/newgrf_railtype.cpp b/src/newgrf_railtype.cpp new file mode 100644 index 000000000..b76eb2aef --- /dev/null +++ b/src/newgrf_railtype.cpp @@ -0,0 +1,112 @@ +/* $Id$ */ + +/** @file newgrf_railtype.cpp NewGRF handling of rail types. */ + +#include "stdafx.h" +#include "openttd.h" +#include "variables.h" +#include "debug.h" +#include "strings_type.h" +#include "rail.h" +#include "road_map.h" +#include "newgrf.h" +#include "newgrf_callbacks.h" +#include "newgrf_commons.h" +#include "newgrf_railtype.h" +#include "newgrf_spritegroup.h" + +static uint32 RailTypeGetRandomBits(const ResolverObject *object) +{ + return 0; +} + +static uint32 RailTypeGetTriggers(const ResolverObject *object) +{ + return 0; +} + +static void RailTypeSetTriggers(const ResolverObject *object, int triggers) +{ +} + +static uint32 RailTypeGetVariable(const ResolverObject *object, byte variable, byte parameter, bool *available) +{ + TileIndex tile = object->u.routes.tile; + + if (tile == INVALID_TILE) { + switch (variable) { + case 0x40: return 0; + case 0x41: return 0; + case 0x42: return 0; + } + } + + switch (variable) { + case 0x40: return GetTerrainType(tile); + case 0x41: return 0; + case 0x42: return IsLevelCrossingTile(tile) && IsCrossingBarred(tile); + } + + DEBUG(grf, 1, "Unhandled rail type tile property 0x%X", variable); + + *available = false; + return UINT_MAX; +} + +static const SpriteGroup *RailTypeResolveReal(const ResolverObject *object, const RealSpriteGroup *group) +{ + if (group->num_loading > 0) return group->loading[0]; + if (group->num_loaded > 0) return group->loaded[0]; + return NULL; +} + +static inline void NewRailTypeResolver(ResolverObject *res, TileIndex tile) +{ + res->GetRandomBits = &RailTypeGetRandomBits; + res->GetTriggers = &RailTypeGetTriggers; + res->SetTriggers = &RailTypeSetTriggers; + res->GetVariable = &RailTypeGetVariable; + res->ResolveReal = &RailTypeResolveReal; + + res->u.routes.tile = tile; + + res->callback = CBID_NO_CALLBACK; + res->callback_param1 = 0; + res->callback_param2 = 0; + res->last_value = 0; + res->trigger = 0; + res->reseed = 0; + res->count = 0; +} + +SpriteID GetCustomRailSprite(const RailtypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg) +{ + assert(rtsg < RTSG_END); + + if (rti->group[rtsg] == NULL) return 0; + + const SpriteGroup *group; + ResolverObject object; + + NewRailTypeResolver(&object, tile); + + group = SpriteGroup::Resolve(rti->group[rtsg], &object); + if (group == NULL || group->GetNumResults() == 0) return 0; + + return group->GetResult(); +} + +uint8 GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile) +{ + /* No rail type table present, return rail type as-is */ + if (grffile->railtype_max == 0) return railtype; + + /* Look for a matching rail type label in the table */ + RailTypeLabel label = GetRailTypeInfo(railtype)->label; + for (uint i = 0; i < grffile->railtype_max; i++) { + if (label == grffile->railtype_list[i]) return i; + } + + /* If not found, return as invalid */ + return 0xFF; +} diff --git a/src/newgrf_railtype.h b/src/newgrf_railtype.h new file mode 100644 index 000000000..8dcd4fed0 --- /dev/null +++ b/src/newgrf_railtype.h @@ -0,0 +1,12 @@ +/* $Id$ */ + +#ifndef NEWGRF_RAILTYPE_H +#define NEWGRF_RAILTYPE_H + +#include "rail.h" + +SpriteID GetCustomRailSprite(const RailtypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg); + +uint8 GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile); + +#endif /* NEWGRF_RAILTYPE_H */ diff --git a/src/newgrf_spritegroup.h b/src/newgrf_spritegroup.h index a97405672..22c202aa6 100644 --- a/src/newgrf_spritegroup.h +++ b/src/newgrf_spritegroup.h @@ -339,6 +339,9 @@ struct ResolverObject { uint8 count; uint8 station_size; } generic; + struct { + TileIndex tile; + } routes; } u; uint32 (*GetRandomBits)(const struct ResolverObject*); diff --git a/src/newgrf_station.cpp b/src/newgrf_station.cpp index d6dcba7b0..52c7c1edb 100644 --- a/src/newgrf_station.cpp +++ b/src/newgrf_station.cpp @@ -20,6 +20,7 @@ #include "newgrf_station.h" #include "newgrf_spritegroup.h" #include "newgrf_sound.h" +#include "newgrf_railtype.h" #include "town.h" #include "newgrf_town.h" #include "date_func.h" @@ -442,7 +443,7 @@ static uint32 StationGetVariable(const ResolverObject *object, byte variable, by if (!HasBit(_svc.valid, 1)) { _svc.v41 = GetPlatformInfoHelper(tile, true, false, false); SetBit(_svc.valid, 1); } return _svc.v41; - case 0x42: return GetTerrainType(tile) | (GetRailType(tile) << 8); + case 0x42: return GetTerrainType(tile) | (GetReverseRailTypeTranslation(GetRailType(tile), object->u.station.statspec->grffile) << 8); case 0x43: return st->owner; // Station owner case 0x44: return HasStationReservation(tile) ? 7 : 4; // PBS status case 0x45: diff --git a/src/rail.h b/src/rail.h index 3ea708db1..8caf2573d 100644 --- a/src/rail.h +++ b/src/rail.h @@ -30,6 +30,54 @@ enum RailTypeFlags { }; DECLARE_ENUM_AS_BIT_SET(RailTypeFlags); +struct SpriteGroup; + +enum RailTypeSpriteGroup { + RTSG_CURSORS, ///< Cursor and toolbar icon images + RTSG_OVERLAY, ///< Images for overlaying track + RTSG_GROUND, ///< Main group of ground images + RTSG_TUNNEL, ///< Main group of ground images for snow or desert + RTSG_WIRES, ///< Catenary wires + RTSG_PYLONS, ///< Catenary pylons + RTSG_BRIDGE, ///< Bridge surface images + RTSG_CROSSING, ///< Level crossing overlay images + RTSG_DEPOT, ///< Depot images + RTSG_FENCES, ///< Fence images + RTSG_END, +}; + +/** + * Offsets for sprites within an overlay/underlay set. + * These are the same for overlay and underlay sprites. + */ +enum RailTrackOffset { + RTO_X, ///< Piece of rail in X direction + RTO_Y, ///< Piece of rail in Y direction + RTO_N, ///< Piece of rail in northern corner + RTO_S, ///< Piece of rail in southern corner + RTO_E, ///< Piece of rail in eastern corner + RTO_W, ///< Piece of rail in western corner + RTO_SLOPE_NE, ///< Piece of rail on slope with north-east raised + RTO_SLOPE_SE, ///< Piece of rail on slope with south-east raised + RTO_SLOPE_SW, ///< Piece of rail on slope with south-west raised + RTO_SLOPE_NW, ///< Piece of rail on slope with north-west raised + RTO_CROSSING_XY, ///< Crossing of X and Y rail, with ballast + RTO_JUNCTION_SW, ///< Ballast for junction 'pointing' SW + RTO_JUNCTION_NE, ///< Ballast for junction 'pointing' NE + RTO_JUNCTION_SE, ///< Ballast for junction 'pointing' SE + RTO_JUNCTION_NW, ///< Ballast for junction 'pointing' NW + RTO_JUNCTION_NSEW,///< Ballast for full junction +}; + +/** + * Offsets for spries within a bridge surface overlay set. + */ +enum RailTrackBridgeOffset { + RTBO_X, ///< Piece of rail in X direction + RTBO_Y, ///< Piece of rail in Y direction + RTBO_SLOPE, ///< Sloped rail pieces, in order NE, SE, SW, NW +}; + /** Offsets from base sprite for fence sprites. These are in the order of * the sprites in the original data files. */ @@ -154,6 +202,16 @@ struct RailtypeInfo { * Unique 32 bit rail type identifier */ RailTypeLabel label; + + /** + * Sprite groups for resolving sprites + */ + const SpriteGroup *group[RTSG_END]; + + inline bool UsesOverlay() const + { + return this->group[RTSG_GROUND] != NULL; + } }; @@ -287,6 +345,11 @@ RailType GetRailTypeByLabel(RailTypeLabel label); void ResetRailTypes(); /** + * Resolve sprites of custom rail types + */ +void InitRailTypes(); + +/** * Allocate a new rail type label */ RailType AllocateRailType(RailTypeLabel label); diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp index c9e2c3916..7de13a03a 100644 --- a/src/rail_cmd.cpp +++ b/src/rail_cmd.cpp @@ -19,6 +19,8 @@ #include "pathfinder/yapf/yapf_cache.h" #include "newgrf_engine.h" #include "landscape_type.h" +#include "newgrf_railtype.h" +#include "newgrf_commons.h" #include "train.h" #include "variables.h" #include "autoslope.h" @@ -52,6 +54,37 @@ void ResetRailTypes() memcpy(_railtypes, _original_railtypes, sizeof(_original_railtypes)); } +void ResolveRailTypeGUISprites(RailtypeInfo *rti) +{ + SpriteID cursors_base = GetCustomRailSprite(rti, INVALID_TILE, RTSG_CURSORS); + if (cursors_base != 0) { + rti->gui_sprites.build_ns_rail = cursors_base + 0; + rti->gui_sprites.build_x_rail = cursors_base + 1; + rti->gui_sprites.build_ew_rail = cursors_base + 2; + rti->gui_sprites.build_y_rail = cursors_base + 3; + rti->gui_sprites.auto_rail = cursors_base + 4; + rti->gui_sprites.build_depot = cursors_base + 5; + rti->gui_sprites.build_tunnel = cursors_base + 6; + rti->gui_sprites.convert_rail = cursors_base + 7; + rti->cursor.rail_ns = cursors_base + 8; + rti->cursor.rail_swne = cursors_base + 9; + rti->cursor.rail_ew = cursors_base + 10; + rti->cursor.rail_nwse = cursors_base + 11; + rti->cursor.autorail = cursors_base + 12; + rti->cursor.depot = cursors_base + 13; + rti->cursor.tunnel = cursors_base + 14; + rti->cursor.convert = cursors_base + 15; + } +} + +void InitRailTypes() +{ + for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) { + RailtypeInfo *rti = &_railtypes[rt]; + ResolveRailTypeGUISprites(rti); + } +} + RailType AllocateRailType(RailTypeLabel label) { for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) { @@ -1709,10 +1742,11 @@ static void DrawTrackFence_WE_2(const TileInfo *ti, SpriteID base_image) } -static void DrawTrackDetails(const TileInfo *ti) +static void DrawTrackDetails(const TileInfo *ti, const RailtypeInfo *rti) { /* Base sprite for track fences. */ - SpriteID base_image = SPR_TRACK_FENCE_FLAT_X; + SpriteID base_image = GetCustomRailSprite(rti, ti->tile, RTSG_FENCES); + if (base_image == 0) base_image = SPR_TRACK_FENCE_FLAT_X; switch (GetRailGroundType(ti->tile)) { case RAIL_GROUND_FENCE_NW: DrawTrackFence_NW(ti, base_image); break; @@ -1747,6 +1781,162 @@ static void DrawTrackDetails(const TileInfo *ti) } } +/* SubSprite for drawing the track halftile of 'three-corners-raised'-sloped rail sprites. */ +static const int INF = 1000; // big number compared to tilesprite size +static const SubSprite _halftile_sub_sprite[4] = { + { -INF , -INF , 32 - 33, INF }, // CORNER_W, clip 33 pixels from right + { -INF , 0 + 7, INF , INF }, // CORNER_S, clip 7 pixels from top + { -31 + 33, -INF , INF , INF }, // CORNER_E, clip 33 pixels from left + { -INF , -INF , INF , 30 - 23 } // CORNER_N, clip 23 pixels from bottom +}; + +static inline void DrawTrackSprite(SpriteID sprite, PaletteID pal, const TileInfo *ti, Slope s) +{ + DrawGroundSprite(sprite, pal, NULL, 0, (ti->tileh & s) ? -8 : 0); +} + +static void DrawTrackBitsOverlay(TileInfo *ti, TrackBits track, const RailtypeInfo *rti) +{ + RailGroundType rgt = GetRailGroundType(ti->tile); + Foundation f = GetRailFoundation(ti->tileh, track); + Corner halftile_corner = CORNER_INVALID; + + if (IsNonContinuousFoundation(f)) { + /* Save halftile corner */ + halftile_corner = (f == FOUNDATION_STEEP_BOTH ? GetHighestSlopeCorner(ti->tileh) : GetHalftileFoundationCorner(f)); + /* Draw lower part first */ + track &= ~CornerToTrackBits(halftile_corner); + f = (f == FOUNDATION_STEEP_BOTH ? FOUNDATION_STEEP_LOWER : FOUNDATION_NONE); + } + + DrawFoundation(ti, f); + /* DrawFoundation modifies ti */ + + /* Draw ground */ + if (track == TRACK_BIT_NONE && rgt == RAIL_GROUND_WATER) { + if (IsSteepSlope(ti->tileh)) { + DrawShoreTile(ti->tileh); + } else { + DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE); + } + } else { + SpriteID image; + + switch (rgt) { + case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break; + case RAIL_GROUND_ICE_DESERT: image = SPR_FLAT_SNOW_DESERT_TILE; break; + default: image = SPR_FLAT_GRASS_TILE; break; + } + + image += _tileh_to_sprite[ti->tileh]; + + DrawGroundSprite(image, PAL_NONE); + } + + SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY); + SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND); + TrackBits pbs = _settings_client.gui.show_track_reservation ? GetRailReservationTrackBits(ti->tile) : TRACK_BIT_NONE; + + if (track == TRACK_BIT_NONE) { + /* Half-tile foundation, no track here? */ + } else if (ti->tileh == SLOPE_NW && track == TRACK_BIT_Y) { + DrawGroundSprite(ground + RTO_SLOPE_NW, PAL_NONE); + if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + 9, PALETTE_CRASH); + } else if (ti->tileh == SLOPE_NE && track == TRACK_BIT_X) { + DrawGroundSprite(ground + RTO_SLOPE_NE, PAL_NONE); + if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + 6, PALETTE_CRASH); + } else if (ti->tileh == SLOPE_SE && track == TRACK_BIT_Y) { + DrawGroundSprite(ground + RTO_SLOPE_SE, PAL_NONE); + if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + 7, PALETTE_CRASH); + } else if (ti->tileh == SLOPE_SW && track == TRACK_BIT_X) { + DrawGroundSprite(ground + RTO_SLOPE_SW, PAL_NONE); + if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + 8, PALETTE_CRASH); + } else { + switch (track) { + /* Draw single ground sprite when not overlapping. No track overlay + * is necessary for these sprites. */ + case TRACK_BIT_X: DrawGroundSprite(ground + RTO_X, PAL_NONE); break; + case TRACK_BIT_Y: DrawGroundSprite(ground + RTO_Y, PAL_NONE); break; + case TRACK_BIT_UPPER: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N); break; + case TRACK_BIT_LOWER: DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break; + case TRACK_BIT_RIGHT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E); break; + case TRACK_BIT_LEFT: DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break; + case TRACK_BIT_CROSS: DrawGroundSprite(ground + RTO_CROSSING_XY, PAL_NONE); break; + case TRACK_BIT_HORZ: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N); + DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break; + case TRACK_BIT_VERT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E); + DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break; + + default: + /* We're drawing a junction tile */ + if ((track & TRACK_BIT_3WAY_NE) == 0) { + DrawGroundSprite(ground + RTO_JUNCTION_SW, PAL_NONE); + } else if ((track & TRACK_BIT_3WAY_SW) == 0) { + DrawGroundSprite(ground + RTO_JUNCTION_NE, PAL_NONE); + } else if ((track & TRACK_BIT_3WAY_NW) == 0) { + DrawGroundSprite(ground + RTO_JUNCTION_SE, PAL_NONE); + } else if ((track & TRACK_BIT_3WAY_SE) == 0) { + DrawGroundSprite(ground + RTO_JUNCTION_NW, PAL_NONE); + } else { + DrawGroundSprite(ground + RTO_JUNCTION_NSEW, PAL_NONE); + } + + /* Mask out PBS bits as we shall draw them afterwards anyway. */ + track &= ~pbs; + + /* Draw regular track bits */ + if (track & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PAL_NONE); + if (track & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PAL_NONE); + if (track & TRACK_BIT_UPPER) DrawGroundSprite(overlay + RTO_N, PAL_NONE); + if (track & TRACK_BIT_LOWER) DrawGroundSprite(overlay + RTO_S, PAL_NONE); + if (track & TRACK_BIT_RIGHT) DrawGroundSprite(overlay + RTO_E, PAL_NONE); + if (track & TRACK_BIT_LEFT) DrawGroundSprite(overlay + RTO_W, PAL_NONE); + } + + /* Draw reserved track bits */ + if (pbs & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH); + if (pbs & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH); + if (pbs & TRACK_BIT_UPPER) DrawTrackSprite(overlay + RTO_N, PALETTE_CRASH, ti, SLOPE_N); + if (pbs & TRACK_BIT_LOWER) DrawTrackSprite(overlay + RTO_S, PALETTE_CRASH, ti, SLOPE_S); + if (pbs & TRACK_BIT_RIGHT) DrawTrackSprite(overlay + RTO_E, PALETTE_CRASH, ti, SLOPE_E); + if (pbs & TRACK_BIT_LEFT) DrawTrackSprite(overlay + RTO_W, PALETTE_CRASH, ti, SLOPE_W); + } + + if (IsValidCorner(halftile_corner)) { + DrawFoundation(ti, HalftileFoundation(halftile_corner)); + + /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */ + Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner)); + + SpriteID image; + switch (rgt) { + case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break; + case RAIL_GROUND_ICE_DESERT: + case RAIL_GROUND_HALF_SNOW: image = SPR_FLAT_SNOW_DESERT_TILE; break; + default: image = SPR_FLAT_GRASS_TILE; break; + } + + image += _tileh_to_sprite[fake_slope]; + + DrawGroundSprite(image, PAL_NONE, &(_halftile_sub_sprite[halftile_corner])); + + track = CornerToTrackBits(halftile_corner); + + int offset; + switch (track) { + default: NOT_REACHED(); + case TRACK_BIT_UPPER: offset = RTO_N; break; + case TRACK_BIT_LOWER: offset = RTO_S; break; + case TRACK_BIT_RIGHT: offset = RTO_E; break; + case TRACK_BIT_LEFT: offset = RTO_W; break; + } + + DrawTrackSprite(ground + offset, PAL_NONE, ti, fake_slope); + if (HasReservedTracks(ti->tile, track)) { + DrawTrackSprite(overlay + offset, PALETTE_CRASH, ti, fake_slope); + } + } +} /** * Draw ground sprite and track bits @@ -1755,16 +1945,13 @@ static void DrawTrackDetails(const TileInfo *ti) */ static void DrawTrackBits(TileInfo *ti, TrackBits track) { - /* SubSprite for drawing the track halftile of 'three-corners-raised'-sloped rail sprites. */ - static const int INF = 1000; // big number compared to tilesprite size - static const SubSprite _halftile_sub_sprite[4] = { - { -INF , -INF , 32 - 33, INF }, // CORNER_W, clip 33 pixels from right - { -INF , 0 + 7, INF , INF }, // CORNER_S, clip 7 pixels from top - { -31 + 33, -INF , INF , INF }, // CORNER_E, clip 33 pixels from left - { -INF , -INF , INF , 30 - 23 } // CORNER_N, clip 23 pixels from bottom - }; - const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + + if (rti->UsesOverlay()) { + DrawTrackBitsOverlay(ti, track, rti); + return; + } + RailGroundType rgt = GetRailGroundType(ti->tile); Foundation f = GetRailFoundation(ti->tileh, track); Corner halftile_corner = CORNER_INVALID; @@ -1960,7 +2147,7 @@ static void DrawTile_Track(TileInfo *ti) DrawTrackBits(ti, rails); - if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti); + if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti, rti); if (HasCatenaryDrawn(GetRailType(ti->tile))) DrawCatenary(ti); @@ -1969,6 +2156,7 @@ static void DrawTile_Track(TileInfo *ti) /* draw depot */ const DrawTileSprites *dts; PaletteID pal = PAL_NONE; + SpriteID relocation; if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED); @@ -1979,8 +2167,12 @@ static void DrawTile_Track(TileInfo *ti) dts = &_depot_gfx_table[GetRailDepotDirection(ti->tile)]; } - image = dts->ground.sprite; - if (image != SPR_FLAT_GRASS_TILE) image += rti->total_offset; + if (rti->UsesOverlay()) { + image = SPR_FLAT_GRASS_TILE; + } else { + image = dts->ground.sprite; + if (image != SPR_FLAT_GRASS_TILE) image += rti->total_offset; + } /* adjust ground tile for desert * don't adjust for snow, because snow in depots looks weird */ @@ -1994,19 +2186,43 @@ static void DrawTile_Track(TileInfo *ti) DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, _drawtile_track_palette)); - /* PBS debugging, draw reserved tracks darker */ - if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) { + if (rti->UsesOverlay()) { + SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND); + switch (GetRailDepotDirection(ti->tile)) { - case DIAGDIR_SW: DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH); break; - case DIAGDIR_SE: DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH); break; + case DIAGDIR_SW: DrawGroundSprite(ground + RTO_X, PAL_NONE); break; + case DIAGDIR_SE: DrawGroundSprite(ground + RTO_Y, PAL_NONE); break; default: break; } + + if (_settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) { + SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY); + + switch (GetRailDepotDirection(ti->tile)) { + case DIAGDIR_SW: DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH); break; + case DIAGDIR_SE: DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH); break; + default: break; + } + } + + relocation = GetCustomRailSprite(rti, ti->tile, RTSG_DEPOT); + relocation -= SPR_RAIL_DEPOT_SE_1; + } else { + /* PBS debugging, draw reserved tracks darker */ + if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) { + switch (GetRailDepotDirection(ti->tile)) { + case DIAGDIR_SW: DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH); break; + case DIAGDIR_SE: DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH); break; + default: break; + } + } + + relocation = rti->total_offset; } if (HasCatenaryDrawn(GetRailType(ti->tile))) DrawCatenary(ti); - /* No NewGRF depots, so no relocation */ - DrawRailTileSeq(ti, dts, TO_BUILDINGS, rti->total_offset, 0, _drawtile_track_palette); + DrawRailTileSeq(ti, dts, TO_BUILDINGS, relocation, 0, _drawtile_track_palette); } DrawBridgeMiddle(ti); } diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp index 8b7643cc1..c877bf0ef 100644 --- a/src/road_cmd.cpp +++ b/src/road_cmd.cpp @@ -35,6 +35,7 @@ #include "town.h" #include "company_base.h" #include "core/random_func.hpp" +#include "newgrf_railtype.h" #include "table/strings.h" @@ -1164,7 +1165,36 @@ static void DrawTile_Road(TileInfo *ti) case ROAD_TILE_CROSSING: { if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED); - SpriteID image = GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.crossing; + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + + if (rti->UsesOverlay()) { + Axis axis = GetCrossingRailAxis(ti->tile); + SpriteID road = SPR_ROAD_Y + axis; + PaletteID pal = PAL_NONE; + + Roadside roadside = GetRoadside(ti->tile); + + if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) { + road += 19; + } else { + switch (roadside) { + case ROADSIDE_BARREN: pal = PALETTE_TO_BARE_LAND; break; + case ROADSIDE_GRASS: break; + default: road -= 19; break; // Paved + } + } + + DrawGroundSprite(road, pal); + + SpriteID rail = GetCustomRailSprite(rti, ti->tile, RTSG_CROSSING) + axis; + DrawGroundSprite(rail, PAL_NONE); + DrawRailTileSeq(ti, &_crossing_layout, TO_CATENARY, rail, 0, PAL_NONE); + + if (HasCatenaryDrawn(GetRailType(ti->tile))) DrawCatenary(ti); + break; + } + + SpriteID image = rti->base_sprites.crossing; PaletteID pal = PAL_NONE; if (GetCrossingRoadAxis(ti->tile) == AXIS_X) image++; diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp index b92adbd96..5ac5b7cac 100644 --- a/src/station_cmd.cpp +++ b/src/station_cmd.cpp @@ -39,6 +39,7 @@ #include "elrail_func.h" #include "station_base.h" #include "roadstop_base.h" +#include "newgrf_railtype.h" #include "waypoint_base.h" #include "waypoint_func.h" #include "pbs.h" @@ -2303,12 +2304,13 @@ static void DrawTile_Station(TileInfo *ti) RoadTypes roadtypes; int32 total_offset; int32 custom_ground_offset; + const RailtypeInfo *rti = NULL; uint32 relocation = 0; const BaseStation *st = NULL; const StationSpec *statspec = NULL; if (HasStationRail(ti->tile)) { - const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + rti = GetRailTypeInfo(GetRailType(ti->tile)); roadtypes = ROADTYPES_NONE; total_offset = rti->total_offset; custom_ground_offset = rti->custom_ground_offset; @@ -2446,18 +2448,29 @@ static void DrawTile_Station(TileInfo *ti) } else { SpriteID image = t->ground.sprite; PaletteID pal = t->ground.pal; - if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) { - image += GetCustomStationGroundRelocation(statspec, st, ti->tile); - image += custom_ground_offset; + if (rti != NULL && rti->UsesOverlay() && (image == SPR_RAIL_TRACK_X || image == SPR_RAIL_TRACK_Y)) { + SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND); + DrawGroundSprite(SPR_FLAT_GRASS_TILE, PAL_NONE); + DrawGroundSprite(ground + (image == SPR_RAIL_TRACK_X ? RTO_X : RTO_Y), PAL_NONE); + + if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationReservation(ti->tile)) { + SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY); + DrawGroundSprite(overlay + (image == SPR_RAIL_TRACK_X ? RTO_X : RTO_Y), PALETTE_CRASH); + } } else { - image += total_offset; - } - DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette)); + if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) { + image += GetCustomStationGroundRelocation(statspec, st, ti->tile); + image += custom_ground_offset; + } else { + image += total_offset; + } + DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette)); - /* PBS debugging, draw reserved tracks darker */ - if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationRail(ti->tile) && HasStationReservation(ti->tile)) { - const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); - DrawGroundSprite(GetRailStationAxis(ti->tile) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH); + /* PBS debugging, draw reserved tracks darker */ + if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationRail(ti->tile) && HasStationReservation(ti->tile)) { + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + DrawGroundSprite(GetRailStationAxis(ti->tile) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH); + } } } @@ -2482,14 +2495,21 @@ void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, Ro int32 total_offset = 0; PaletteID pal = COMPANY_SPRITE_COLOUR(_local_company); const DrawTileSprites *t = &_station_display_datas[st][image]; + const RailtypeInfo *rti = NULL; if (railtype != INVALID_RAILTYPE) { - const RailtypeInfo *rti = GetRailTypeInfo(railtype); + rti = GetRailTypeInfo(railtype); total_offset = rti->total_offset; } SpriteID img = t->ground.sprite; - DrawSprite(img + total_offset, HasBit(img, PALETTE_MODIFIER_COLOUR) ? pal : PAL_NONE, x, y); + if ((img == SPR_RAIL_TRACK_X || img == SPR_RAIL_TRACK_Y) && rti->UsesOverlay()) { + SpriteID ground = GetCustomRailSprite(rti, INVALID_TILE, RTSG_GROUND); + DrawSprite(SPR_FLAT_GRASS_TILE, PAL_NONE, x, y); + DrawSprite(ground + (img == SPR_RAIL_TRACK_X ? RTO_X : RTO_Y), PAL_NONE, x, y); + } else { + DrawSprite(img + total_offset, HasBit(img, PALETTE_MODIFIER_COLOUR) ? pal : PAL_NONE, x, y); + } if (roadtype == ROADTYPE_TRAM) { DrawSprite(SPR_TRAMWAY_TRAM + (t->ground.sprite == SPR_ROAD_PAVED_STRAIGHT_X ? 1 : 0), PAL_NONE, x, y); diff --git a/src/table/railtypes.h b/src/table/railtypes.h index a01200a05..75d69ee69 100644 --- a/src/table/railtypes.h +++ b/src/table/railtypes.h @@ -89,6 +89,8 @@ static const RailtypeInfo _original_railtypes[] = { /* rail type label */ 'RAIL', + + { NULL }, }, /** Electrified railway */ @@ -167,6 +169,8 @@ static const RailtypeInfo _original_railtypes[] = { /* rail type label */ 'ELRL', + + { NULL }, }, /** Monorail */ @@ -241,6 +245,8 @@ static const RailtypeInfo _original_railtypes[] = { /* rail type label */ 'MONO', + + { NULL }, }, /** Maglev */ @@ -315,6 +321,8 @@ static const RailtypeInfo _original_railtypes[] = { /* rail type label */ 'MGLV', + + { NULL }, }, }; diff --git a/src/table/road_land.h b/src/table/road_land.h index e6ec411bd..19b8f5711 100644 --- a/src/table/road_land.h +++ b/src/table/road_land.h @@ -70,6 +70,20 @@ static const DrawTileSprites _tram_depot[] = { { {0xA4A, PAL_NONE}, _tram_depot_NW } }; +/* Sprite layout for level crossings. The SpriteIDs are actually offsets + * from the base SpriteID returned from the NewGRF sprite resolver. */ +static const DrawTileSeqStruct _crossing_layout_ALL[] = { + TILE_SEQ_LINE(2, PAL_NONE, 0, 0, 3, 3) + TILE_SEQ_LINE(4, PAL_NONE, 0, 13, 3, 3) + TILE_SEQ_LINE(6, PAL_NONE, 13, 0, 3, 3) + TILE_SEQ_LINE(8, PAL_NONE, 13, 13, 3, 3) + TILE_SEQ_END() +}; + +static const DrawTileSprites _crossing_layout = { + {0, PAL_NONE}, _crossing_layout_ALL +}; + #undef TILE_SEQ_LINE #undef TILE_SEQ_END diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index a9d24c7a2..fdbfc8a67 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -40,6 +40,7 @@ #include "pbs.h" #include "company_base.h" #include "engine_base.h" +#include "newgrf_railtype.h" #include "table/sprites.h" #include "table/strings.h" @@ -930,14 +931,22 @@ static void DrawTile_TunnelBridge(TileInfo *ti) AddSortableSpriteToDraw(SPR_TRAMWAY_TUNNEL_WIRES + tunnelbridge_direction, PAL_NONE, ti->x, ti->y, BB_data[10], BB_data[11], TILE_HEIGHT, ti->z, IsTransparencySet(TO_CATENARY), BB_data[8], BB_data[9], BB_Z_SEPARATOR); } } - } else if (HasCatenaryDrawn(GetRailType(ti->tile))) { - /* Maybe draw pylons on the entry side */ - DrawCatenary(ti); + } else { + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + if (rti->UsesOverlay()) { + SpriteID surface = GetCustomRailSprite(rti, ti->tile, RTSG_TUNNEL); + if (surface != 0) DrawGroundSprite(surface + tunnelbridge_direction, PAL_NONE); + } - catenary = true; - StartSpriteCombine(); - /* Draw wire above the ramp */ - DrawCatenaryOnTunnel(ti); + if (HasCatenaryDrawn(GetRailType(ti->tile))) { + /* Maybe draw pylons on the entry side */ + DrawCatenary(ti); + + catenary = true; + StartSpriteCombine(); + /* Draw wire above the ramp */ + DrawCatenaryOnTunnel(ti); + } } AddSortableSpriteToDraw(image + 1, PAL_NONE, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, BB_data[0], BB_data[1], TILE_HEIGHT, ti->z, false, BB_data[2], BB_data[3], BB_Z_SEPARATOR); @@ -995,15 +1004,6 @@ static void DrawTile_TunnelBridge(TileInfo *ti) /* Bridge heads are drawn solid no matter how invisibility/transparency is set */ AddSortableSpriteToDraw(psid->sprite, psid->pal, ti->x, ti->y, 16, 16, ti->tileh == SLOPE_FLAT ? 0 : 8, ti->z); - if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && transport_type == TRANSPORT_RAIL && HasTunnelBridgeReservation(ti->tile)) { - const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); - if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) { - AddSortableSpriteToDraw(DiagDirToAxis(tunnelbridge_direction) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + 8); - } else { - AddSortableSpriteToDraw(rti->base_sprites.single_sloped + tunnelbridge_direction, PALETTE_CRASH, ti->x, ti->y, 16, 16, 8, ti->z); - } - } - if (transport_type == TRANSPORT_ROAD) { RoadTypes rts = GetRoadTypes(ti->tile); @@ -1021,6 +1021,26 @@ static void DrawTile_TunnelBridge(TileInfo *ti) } EndSpriteCombine(); } else if (transport_type == TRANSPORT_RAIL) { + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); + if (rti->UsesOverlay()) { + SpriteID surface = GetCustomRailSprite(rti, ti->tile, RTSG_BRIDGE); + if (surface != 0) { + if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) { + AddSortableSpriteToDraw(surface + ((DiagDirToAxis(tunnelbridge_direction) == AXIS_X) ? RTBO_X : RTBO_Y), PAL_NONE, ti->x, ti->y, 16, 16, 0, ti->z + 8); + } else { + AddSortableSpriteToDraw(surface + RTBO_SLOPE + tunnelbridge_direction, PAL_NONE, ti->x, ti->y, 16, 16, 8, ti->z); + } + } + /* Don't fallback to non-overlay sprite -- the spec states that + * if an overlay is present then the bridge surface must be + * present. */ + } else if (_game_mode != GM_MENU &&_settings_client.gui.show_track_reservation && HasTunnelBridgeReservation(ti->tile)) { + if (HasBridgeFlatRamp(ti->tileh, DiagDirToAxis(tunnelbridge_direction))) { + AddSortableSpriteToDraw(DiagDirToAxis(tunnelbridge_direction) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + 8); + } else { + AddSortableSpriteToDraw(rti->base_sprites.single_sloped + tunnelbridge_direction, PALETTE_CRASH, ti->x, ti->y, 16, 16, 8, ti->z); + } + } EndSpriteCombine(); if (HasCatenaryDrawn(GetRailType(ti->tile))) { DrawCatenary(ti); @@ -1128,7 +1148,7 @@ void DrawBridgeMiddle(const TileInfo *ti) AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, x, y, 16, 16, 1, bridge_z - TILE_HEIGHT + BB_Z_SEPARATOR); /* Draw Trambits as SpriteCombine */ - if (transport_type == TRANSPORT_ROAD) StartSpriteCombine(); + if (transport_type == TRANSPORT_ROAD || transport_type == TRANSPORT_RAIL) StartSpriteCombine(); /* Draw floor and far part of bridge*/ if (!IsInvisibilitySet(TO_BRIDGES)) { @@ -1152,6 +1172,15 @@ void DrawBridgeMiddle(const TileInfo *ti) StartSpriteCombine(); } } else if (transport_type == TRANSPORT_RAIL) { + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(rampsouth)); + if (rti->UsesOverlay()) { + SpriteID surface = GetCustomRailSprite(rti, ti->tile, RTSG_BRIDGE); + if (surface != 0) { + AddSortableSpriteToDraw(surface + axis, PAL_NONE, x, y, 16, 16, 0, bridge_z, IsTransparencySet(TO_BRIDGES)); + } + } + EndSpriteCombine(); + if (HasCatenaryDrawn(GetRailType(rampsouth))) { DrawCatenaryOnBridge(ti); } |