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

(svn r21521) -Codechange: Unify some cached values that were present in both road vehicles and trains.

release/1.1
terkhen 2010-12-14 21:33:53 +00:00
parent a93944e765
commit 48b7916458
18 changed files with 69 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/ai/api/ai_vehicle.cpp
View File

@ -48,11 +48,7 @@
if (!IsValidVehicle(vehicle_id)) return -1;
const Vehicle *v = ::Vehicle::Get(vehicle_id);
switch (v->type) {
case VEH_ROAD: return ::RoadVehicle::From(v)->rcache.cached_total_length;
case VEH_TRAIN: return ::Train::From(v)->tcache.cached_total_length;
default: return -1;
}
return v->IsGroundVehicle() ? v->GetGroundVehicleCache()->cached_total_length : -1;
}
/* static */ VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id)

7
src/articulated_vehicles.cpp
View File

@ -313,6 +313,9 @@ void AddArticulatedParts(Vehicle *first)
* and we run out of available vehicles, bail out. */
if (!Vehicle::CanAllocateItem()) return;
GroundVehicleCache *gcache = v->GetGroundVehicleCache();
gcache->first_engine = v->engine_type; // Needs to be set before first callback
const Engine *e_artic = Engine::Get(engine_type);
switch (type) {
default: NOT_REACHED();
@ -326,7 +329,6 @@ void AddArticulatedParts(Vehicle *first)
t->subtype = 0;
t->track = front->track;
t->railtype = front->railtype;
t->tcache.first_engine = front->engine_type; // needs to be set before first callback
t->spritenum = e_artic->u.rail.image_index;
if (e_artic->CanCarryCargo()) {
@ -348,8 +350,7 @@ void AddArticulatedParts(Vehicle *first)
v = rv;
rv->subtype = 0;
rv->rcache.first_engine = front->engine_type; // needs to be set before first callback
rv->rcache.cached_veh_length = 8; // Callback is called when the consist is finished
gcache->cached_veh_length = 8; // Callback is called when the consist is finished
rv->state = RVSB_IN_DEPOT;
rv->roadtype = front->roadtype;

6
src/autoreplace_cmd.cpp
View File

@ -421,7 +421,7 @@ static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon
if (old_head->type == VEH_TRAIN) {
/* Store the length of the old vehicle chain, rounded up to whole tiles */
uint16 old_total_length = CeilDiv(Train::From(old_head)->tcache.cached_total_length, TILE_SIZE) * TILE_SIZE;
uint16 old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE;
int num_units = 0; ///< Number of units in the chain
for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++;
@ -481,7 +481,7 @@ static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon
}
/* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */
if (cost.Succeeded() && wagon_removal && new_head->tcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);
if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);
/* Append/insert wagons into the new vehicle chain
* We do this from back to front, so we can stop when wagon removal or maximum train length (i.e. from mammoth-train setting) is triggered.
@ -495,7 +495,7 @@ static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon
/* Insert wagon after 'last_engine' */
CommandCost res = MoveVehicle(append, last_engine, DC_EXEC, false);
if (res.Succeeded() && wagon_removal && new_head->tcache.cached_total_length > old_total_length) {
if (res.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) {
MoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);
break;
}

16
src/depot_gui.cpp
View File

@ -287,7 +287,7 @@ struct DepotWindow : Window {
this->sel, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);
/* Number of wagons relative to a standard length wagon (rounded up) */
SetDParam(0, CeilDiv(u->tcache.cached_total_length, 8));
SetDParam(0, CeilDiv(u->gcache.cached_total_length, 8));
DrawString(rtl ? left + WD_FRAMERECT_LEFT : right - this->count_width, rtl ? left + this->count_width : right - WD_FRAMERECT_RIGHT, y + (this->resize.step_height - FONT_HEIGHT_SMALL) / 2, STR_TINY_BLACK_COMA, TC_FROMSTRING, SA_RIGHT); // Draw the counter
break;
}
@ -507,19 +507,7 @@ struct DepotWindow : Window {
this->sel = v->index;
this->SetDirty();
switch (v->type) {
case VEH_TRAIN:
_cursor.short_vehicle_offset = 16 - Train::From(v)->tcache.cached_veh_length * 2;
break;
case VEH_ROAD:
_cursor.short_vehicle_offset = 16 - RoadVehicle::From(v)->rcache.cached_veh_length * 2;
break;
default:
_cursor.short_vehicle_offset = 0;
break;
}
_cursor.short_vehicle_offset = v->IsGroundVehicle() ? 16 - v->GetGroundVehicleCache()->cached_veh_length * 2 : 0;
_cursor.vehchain = _ctrl_pressed;
}
break;

2
src/economy.cpp
View File

@ -1370,7 +1370,7 @@ static void LoadUnloadVehicle(Vehicle *v, int *cargo_left)
if (v->type == VEH_TRAIN) {
/* Each platform tile is worth 2 rail vehicles. */
int overhang = Train::From(v)->tcache.cached_total_length - st->GetPlatformLength(v->tile) * TILE_SIZE;
int overhang = v->GetGroundVehicleCache()->cached_total_length - st->GetPlatformLength(v->tile) * TILE_SIZE;
if (overhang > 0) {
unloading_time <<= 1;
unloading_time += (overhang * unloading_time) / 8;

5
src/ground_vehicle.hpp
View File

@ -36,6 +36,11 @@ struct GroundVehicleCache {
uint16 cached_max_track_speed; ///< Maximum consist speed limited by track type (valid only for the first engine).
uint32 cached_power; ///< Total power of the consist (valid only for the first engine).
uint32 cached_air_drag; ///< Air drag coefficient of the vehicle (valid only for the first engine).
/* Cached NewGRF values, recalculated on load and each time a vehicle is added to/removed from the consist. */
uint16 cached_total_length; ///< Length of the whole vehicle (valid only for the first engine).
EngineID first_engine; ///< Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
uint8 cached_veh_length; ///< Length of this vehicle in units of 1/8 of normal length. It is cached because this can be set by a callback.
};
/** Ground vehicle flags. */

21
src/newgrf_engine.cpp
View File

@ -439,10 +439,8 @@ static uint8 LiveryHelper(EngineID engine, const Vehicle *v)
if (v == NULL) {
if (!Company::IsValidID(_current_company)) return 0;
l = GetEngineLivery(engine, _current_company, INVALID_ENGINE, NULL, LIT_ALL);
} else if (v->type == VEH_TRAIN) {
l = GetEngineLivery(v->engine_type, v->owner, Train::From(v)->tcache.first_engine, v, LIT_ALL);
} else if (v->type == VEH_ROAD) {
l = GetEngineLivery(v->engine_type, v->owner, RoadVehicle::From(v)->rcache.first_engine, v, LIT_ALL);
} else if (v->IsGroundVehicle()) {
l = GetEngineLivery(v->engine_type, v->owner, v->GetGroundVehicleCache()->first_engine, v, LIT_ALL);
} else {
l = GetEngineLivery(v->engine_type, v->owner, INVALID_ENGINE, v, LIT_ALL);
}
@ -794,7 +792,7 @@ static uint32 VehicleGetVariable(const ResolverObject *object, byte variable, by
switch (variable - 0x80) {
case 0x62: return t->track;
case 0x66: return t->railtype;
case 0x73: return t->tcache.cached_veh_length;
case 0x73: return t->gcache.cached_veh_length;
case 0x74: return t->gcache.cached_power;
case 0x75: return GB(t->gcache.cached_power, 8, 24);
case 0x76: return GB(t->gcache.cached_power, 16, 16);
@ -909,14 +907,15 @@ static const SpriteGroup *GetVehicleSpriteGroup(EngineID engine, const Vehicle *
} else {
cargo = v->cargo_type;
if (v->type == VEH_TRAIN) {
/* We always use cached value, except for callbacks because the override spriteset
if (v->IsGroundVehicle()) {
/* For trains we always use cached value, except for callbacks because the override spriteset
* to use may be different than the one cached. It happens for callback 0x15 (refit engine),
* as v->cargo_type is temporary changed to the new type */
group = use_cache ? Train::From(v)->tcache.cached_override : GetWagonOverrideSpriteSet(v->engine_type, v->cargo_type, Train::From(v)->tcache.first_engine);
if (group != NULL) return group;
} else if (v->type == VEH_ROAD) {
group = GetWagonOverrideSpriteSet(v->engine_type, v->cargo_type, RoadVehicle::From(v)->rcache.first_engine);
if (use_cache && v->type == VEH_TRAIN) {
group = Train::From(v)->tcache.cached_override;
} else {
group = GetWagonOverrideSpriteSet(v->engine_type, v->cargo_type, v->GetGroundVehicleCache()->first_engine);
}
if (group != NULL) return group;
}
}

6
src/openttd.cpp
View File

@ -1145,7 +1145,6 @@ static void CheckCaches()
VehicleCache *veh_cache = CallocT<VehicleCache>(length);
GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length);
TrainCache *tra_cache = CallocT<TrainCache>(length);
RoadVehicleCache *roa_cache = CallocT<RoadVehicleCache>(length);
length = 0;
for (const Vehicle *u = v; u != NULL; u = u->Next()) {
@ -1159,7 +1158,6 @@ static void CheckCaches()
break;
case VEH_ROAD:
gro_cache[length] = RoadVehicle::From(u)->gcache;
roa_cache[length] = RoadVehicle::From(u)->rcache;
break;
default:
break;
@ -1197,9 +1195,6 @@ static void CheckCaches()
if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
DEBUG(desync, 2, "road vehicle ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
}
if (memcmp(&roa_cache[length], &RoadVehicle::From(u)->rcache, sizeof(RoadVehicleCache)) != 0) {
DEBUG(desync, 2, "road vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
}
break;
default:
break;
@ -1211,7 +1206,6 @@ static void CheckCaches()
free(veh_cache);
free(gro_cache);
free(tra_cache);
free(roa_cache);
}
/* Check whether the caches are still valid */

4
src/pathfinder/yapf/yapf_costrail.hpp
View File

@ -258,8 +258,8 @@ public:
const Train *v = Yapf().GetVehicle();
assert(v != NULL);
assert(v->type == VEH_TRAIN);
assert(v->tcache.cached_total_length != 0);
int missing_platform_length = CeilDiv(v->tcache.cached_total_length, TILE_SIZE) - platform_length;
assert(v->gcache.cached_total_length != 0);
int missing_platform_length = CeilDiv(v->gcache.cached_total_length, TILE_SIZE) - platform_length;
if (missing_platform_length < 0) {
/* apply penalty for longer platform than needed */
cost += Yapf().PfGetSettings().rail_longer_platform_penalty + Yapf().PfGetSettings().rail_longer_platform_per_tile_penalty * -missing_platform_length;

4
src/rail_cmd.cpp
View File

@ -2698,7 +2698,7 @@ static const int8 _deltacoord_leaveoffset[8] = {
int TicksToLeaveDepot(const Train *v)
{
DiagDirection dir = GetRailDepotDirection(v->tile);
int length = v->tcache.cached_veh_length;
int length = v->gcache.cached_veh_length;
switch (dir) {
case DIAGDIR_NE: return ((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) - (length + 1)));
@ -2727,7 +2727,7 @@ static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int
/* calculate the point where the following wagon should be activated
* this depends on the length of the current vehicle */
int length = v->tcache.cached_veh_length;
int length = v->gcache.cached_veh_length;
byte fract_coord_leave =
((_fractcoords_enter[dir] & 0x0F) + // x

6
src/roadstop.cpp
View File

@ -278,7 +278,7 @@ bool RoadStop::Enter(RoadVehicle *rv)
*/
void RoadStop::Entry::Leave(const RoadVehicle *rv)
{
this->occupied -= rv->rcache.cached_total_length;
this->occupied -= rv->gcache.cached_total_length;
assert(this->occupied >= 0);
}
@ -291,7 +291,7 @@ void RoadStop::Entry::Enter(const RoadVehicle *rv)
/* we cannot assert on this->occupied < this->length because of the
* remote possibility that RVs are running through eachother when
* trying to prevention an infinite jam. */
this->occupied += rv->rcache.cached_total_length;
this->occupied += rv->gcache.cached_total_length;
}
/**
@ -367,7 +367,7 @@ void RoadStop::Entry::Rebuild(const RoadStop *rs, int side)
this->occupied = 0;
for (RVList::iterator it = rserh.vehicles.begin(); it != rserh.vehicles.end(); it++) {
this->occupied += (*it)->rcache.cached_total_length;
this->occupied += (*it)->gcache.cached_total_length;
}
}

8
src/roadveh.h
View File

@ -83,18 +83,10 @@ enum RoadVehicleSubType {
void RoadVehUpdateCache(RoadVehicle *v);
/** Cached oftenly queried (NewGRF) values */
struct RoadVehicleCache {
uint16 cached_total_length; ///< Length of the whole train, valid only for first engine.
byte cached_veh_length; ///< length of this vehicle in units of 1/8 of normal length, cached because this can be set by a callback
EngineID first_engine; ///< Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
};
/**
* Buses, trucks and trams belong to this class.
*/
struct RoadVehicle : public GroundVehicle<RoadVehicle, VEH_ROAD> {
RoadVehicleCache rcache; ///< Cache of often used calculated values
byte state; ///< @see RoadVehicleStates
byte frame;
uint16 blocked_ctr;

16
src/roadveh_cmd.cpp
View File

@ -102,7 +102,7 @@ int RoadVehicle::GetDisplayImageWidth(Point *offset) const
offset->x = reference_width / 2;
offset->y = 0;
}
return this->rcache.cached_veh_length * reference_width / 8;
return this->gcache.cached_veh_length * reference_width / 8;
}
static SpriteID GetRoadVehIcon(EngineID engine)
@ -175,18 +175,18 @@ void RoadVehUpdateCache(RoadVehicle *v)
v->InvalidateNewGRFCacheOfChain();
v->rcache.cached_total_length = 0;
v->gcache.cached_total_length = 0;
for (RoadVehicle *u = v; u != NULL; u = u->Next()) {
/* Check the v->first cache. */
assert(u->First() == v);
/* Update the 'first engine' */
u->rcache.first_engine = (v == u) ? INVALID_ENGINE : v->engine_type;
u->gcache.first_engine = (v == u) ? INVALID_ENGINE : v->engine_type;
/* Update the length of the vehicle. */
u->rcache.cached_veh_length = GetRoadVehLength(u);
v->rcache.cached_total_length += u->rcache.cached_veh_length;
u->gcache.cached_veh_length = GetRoadVehLength(u);
v->gcache.cached_total_length += u->gcache.cached_veh_length;
/* Update visual effect */
v->UpdateVisualEffect();
@ -236,7 +236,7 @@ CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engin
v->last_station_visited = INVALID_STATION;
v->engine_type = e->index;
v->rcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
v->gcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
v->reliability = e->reliability;
v->reliability_spd_dec = e->reliability_spd_dec;
@ -254,7 +254,7 @@ CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engin
v->roadtype = HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
v->compatible_roadtypes = RoadTypeToRoadTypes(v->roadtype);
v->rcache.cached_veh_length = 8;
v->gcache.cached_veh_length = 8;
if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
@ -1317,7 +1317,7 @@ again:
* it's on a depot tile, check if it's time to activate the next vehicle in
* the chain yet. */
if (v->Next() != NULL && IsRoadDepotTile(v->tile)) {
if (v->frame == v->rcache.cached_veh_length + RVC_DEPOT_START_FRAME) {
if (v->frame == v->gcache.cached_veh_length + RVC_DEPOT_START_FRAME) {
RoadVehLeaveDepot(v->Next(), false);
}
}

3
src/saveload/vehicle_sl.cpp
View File

@ -251,8 +251,7 @@ void AfterLoadVehicles(bool part_of_load)
if (part_of_load) v->fill_percent_te_id = INVALID_TE_ID;
v->first = NULL;
if (v->type == VEH_TRAIN) Train::From(v)->tcache.first_engine = INVALID_ENGINE;
if (v->type == VEH_ROAD) RoadVehicle::From(v)->rcache.first_engine = INVALID_ENGINE;
if (v->IsGroundVehicle()) v->GetGroundVehicleCache()->first_engine = INVALID_ENGINE;
}
/* AfterLoadVehicles may also be called in case of NewGRF reload, in this

12
src/train.h
View File

@ -68,16 +68,12 @@ struct TrainCache {
uint16 last_speed; // NOSAVE: only used in UI
/* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
uint16 cached_total_length; ///< Length of the whole train, valid only for first engine.
uint8 cached_veh_length; ///< length of this vehicle in units of 1/8 of normal length, cached because this can be set by a callback
bool cached_tilt; ///< train can tilt; feature provides a bonus in curves
byte user_def_data; ///< Cached property 0x25. Can be set by Callback 0x36.
/* cached max. speed / acceleration data */
int cached_max_curve_speed; ///< max consist speed limited by curves
byte user_def_data;
EngineID first_engine; ///< cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
};
/**
@ -387,7 +383,7 @@ protected: // These functions should not be called outside acceleration code.
{
/* For powered wagons the engine defines the type of engine (i.e. railtype) */
if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {
return RailVehInfo(this->tcache.first_engine)->pow_wag_power;
return RailVehInfo(this->gcache.first_engine)->pow_wag_power;
}
return 0;
@ -408,7 +404,7 @@ protected: // These functions should not be called outside acceleration code.
/* Powered wagons have extra weight added. */
if (HasBit(this->flags, VRF_POWEREDWAGON)) {
weight += RailVehInfo(this->tcache.first_engine)->pow_wag_weight;
weight += RailVehInfo(this->gcache.first_engine)->pow_wag_weight;
}
return weight;

40
src/train_cmd.cpp
View File

@ -110,7 +110,7 @@ void CheckTrainsLengths()
for (const Train *u = v, *w = v->Next(); w != NULL; u = w, w = w->Next()) {
if (u->track != TRACK_BIT_DEPOT) {
if ((w->track != TRACK_BIT_DEPOT &&
max(abs(u->x_pos - w->x_pos), abs(u->y_pos - w->y_pos)) != u->tcache.cached_veh_length) ||
max(abs(u->x_pos - w->x_pos), abs(u->y_pos - w->y_pos)) != u->gcache.cached_veh_length) ||
(w->track == TRACK_BIT_DEPOT && TicksToLeaveDepot(u) <= 0)) {
SetDParam(0, v->index);
SetDParam(1, v->owner);
@ -152,7 +152,7 @@ void Train::ConsistChanged(bool same_length)
const RailVehicleInfo *rvi_v = RailVehInfo(this->engine_type);
EngineID first_engine = this->IsFrontEngine() ? this->engine_type : INVALID_ENGINE;
this->tcache.cached_total_length = 0;
this->gcache.cached_total_length = 0;
this->compatible_railtypes = RAILTYPES_NONE;
bool train_can_tilt = true;
@ -164,7 +164,7 @@ void Train::ConsistChanged(bool same_length)
assert(u->First() == this);
/* update the 'first engine' */
u->tcache.first_engine = this == u ? INVALID_ENGINE : first_engine;
u->gcache.first_engine = this == u ? INVALID_ENGINE : first_engine;
u->railtype = rvi_u->railtype;
if (u->IsEngine()) first_engine = u->engine_type;
@ -189,7 +189,7 @@ void Train::ConsistChanged(bool same_length)
if (!HasBit(e_u->info.misc_flags, EF_RAIL_TILTS)) train_can_tilt = false;
/* Cache wagon override sprite group. NULL is returned if there is none */
u->tcache.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->tcache.first_engine);
u->tcache.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->gcache.first_engine);
/* Reset colour map */
u->colourmap = PAL_NONE;
@ -237,12 +237,12 @@ void Train::ConsistChanged(bool same_length)
veh_len = 8 - Clamp(veh_len, 0, 7);
/* verify length hasn't changed */
if (same_length && veh_len != u->tcache.cached_veh_length) RailVehicleLengthChanged(u);
if (same_length && veh_len != u->gcache.cached_veh_length) RailVehicleLengthChanged(u);
/* update vehicle length? */
if (!same_length) u->tcache.cached_veh_length = veh_len;
if (!same_length) u->gcache.cached_veh_length = veh_len;
this->tcache.cached_total_length += u->tcache.cached_veh_length;
this->gcache.cached_total_length += u->gcache.cached_veh_length;
this->InvalidateNewGRFCache();
u->InvalidateNewGRFCache();
}
@ -281,7 +281,7 @@ int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, i
/* Default to the middle of the station for stations stops that are not in
* the order list like intermediate stations when non-stop is disabled */
OrderStopLocation osl = OSL_PLATFORM_MIDDLE;
if (v->tcache.cached_total_length >= *station_length) {
if (v->gcache.cached_total_length >= *station_length) {
/* The train is longer than the station, make it stop at the far end of the platform */
osl = OSL_PLATFORM_FAR_END;
} else if (v->current_order.IsType(OT_GOTO_STATION) && v->current_order.GetDestination() == station_id) {
@ -294,11 +294,11 @@ int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, i
default: NOT_REACHED();
case OSL_PLATFORM_NEAR_END:
stop = v->tcache.cached_total_length;
stop = v->gcache.cached_total_length;
break;
case OSL_PLATFORM_MIDDLE:
stop = *station_length - (*station_length - v->tcache.cached_total_length) / 2;
stop = *station_length - (*station_length - v->gcache.cached_total_length) / 2;
break;
case OSL_PLATFORM_FAR_END:
@ -308,7 +308,7 @@ int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, i
/* Subtract half the front vehicle length of the train so we get the real
* stop location of the train. */
return stop - (v->tcache.cached_veh_length + 1) / 2;
return stop - (v->gcache.cached_veh_length + 1) / 2;
}
@ -455,7 +455,7 @@ int Train::GetDisplayImageWidth(Point *offset) const
offset->x = reference_width / 2;
offset->y = vehicle_pitch;
}
return this->tcache.cached_veh_length * reference_width / 8;
return this->gcache.cached_veh_length * reference_width / 8;
}
static SpriteID GetDefaultTrainSprite(uint8 spritenum, Direction direction)
@ -551,7 +551,7 @@ static CommandCost CmdBuildRailWagon(TileIndex tile, DoCommandFlag flags, const
v->spritenum = rvi->image_index;
v->engine_type = e->index;
v->tcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
v->gcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
DiagDirection dir = GetRailDepotDirection(tile);
@ -697,7 +697,7 @@ CommandCost CmdBuildRailVehicle(TileIndex tile, DoCommandFlag flags, const Engin
v->last_station_visited = INVALID_STATION;
v->engine_type = e->index;
v->tcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
v->gcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
v->reliability = e->reliability;
v->reliability_spd_dec = e->reliability_spd_dec;
@ -963,8 +963,8 @@ static CommandCost CheckTrainAttachment(Train *t)
allowed_len--; // We do not count articulated parts and rear heads either.
/* Back up and clear the first_engine data to avoid using wagon override group */
EngineID first_engine = t->tcache.first_engine;
t->tcache.first_engine = INVALID_ENGINE;
EngineID first_engine = t->gcache.first_engine;
t->gcache.first_engine = INVALID_ENGINE;
/* We don't want the cache to interfere. head's cache is cleared before
* the loop and after each callback does not need to be cleared here. */
@ -973,7 +973,7 @@ static CommandCost CheckTrainAttachment(Train *t)
uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, head->engine_type, t, head);
/* Restore original first_engine data */
t->tcache.first_engine = first_engine;
t->gcache.first_engine = first_engine;
/* We do not want to remember any cached variables from the test run */
t->InvalidateNewGRFCache();
@ -1599,7 +1599,7 @@ static void AdvanceWagonsBeforeSwap(Train *v)
last = last->Previous();
first = first->Next();
int differential = base->tcache.cached_veh_length - last->tcache.cached_veh_length;
int differential = base->gcache.cached_veh_length - last->gcache.cached_veh_length;
/* do not update images now
* negative differential will be handled in AdvanceWagonsAfterSwap() */
@ -1659,7 +1659,7 @@ static void AdvanceWagonsAfterSwap(Train *v)
last = last->Previous();
first = first->Next();
int differential = last->tcache.cached_veh_length - base->tcache.cached_veh_length;
int differential = last->gcache.cached_veh_length - base->gcache.cached_veh_length;
/* do not update images now */
for (int i = 0; i < differential; i++) TrainController(first, (nomove ? last->Next() : NULL));
@ -3387,7 +3387,7 @@ static bool TrainApproachingLineEnd(Train *v, bool signal)
}
/* do not reverse when approaching red signal */
if (!signal && x + (v->tcache.cached_veh_length + 1) / 2 >= TILE_SIZE) {
if (!signal && x + (v->gcache.cached_veh_length + 1) / 2 >= TILE_SIZE) {
/* we are too near the tile end, reverse now */
v->cur_speed = 0;
ReverseTrainDirection(v);

6
src/vehicle.cpp
View File

@ -1665,10 +1665,8 @@ PaletteID GetEnginePalette(EngineID engine_type, CompanyID company)
PaletteID GetVehiclePalette(const Vehicle *v)
{
if (v->type == VEH_TRAIN) {
return GetEngineColourMap(v->engine_type, v->owner, Train::From(v)->tcache.first_engine, v);
} else if (v->type == VEH_ROAD) {
return GetEngineColourMap(v->engine_type, v->owner, RoadVehicle::From(v)->rcache.first_engine, v);
if (v->IsGroundVehicle()) {
return GetEngineColourMap(v->engine_type, v->owner, v->GetGroundVehicleCache()->first_engine, v);
}
return GetEngineColourMap(v->engine_type, v->owner, INVALID_ENGINE, v);

14
src/vehicle_gui.cpp
View File

@ -847,19 +847,7 @@ static int CDECL VehicleValueSorter(const Vehicle * const *a, const Vehicle * co
/** Sort vehicles by their length */
static int CDECL VehicleLengthSorter(const Vehicle * const *a, const Vehicle * const *b)
{
int r = 0;
switch ((*a)->type) {
case VEH_TRAIN:
r = Train::From(*a)->tcache.cached_total_length - Train::From(*b)->tcache.cached_total_length;
break;
case VEH_ROAD: {
r = RoadVehicle::From(*a)->rcache.cached_total_length - RoadVehicle::From(*b)->rcache.cached_total_length;
break;
}
default: NOT_REACHED();
}
int r = (*a)->GetGroundVehicleCache()->cached_total_length - (*b)->GetGroundVehicleCache()->cached_total_length;
return (r != 0) ? r : VehicleNumberSorter(a, b);
}