45   e->overrides = 
ReallocT(e->overrides, e->overrides_count);
 
   47   wo = &e->overrides[e->overrides_count - 1];
 
   51   wo->train_id = MallocT<EngineID>(trains);
 
   52   memcpy(wo->train_id, train_id, trains * 
sizeof *train_id);
 
   59   for (uint i = 0; i < e->overrides_count; i++) {
 
   62     if (wo->cargo != cargo && wo->cargo != CT_DEFAULT) 
continue;
 
   64     for (uint j = 0; j < wo->trains; j++) {
 
   65       if (wo->train_id[j] == overriding_engine) 
return wo->group;
 
   76   for (uint i = 0; i < e->overrides_count; i++) {
 
   81   e->overrides_count = 0;
 
   92     grfmsg(6, 
"SetCustomEngineSprites: engine %d cargo %d already has group -- replacing", engine, cargo);
 
  111 static int MapOldSubType(
const Vehicle *v)
 
  123     default: NOT_REACHED();
 
  129 enum TTDPAircraftMovementStates {
 
  135   AMS_TTDP_TO_ENTRY_2_AND_3,
 
  136   AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,
 
  137   AMS_TTDP_TO_JUNCTION,
 
  138   AMS_TTDP_LEAVE_RUNWAY,
 
  146   AMS_TTDP_FLIGHT_APPROACH,
 
  147   AMS_TTDP_UNUSED_0x11,
 
  148   AMS_TTDP_FLIGHT_TO_TOWER,
 
  149   AMS_TTDP_UNUSED_0x13,
 
  150   AMS_TTDP_FLIGHT_FINAL,
 
  151   AMS_TTDP_FLIGHT_DESCENT,
 
  153   AMS_TTDP_HELI_TAKEOFF_AIRPORT,
 
  154   AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,
 
  155   AMS_TTDP_HELI_LAND_AIRPORT,
 
  156   AMS_TTDP_HELI_TAKEOFF_HELIPORT,
 
  157   AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,
 
  158   AMS_TTDP_HELI_LAND_HELIPORT,
 
  169   if (st == NULL) 
return AMS_TTDP_FLIGHT_TO_TOWER;
 
  186       if (amdflag & 
AMED_SLOWTURN) 
return AMS_TTDP_FLIGHT_TO_TOWER;
 
  193       return AMS_TTDP_TO_HANGAR;
 
  196       if (amdflag & AMED_EXACTPOS) 
return AMS_TTDP_TO_PAD1;
 
  197       return AMS_TTDP_TO_JUNCTION;
 
  200       if (amdflag & AMED_EXACTPOS) 
return AMS_TTDP_TO_PAD2;
 
  201       return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;
 
  210       if (amdflag & AMED_EXACTPOS) 
return AMS_TTDP_TO_PAD3;
 
  211       return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;
 
  217       if (amdflag & AMED_HELI_LOWER) 
return AMS_TTDP_HELI_LAND_AIRPORT; 
 
  218       if (amdflag & AMED_SLOWTURN)   
return AMS_TTDP_FLIGHT_TO_TOWER;   
 
  219       return AMS_TTDP_TO_JUNCTION; 
 
  222       return AMS_TTDP_TO_OUTWAY;
 
  225       return AMS_TTDP_TAKEOFF;
 
  228       return AMS_TTDP_CLIMBING;
 
  233           AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;
 
  235         return AMS_TTDP_HELI_TAKEOFF_HELIPORT;
 
  239       return amdflag & 
AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;
 
  242       return AMS_TTDP_FLIGHT_DESCENT;
 
  245       if (amdflag & 
AMED_BRAKE) 
return AMS_TTDP_BRAKING;
 
  247       return AMS_TTDP_TO_INWAY;
 
  251       if (amdflag & AMED_HELI_LOWER) {
 
  253           AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;
 
  255         return AMS_TTDP_FLIGHT_TO_TOWER;
 
  259       return AMS_TTDP_HANGAR;
 
  265 enum TTDPAircraftMovementActions {
 
  270   AMA_TTDP_HANGAR_TO_PAD1,
 
  271   AMA_TTDP_HANGAR_TO_PAD2,
 
  272   AMA_TTDP_HANGAR_TO_PAD3,
 
  273   AMA_TTDP_LANDING_TO_PAD1,
 
  274   AMA_TTDP_LANDING_TO_PAD2,
 
  275   AMA_TTDP_LANDING_TO_PAD3,
 
  276   AMA_TTDP_PAD1_TO_HANGAR,
 
  277   AMA_TTDP_PAD2_TO_HANGAR,
 
  278   AMA_TTDP_PAD3_TO_HANGAR,
 
  279   AMA_TTDP_PAD1_TO_TAKEOFF,
 
  280   AMA_TTDP_PAD2_TO_TAKEOFF,
 
  281   AMA_TTDP_PAD3_TO_TAKEOFF,
 
  282   AMA_TTDP_HANGAR_TO_TAKOFF,
 
  283   AMA_TTDP_LANDING_TO_HANGAR,
 
  297       return (v->
cur_speed > 0) ? AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_IN_HANGAR;
 
  301       return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD1 : AMA_TTDP_LANDING_TO_PAD1;
 
  305       return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD2 : AMA_TTDP_LANDING_TO_PAD2;
 
  314       return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD3 : AMA_TTDP_LANDING_TO_PAD3;
 
  321       return AMA_TTDP_PAD1_TO_TAKEOFF;
 
  324       return AMA_TTDP_IN_FLIGHT;
 
  332         AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;
 
  335       return AMA_TTDP_IN_HANGAR;
 
  360   assert(this->
ro.trigger != 0);
 
  372       int32 count = 
GB(relative, 0, 4);
 
  373       if (this->
self_scope.
v != NULL && (relative != this->cached_relative_count || count == 0)) {
 
  379         switch (
GB(relative, 6, 2)) {
 
  380           default: NOT_REACHED();
 
  394               if (u->engine_type != self->engine_type) {
 
  397                 if (v == NULL) v = u;
 
  400             if (v == NULL) v = 
self;
 
  447   byte chain_before = 0;
 
  448   byte chain_after  = 0;
 
  450   for (u = v->
First(); u != v; u = u->
Next()) {
 
  460   return chain_before | chain_after << 8 | (chain_before + chain_after + consecutive) << 16;
 
  487         byte cargo_classes = 0;
 
  489         uint8 common_subtypes[256];
 
  490         byte user_def_data = 0;
 
  492         uint8 common_subtype = 0xFF; 
 
  495         memset(common_cargoes, 0, 
sizeof(common_cargoes));
 
  496         memset(common_subtypes, 0, 
sizeof(common_subtypes));
 
  498         for (u = v; u != NULL; u = u->
Next()) {
 
  509         uint common_cargo_best_amount = 0;
 
  511           if (common_cargoes[cargo] > common_cargo_best_amount) {
 
  512             common_cargo_best_amount = common_cargoes[cargo];
 
  513             common_cargo_type = cargo;
 
  518         for (u = v; u != NULL; u = u->
Next()) {
 
  526         uint common_subtype_best_amount = 0;
 
  527         for (uint i = 0; i < 
lengthof(common_subtypes); i++) {
 
  528           if (common_subtypes[i] > common_subtype_best_amount) {
 
  529             common_subtype_best_amount = common_subtypes[i];
 
  551       const GRFFile *grffile = 
object->ro.grffile;
 
  552       uint8 common_bitnum = (common_cargo_type == 
CT_INVALID) ? 0xFF :
 
  579         return (
Clamp(altitude, 0, 0xFF) << 8) | airporttype;
 
  639         byte artic_before = 0;
 
  641         byte artic_after = 0;
 
  654         for (; v != NULL; v = v->
Next()) {
 
  671         if (u == NULL) 
return 0; 
 
  673         if (parameter == 0x5F) {
 
  677           return VehicleGetVariable(u, 
object, parameter, 
GetRegister(0x10E), available);
 
  694       if (u == NULL) 
return 0;
 
  697       bool prev = (int8)parameter < 0;
 
  718         const Train *u = is_powered_wagon ? t->
First() : t; 
 
  720         bool powered = t->
IsEngine() || is_powered_wagon;
 
  723         if (powered && has_power) 
SetBit(modflags, 5);
 
  724         if (powered && !has_power) 
SetBit(modflags, 6);
 
  730       return variable == 0xFE ? modflags : 
GB(modflags, 8, 8);
 
  735   switch (variable - 0x80) {
 
  736     case 0x00: 
return v->
type + 0x10;
 
  737     case 0x01: 
return MapOldSubType(v);
 
  738     case 0x04: 
return v->
index;
 
  739     case 0x05: 
return GB(v->
index, 8, 8);
 
  753           default:           ticks = 0; 
break;
 
  756       return (variable - 0x80) == 0x10 ? ticks : 
GB(ticks, 8, 8);
 
  760     case 0x14: 
return v->GetServiceInterval();
 
  761     case 0x15: 
return GB(v->GetServiceInterval(), 8, 8);
 
  776       return (variable - 0x80) == 0x18 ? max_speed : 
GB(max_speed, 8, 8);
 
  778     case 0x1A: 
return v->
x_pos;
 
  779     case 0x1B: 
return GB(v->
x_pos, 8, 8);
 
  780     case 0x1C: 
return v->
y_pos;
 
  781     case 0x1D: 
return GB(v->
y_pos, 8, 8);
 
  782     case 0x1E: 
return v->
z_pos;
 
  842       switch (variable - 0x80) {
 
  843         case 0x62: 
return t->track;
 
  844         case 0x66: 
return t->railtype;
 
  859       switch (variable - 0x80) {
 
  860         case 0x62: 
return rv->
state;
 
  861         case 0x64: 
return rv->blocked_ctr;
 
  862         case 0x65: 
return GB(rv->blocked_ctr, 8, 8);
 
  873       switch (variable - 0x80) {
 
  874         case 0x62: 
return s->
state;
 
  881       switch (variable - 0x80) {
 
  892   DEBUG(grf, 1, 
"Unhandled vehicle variable 0x%X, type 0x%X", variable, (uint)v->
type);
 
  900   if (this->v == NULL) {
 
  917       case 0x4B: 
return _date; 
 
  929   return VehicleGetVariable(const_cast<Vehicle*>(this->v), 
this, variable, parameter, available);
 
  947   if (totalsets == 0) 
return NULL;
 
  950   set = 
min(
set, totalsets - 1);
 
  978   return (e != NULL) ? e->
GetGRF() : NULL;
 
  992     CallbackID callback, uint32 callback_param1, uint32 callback_param2)
 
  994   self_scope(*this, engine_type, v, info_view),
 
  995   parent_scope(*this, engine_type, ((v != NULL) ? v->First() : v), info_view),
 
  996   relative_scope(*this, engine_type, v, info_view),
 
  997   cached_relative_count(0)
 
  999   if (wagon_override == 
WO_SELF) {
 
 1000     this->
root_spritegroup = GetWagonOverrideSpriteSet(engine_type, CT_DEFAULT, engine_type);
 
 1032   uint max_stack = sprite_stack ? 
lengthof(result->seq) : 1;
 
 1033   for (uint stack = 0; stack < max_stack; ++stack) {
 
 1034     object.ResetState();
 
 1035     object.callback_param1 = image_type | (stack << 8);
 
 1037     uint32 reg100 = sprite_stack ? 
GetRegister(0x100) : 0;
 
 1038     if (group != NULL && group->GetNumResults() != 0) {
 
 1039       result->seq[result->count].
sprite = group->GetResult() + (direction % group->GetNumResults());
 
 1040       result->seq[result->count].
pal    = 
GB(reg100, 0, 16); 
 
 1043     if (!
HasBit(reg100, 31)) 
break;
 
 1058   uint rotor_pos = v == NULL || info_view ? 0 : v->
Next()->
Next()->
state;
 
 1061   uint max_stack = sprite_stack ? 
lengthof(result->seq) : 1;
 
 1062   for (uint stack = 0; stack < max_stack; ++stack) {
 
 1063     object.ResetState();
 
 1064     object.callback_param1 = image_type | (stack << 8);
 
 1066     uint32 reg100 = sprite_stack ? 
GetRegister(0x100) : 0;
 
 1067     if (group != NULL && group->GetNumResults() != 0) {
 
 1068       result->seq[result->count].
sprite = group->GetResult() + (rotor_pos % group->GetNumResults());
 
 1069       result->seq[result->count].
pal    = 
GB(reg100, 0, 16); 
 
 1072     if (!
HasBit(reg100, 31)) 
break;
 
 1085   return Train::From(v)->tcache.cached_override != NULL;
 
 1100   return object.ResolveCallback();
 
 1116   object.parent_scope.SetVehicle(parent);
 
 1117   return object.ResolveCallback();
 
 1124   return GetEngineProperty(v->
engine_type, property, orig_value, v);
 
 1137 static void DoTriggerVehicle(
Vehicle *v, VehicleTrigger trigger, byte base_random_bits, 
bool first)
 
 1143   object.trigger = trigger;
 
 1146   if (group == NULL) 
return;
 
 1148   byte new_random_bits = Random();
 
 1149   uint32 reseed = 
object.GetReseedSum(); 
 
 1151   v->
random_bits |= (first ? new_random_bits : base_random_bits) & reseed;
 
 1154     case VEHICLE_TRIGGER_NEW_CARGO:
 
 1163       DoTriggerVehicle(v->
First(), VEHICLE_TRIGGER_ANY_NEW_CARGO, new_random_bits, 
false);
 
 1166     case VEHICLE_TRIGGER_DEPOT:
 
 1170       if (v->
Next() != NULL) DoTriggerVehicle(v->
Next(), trigger, 0, 
true);
 
 1173     case VEHICLE_TRIGGER_EMPTY:
 
 1178       if (v->
Next() != NULL) DoTriggerVehicle(v->
Next(), trigger, first ? new_random_bits : base_random_bits, 
false);
 
 1181     case VEHICLE_TRIGGER_ANY_NEW_CARGO:
 
 1185       if (v->
Next() != NULL) DoTriggerVehicle(v->
Next(), VEHICLE_TRIGGER_ANY_NEW_CARGO, base_random_bits, 
false);
 
 1188     case VEHICLE_TRIGGER_CALLBACK_32:
 
 1194 void TriggerVehicle(
Vehicle *v, VehicleTrigger trigger)
 
 1196   if (trigger == VEHICLE_TRIGGER_DEPOT) {
 
 1202   DoTriggerVehicle(v, trigger, 0, 
true);
 
 1225   loc->engine = engine;
 
 1258   FOR_ALL_ENGINES(e) {
 
 1267     uint local_target = it->target;
 
 1270     if (id_source->
internal_id == local_target) 
continue;
 
 1275     int source_index = ordering.
FindIndex(source);
 
 1276     int target_index = ordering.
FindIndex(target);
 
 1278     assert(source_index >= 0 && target_index >= 0);
 
 1279     assert(source_index != target_index);
 
 1282     if (source_index < target_index) {
 
 1284       for (
int i = source_index; i < target_index; ++i) list[i] = list[i + 1];
 
 1285       list[target_index] = source;
 
 1287       for (
int i = source_index; i > target_index; --i) list[i] = list[i - 1];
 
 1288       list[target_index] = source;
 
 1295   for (
const EngineID *it = ordering.
Begin(); it != idend; ++it, ++index) {
 
 1300   _list_order_changes.
Reset();
 
 1312   static const int cache_entries[][2] = {
 
 1322   for (
size_t i = 0; i < 
lengthof(cache_entries); i++) {