tron@2186: /* $Id$ */ tron@2186: rubidium@9111: /** @file vehicle.cpp Base implementations of all vehicles. */ belugas@6423: truelight@0: #include "stdafx.h" Darkvater@1891: #include "openttd.h" tron@3957: #include "road_map.h" tron@3959: #include "roadveh.h" tron@3961: #include "ship.h" tron@1349: #include "spritecache.h" rubidium@8119: #include "tile_cmd.h" maedhros@6453: #include "landscape.h" maedhros@6980: #include "timetable.h" rubidium@8224: #include "viewport_func.h" rubidium@8224: #include "gfx_func.h" rubidium@8763: #include "news_func.h" rubidium@8116: #include "command_func.h" truelight@0: #include "saveload.h" rubidium@8254: #include "player_func.h" celestar@1601: #include "debug.h" matthijs@1752: #include "vehicle_gui.h" rubidium@8103: #include "rail_type.h" bjarni@2676: #include "train.h" bjarni@4662: #include "aircraft.h" peter1138@3428: #include "industry_map.h" celestar@3404: #include "station_map.h" tron@3957: #include "water_map.h" rubidium@5469: #include "network/network.h" KUDr@4130: #include "yapf/yapf.h" peter1138@5717: #include "newgrf_callbacks.h" peter1138@4603: #include "newgrf_engine.h" peter1138@4656: #include "newgrf_sound.h" peter1138@9041: #include "newgrf_station.h" rubidium@6643: #include "group.h" rubidium@8784: #include "order_func.h" rubidium@8114: #include "strings_func.h" rubidium@8123: #include "zoom_func.h" rubidium@8131: #include "functions.h" rubidium@8140: #include "date_func.h" rubidium@8131: #include "window_func.h" rubidium@8144: #include "vehicle_func.h" smatz@8238: #include "signal_func.h" rubidium@8157: #include "sound_func.h" rubidium@8211: #include "variables.h" rubidium@8212: #include "autoreplace_func.h" rubidium@8212: #include "autoreplace_gui.h" rubidium@8214: #include "string_func.h" rubidium@8270: #include "settings_type.h" smatz@8847: #include "oldpool_func.h" rubidium@8962: #include "depot_map.h" rubidium@9005: #include "animated_tile_func.h" rubidium@9009: #include "effectvehicle_base.h" peter1138@9348: #include "core/alloc_func.hpp" truelight@0: rubidium@8264: #include "table/sprites.h" rubidium@8264: #include "table/strings.h" rubidium@8264: rubidium@6904: #define INVALID_COORD (0x7fffffff) tron@4174: #define GEN_HASH(x, y) ((GB((y), 6, 6) << 6) + GB((x), 7, 6)) truelight@0: rubidium@8144: VehicleID _vehicle_id_ctr_day; peter1138@9344: const Vehicle *_place_clicked_vehicle; rubidium@8144: VehicleID _new_vehicle_id; rubidium@8144: uint16 _returned_refit_capacity; rubidium@8144: bjarni@5792: bjarni@5792: /* Tables used in vehicle.h to find the right command for a certain vehicle type */ bjarni@5792: const uint32 _veh_build_proc_table[] = { bjarni@2552: CMD_BUILD_RAIL_VEHICLE, bjarni@2552: CMD_BUILD_ROAD_VEH, bjarni@2552: CMD_BUILD_SHIP, bjarni@2552: CMD_BUILD_AIRCRAFT, bjarni@2552: }; bjarni@5792: const uint32 _veh_sell_proc_table[] = { bjarni@2552: CMD_SELL_RAIL_WAGON, bjarni@2552: CMD_SELL_ROAD_VEH, bjarni@2552: CMD_SELL_SHIP, bjarni@2552: CMD_SELL_AIRCRAFT, bjarni@2552: }; tron@2753: bjarni@5792: const uint32 _veh_refit_proc_table[] = { bjarni@2552: CMD_REFIT_RAIL_VEHICLE, peter1138@3990: CMD_REFIT_ROAD_VEH, bjarni@2552: CMD_REFIT_SHIP, bjarni@2552: CMD_REFIT_AIRCRAFT, bjarni@2552: }; bjarni@2552: bjarni@4451: const uint32 _send_to_depot_proc_table[] = { Darkvater@4495: CMD_SEND_TRAIN_TO_DEPOT, bjarni@4451: CMD_SEND_ROADVEH_TO_DEPOT, bjarni@4451: CMD_SEND_SHIP_TO_DEPOT, bjarni@4451: CMD_SEND_AIRCRAFT_TO_HANGAR, bjarni@4451: }; bjarni@4451: bjarni@2552: truelight@1279: /* Initialize the vehicle-pool */ rubidium@7400: DEFINE_OLD_POOL_GENERIC(Vehicle, Vehicle) truelight@1279: bjarni@8629: /** Function to tell if a vehicle needs to be autorenewed bjarni@8629: * @param *p The vehicle owner bjarni@8629: * @return true if the vehicle is old enough for replacement bjarni@8629: */ bjarni@8629: bool Vehicle::NeedsAutorenewing(const Player *p) const bjarni@8629: { bjarni@8629: /* We can always generate the Player pointer when we have the vehicle. bjarni@8629: * However this takes time and since the Player pointer is often present bjarni@8629: * when this function is called then it's faster to pass the pointer as an bjarni@8629: * argument rather than finding it again. */ bjarni@8629: assert(p == GetPlayer(this->owner)); bjarni@8629: bjarni@8629: if (!p->engine_renew) return false; bjarni@8629: if (this->age - this->max_age < (p->engine_renew_months * 30)) return false; bjarni@8997: if (this->age == 0) return false; // rail cars don't age and lacks a max age bjarni@8629: bjarni@8629: return true; bjarni@8629: } bjarni@8629: bjarni@578: void VehicleServiceInDepot(Vehicle *v) bjarni@578: { bjarni@578: v->date_of_last_service = _date; bjarni@578: v->breakdowns_since_last_service = 0; tron@1926: v->reliability = GetEngine(v->engine_type)->reliability; bjarni@4725: InvalidateWindow(WC_VEHICLE_DETAILS, v->index); // ensure that last service date and reliability are updated bjarni@578: } truelight@0: frosch@8862: bool Vehicle::NeedsServicing() const tron@593: { frosch@8862: if (this->vehstatus & (VS_STOPPED | VS_CRASHED)) return false; matthijs@1757: bjarni@4262: if (_patches.no_servicing_if_no_breakdowns && _opt.diff.vehicle_breakdowns == 0) { frosch@8862: /* Vehicles set for autoreplacing needs to go to a depot even if breakdowns are turned off. frosch@8862: * Note: If servicing is enabled, we postpone replacement till next service. */ frosch@8862: return EngineHasReplacementForPlayer(GetPlayer(this->owner), this->engine_type, this->group_id); bjarni@4262: } bjarni@4262: truelight@812: return _patches.servint_ispercent ? frosch@8862: (this->reliability < GetEngine(this->engine_type)->reliability * (100 - this->service_interval) / 100) : frosch@8862: (this->date_of_last_service + this->service_interval < _date); frosch@8862: } frosch@8862: frosch@8862: bool Vehicle::NeedsAutomaticServicing() const frosch@8862: { frosch@8862: if (_patches.gotodepot && VehicleHasDepotOrders(this)) return false; frosch@8862: if (this->current_order.IsType(OT_LOADING)) return false; rubidium@8914: if (this->current_order.IsType(OT_GOTO_DEPOT) && this->current_order.GetDepotOrderType() != ODTFB_SERVICE) return false; frosch@8862: return NeedsServicing(); tron@593: } tron@593: tron@3881: StringID VehicleInTheWayErrMsg(const Vehicle* v) truelight@0: { tron@2631: switch (v->type) { rubidium@6259: case VEH_TRAIN: return STR_8803_TRAIN_IN_THE_WAY; rubidium@6259: case VEH_ROAD: return STR_9000_ROAD_VEHICLE_IN_THE_WAY; rubidium@6259: case VEH_AIRCRAFT: return STR_A015_AIRCRAFT_IN_THE_WAY; tron@3881: default: return STR_980E_SHIP_IN_THE_WAY; tron@2631: } truelight@0: } truelight@0: truelight@0: static void *EnsureNoVehicleProcZ(Vehicle *v, void *data) truelight@0: { smatz@8081: byte z = *(byte*)data; smatz@8081: smatz@8081: if (v->type == VEH_DISASTER || (v->type == VEH_AIRCRAFT && v->subtype == AIR_SHADOW)) return NULL; smatz@8081: if (v->z_pos > z) return NULL; truelight@0: tron@3881: _error_message = VehicleInTheWayErrMsg(v); tron@537: return v; truelight@0: } truelight@0: truelight@1605: Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z) truelight@1605: { smatz@8081: return (Vehicle*)VehicleFromPos(tile, &z, &EnsureNoVehicleProcZ); truelight@1605: } truelight@1605: smatz@8078: bool EnsureNoVehicleOnGround(TileIndex tile) smatz@8078: { smatz@8078: return FindVehicleOnTileZ(tile, GetTileMaxZ(tile)) == NULL; smatz@8078: } smatz@8078: rubidium@5940: Vehicle *FindVehicleBetween(TileIndex from, TileIndex to, byte z, bool without_crashed) truelight@0: { tron@926: int x1 = TileX(from); tron@926: int y1 = TileY(from); tron@926: int x2 = TileX(to); tron@926: int y2 = TileY(to); truelight@0: Vehicle *veh; truelight@0: truelight@0: /* Make sure x1 < x2 or y1 < y2 */ truelight@0: if (x1 > x2 || y1 > y2) { tron@6106: Swap(x1, x2); tron@6106: Swap(y1, y2); truelight@0: } truelight@919: FOR_ALL_VEHICLES(veh) { rubidium@5940: if (without_crashed && (veh->vehstatus & VS_CRASHED) != 0) continue; rubidium@6491: if ((veh->type == VEH_TRAIN || veh->type == VEH_ROAD) && (z == 0xFF || veh->z_pos == z)) { rubidium@6491: if ((veh->x_pos >> 4) >= x1 && (veh->x_pos >> 4) <= x2 && rubidium@6491: (veh->y_pos >> 4) >= y1 && (veh->y_pos >> 4) <= y2) { truelight@0: return veh; truelight@0: } truelight@0: } truelight@0: } truelight@0: return NULL; truelight@0: } truelight@0: tron@2817: smatz@8072: /** Procedure called for every vehicle found in tunnel/bridge in the hash map */ smatz@8072: static void *GetVehicleTunnelBridgeProc(Vehicle *v, void *data) smatz@8072: { smatz@8081: if (v->type != VEH_TRAIN && v->type != VEH_ROAD) return NULL; smatz@8072: smatz@8072: _error_message = VehicleInTheWayErrMsg(v); smatz@8072: return v; smatz@8072: } smatz@8072: smatz@8072: /** smatz@8072: * Finds vehicle in tunnel / bridge smatz@8072: * @param tile first end smatz@8072: * @param endtile second end smatz@8072: * @return pointer to vehicle found smatz@8072: */ smatz@8072: Vehicle *GetVehicleTunnelBridge(TileIndex tile, TileIndex endtile) smatz@8072: { smatz@8081: Vehicle *v = (Vehicle*)VehicleFromPos(tile, NULL, &GetVehicleTunnelBridgeProc); smatz@8072: if (v != NULL) return v; smatz@8072: smatz@8081: return (Vehicle*)VehicleFromPos(endtile, NULL, &GetVehicleTunnelBridgeProc); smatz@8072: } smatz@8072: smatz@8072: rubidium@8892: static void UpdateVehiclePosHash(Vehicle *v, int x, int y); tron@2817: truelight@0: void VehiclePositionChanged(Vehicle *v) truelight@0: { truelight@0: int img = v->cur_image; truelight@0: Point pt = RemapCoords(v->x_pos + v->x_offs, v->y_pos + v->y_offs, v->z_pos); rubidium@8892: const Sprite *spr = GetSprite(img); truelight@0: tron@2319: pt.x += spr->x_offs; tron@2319: pt.y += spr->y_offs; truelight@0: truelight@0: UpdateVehiclePosHash(v, pt.x, pt.y); truelight@0: truelight@0: v->left_coord = pt.x; truelight@0: v->top_coord = pt.y; tron@2319: v->right_coord = pt.x + spr->width + 2; tron@2319: v->bottom_coord = pt.y + spr->height + 2; truelight@0: } truelight@0: belugas@6423: /** Called after load to update coordinates */ peter1138@8172: void AfterLoadVehicles(bool clear_te_id) truelight@0: { truelight@0: Vehicle *v; truelight@0: truelight@0: FOR_ALL_VEHICLES(v) { rubidium@7497: /* Reinstate the previous pointer */ rubidium@7497: if (v->Next() != NULL) v->Next()->previous = v; rubidium@7497: rubidium@6558: v->UpdateDeltaXY(v->direction); rubidium@6558: peter1138@8172: if (clear_te_id) v->fill_percent_te_id = INVALID_TE_ID; celestar@1601: v->first = NULL; rubidium@6259: if (v->type == VEH_TRAIN) v->u.rail.first_engine = INVALID_ENGINE; maedhros@6857: if (v->type == VEH_ROAD) v->u.road.first_engine = INVALID_ENGINE; rubidium@7010: rubidium@7010: v->cargo.InvalidateCache(); celestar@3355: } celestar@3355: celestar@3355: FOR_ALL_VEHICLES(v) { rubidium@7497: /* Fill the first pointers */ rubidium@7497: if (v->Previous() == NULL) { rubidium@7497: for (Vehicle *u = v; u != NULL; u = u->Next()) { rubidium@7497: u->first = v; rubidium@7497: } rubidium@7497: } rubidium@7497: } rubidium@7497: rubidium@7497: FOR_ALL_VEHICLES(v) { rubidium@7497: assert(v->first != NULL); rubidium@7497: maedhros@6857: if (v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v))) { smatz@8463: if (IsFrontEngine(v)) v->u.rail.last_speed = v->cur_speed; // update displayed train speed peter1138@2994: TrainConsistChanged(v); maedhros@6857: } else if (v->type == VEH_ROAD && IsRoadVehFront(v)) { maedhros@6857: RoadVehUpdateCache(v); maedhros@6857: } peter1138@2994: } peter1138@2994: peter1138@2994: FOR_ALL_VEHICLES(v) { truelight@4346: switch (v->type) { rubidium@6683: case VEH_ROAD: skidd13@7928: v->u.road.roadtype = HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD; rubidium@6683: v->u.road.compatible_roadtypes = RoadTypeToRoadTypes(v->u.road.roadtype); rubidium@7134: /* FALL THROUGH */ rubidium@7134: case VEH_TRAIN: rubidium@7134: case VEH_SHIP: rubidium@7134: v->cur_image = v->GetImage(v->direction); rubidium@6683: break; rubidium@6683: rubidium@6259: case VEH_AIRCRAFT: Darkvater@5854: if (IsNormalAircraft(v)) { rubidium@7134: v->cur_image = v->GetImage(v->direction); Darkvater@5866: Darkvater@5866: /* The plane's shadow will have the same image as the plane */ rubidium@7492: Vehicle *shadow = v->Next(); Darkvater@5866: shadow->cur_image = v->cur_image; Darkvater@5866: Darkvater@5866: /* In the case of a helicopter we will update the rotor sprites */ Darkvater@5866: if (v->subtype == AIR_HELICOPTER) { rubidium@7492: Vehicle *rotor = shadow->Next(); Darkvater@5866: rotor->cur_image = GetRotorImage(v); Darkvater@5866: } peter1138@6490: peter1138@6490: UpdateAircraftCache(v); truelight@4346: } truelight@4346: break; truelight@4346: default: break; truelight@0: } truelight@4346: truelight@4346: v->left_coord = INVALID_COORD; truelight@4346: VehiclePositionChanged(v); truelight@0: } truelight@0: } truelight@0: rubidium@7398: Vehicle::Vehicle() truelight@0: { rubidium@7398: this->type = VEH_INVALID; rubidium@7398: this->left_coord = INVALID_COORD; rubidium@7398: this->group_id = DEFAULT_GROUP; rubidium@7398: this->fill_percent_te_id = INVALID_TE_ID; rubidium@7497: this->first = this; glx@7802: this->colormap = PAL_NONE; truelight@0: } truelight@0: peter1138@2804: /** peter1138@2804: * Get a value for a vehicle's random_bits. peter1138@2804: * @return A random value from 0 to 255. peter1138@2804: */ rubidium@6247: byte VehicleRandomBits() peter1138@2804: { peter1138@2804: return GB(Random(), 0, 8); peter1138@2804: } peter1138@2804: rubidium@7398: rubidium@7398: /* static */ bool Vehicle::AllocateList(Vehicle **vl, int num) truelight@0: { rubidium@7398: uint counter = _Vehicle_pool.first_free_index; rubidium@7398: rubidium@7398: for (int i = 0; i != num; i++) { rubidium@7398: Vehicle *v = AllocateRaw(counter); rubidium@7398: rubidium@7398: if (v == NULL) return false; rubidium@7398: v = new (v) InvalidVehicle(); rubidium@7398: bjarni@2606: if (vl != NULL) { bjarni@2606: vl[i] = v; bjarni@2606: } rubidium@7398: counter++; bjarni@2601: } bjarni@2601: bjarni@2606: return true; bjarni@2601: } bjarni@2601: peter1138@6871: /* Size of the hash, 6 = 64 x 64, 7 = 128 x 128. Larger sizes will (in theory) reduce hash peter1138@6871: * lookup times at the expense of memory usage. */ peter1138@6871: const int HASH_BITS = 7; peter1138@6871: const int HASH_SIZE = 1 << HASH_BITS; peter1138@6871: const int HASH_MASK = HASH_SIZE - 1; peter1138@6871: const int TOTAL_HASH_SIZE = 1 << (HASH_BITS * 2); peter1138@6871: const int TOTAL_HASH_MASK = TOTAL_HASH_SIZE - 1; peter1138@6871: peter1138@6871: /* Resolution of the hash, 0 = 1*1 tile, 1 = 2*2 tiles, 2 = 4*4 tiles, etc. peter1138@6871: * Profiling results show that 0 is fastest. */ peter1138@6871: const int HASH_RES = 0; peter1138@6871: peter1138@6871: static Vehicle *_new_vehicle_position_hash[TOTAL_HASH_SIZE]; peter1138@6871: peter1138@6871: static void *VehicleFromHash(int xl, int yl, int xu, int yu, void *data, VehicleFromPosProc *proc) peter1138@6871: { peter1138@6871: for (int y = yl; ; y = (y + (1 << HASH_BITS)) & (HASH_MASK << HASH_BITS)) { peter1138@6871: for (int x = xl; ; x = (x + 1) & HASH_MASK) { peter1138@6871: Vehicle *v = _new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK]; peter1138@6871: for (; v != NULL; v = v->next_new_hash) { peter1138@6871: void *a = proc(v, data); peter1138@6871: if (a != NULL) return a; peter1138@6871: } peter1138@6871: if (x == xu) break; peter1138@6871: } peter1138@6871: if (y == yu) break; peter1138@6871: } peter1138@6871: peter1138@6871: return NULL; peter1138@6871: } peter1138@6871: peter1138@6871: peter1138@6871: void *VehicleFromPosXY(int x, int y, void *data, VehicleFromPosProc *proc) peter1138@6871: { peter1138@6871: const int COLL_DIST = 6; peter1138@6871: peter1138@6871: /* Hash area to scan is from xl,yl to xu,yu */ peter1138@6871: int xl = GB((x - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS); peter1138@6871: int xu = GB((x + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS); peter1138@6871: int yl = GB((y - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS; peter1138@6871: int yu = GB((y + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS; peter1138@6871: peter1138@6871: return VehicleFromHash(xl, yl, xu, yu, data, proc); peter1138@6871: } peter1138@6871: tron@2651: truelight@0: void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc) truelight@0: { peter1138@6871: int x = GB(TileX(tile), HASH_RES, HASH_BITS); peter1138@6871: int y = GB(TileY(tile), HASH_RES, HASH_BITS) << HASH_BITS; peter1138@6871: peter1138@6871: Vehicle *v = _new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK]; peter1138@6871: for (; v != NULL; v = v->next_new_hash) { peter1138@6871: if (v->tile != tile) continue; peter1138@6871: peter1138@6871: void *a = proc(v, data); peter1138@6871: if (a != NULL) return a; truelight@0: } peter1138@6871: truelight@0: return NULL; truelight@0: } truelight@0: peter1138@6886: static void UpdateNewVehiclePosHash(Vehicle *v, bool remove) peter1138@6871: { peter1138@6871: Vehicle **old_hash = v->old_new_hash; peter1138@6871: Vehicle **new_hash; peter1138@6871: peter1138@6886: if (remove) { peter1138@6871: new_hash = NULL; peter1138@6871: } else { peter1138@7371: int x = GB(TileX(v->tile), HASH_RES, HASH_BITS); peter1138@7371: int y = GB(TileY(v->tile), HASH_RES, HASH_BITS) << HASH_BITS; peter1138@6871: new_hash = &_new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK]; peter1138@6871: } peter1138@6871: peter1138@6871: if (old_hash == new_hash) return; peter1138@6871: peter1138@6871: /* Remove from the old position in the hash table */ peter1138@6871: if (old_hash != NULL) { peter1138@6871: Vehicle *last = NULL; peter1138@6871: Vehicle *u = *old_hash; peter1138@6871: while (u != v) { peter1138@6871: last = u; peter1138@6871: u = u->next_new_hash; peter1138@6871: assert(u != NULL); peter1138@6871: } peter1138@6871: peter1138@6871: if (last == NULL) { peter1138@6871: *old_hash = v->next_new_hash; peter1138@6871: } else { peter1138@6871: last->next_new_hash = v->next_new_hash; peter1138@6871: } peter1138@6871: } peter1138@6871: peter1138@6871: /* Insert vehicle at beginning of the new position in the hash table */ peter1138@6871: if (new_hash != NULL) { peter1138@6871: v->next_new_hash = *new_hash; peter1138@6871: *new_hash = v; peter1138@6871: assert(v != v->next_new_hash); peter1138@6871: } peter1138@6871: peter1138@6871: /* Remember current hash position */ peter1138@6871: v->old_new_hash = new_hash; peter1138@6871: } peter1138@6871: peter1138@6871: static Vehicle *_vehicle_position_hash[0x1000]; truelight@0: rubidium@8892: static void UpdateVehiclePosHash(Vehicle *v, int x, int y) truelight@0: { peter1138@6886: UpdateNewVehiclePosHash(v, x == INVALID_COORD); peter1138@6871: peter1138@5574: Vehicle **old_hash, **new_hash; truelight@0: int old_x = v->left_coord; truelight@0: int old_y = v->top_coord; truelight@0: rubidium@6491: new_hash = (x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(x, y)]; truelight@0: old_hash = (old_x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(old_x, old_y)]; truelight@193: tron@2639: if (old_hash == new_hash) return; truelight@0: truelight@0: /* remove from hash table? */ truelight@0: if (old_hash != NULL) { truelight@0: Vehicle *last = NULL; peter1138@5574: Vehicle *u = *old_hash; peter1138@5574: while (u != v) { truelight@0: last = u; peter1138@5574: u = u->next_hash; peter1138@5574: assert(u != NULL); truelight@0: } truelight@0: tron@2639: if (last == NULL) { truelight@0: *old_hash = v->next_hash; tron@2639: } else { truelight@0: last->next_hash = v->next_hash; tron@2639: } truelight@0: } truelight@0: truelight@0: /* insert into hash table? */ truelight@0: if (new_hash != NULL) { truelight@0: v->next_hash = *new_hash; peter1138@5574: *new_hash = v; truelight@0: } truelight@0: } truelight@0: rubidium@6247: void ResetVehiclePosHash() Darkvater@5352: { glx@6883: Vehicle *v; glx@6883: FOR_ALL_VEHICLES(v) { v->old_new_hash = NULL; } peter1138@5574: memset(_vehicle_position_hash, 0, sizeof(_vehicle_position_hash)); peter1138@6871: memset(_new_vehicle_position_hash, 0, sizeof(_new_vehicle_position_hash)); Darkvater@5352: } Darkvater@5352: glx@7802: void ResetVehicleColorMap() glx@7802: { glx@7802: Vehicle *v; glx@7802: FOR_ALL_VEHICLES(v) { v->colormap = PAL_NONE; } glx@7802: } glx@7802: rubidium@6247: void InitializeVehicles() truelight@0: { rubidium@7400: _Vehicle_pool.CleanPool(); rubidium@7400: _Vehicle_pool.AddBlockToPool(); Darkvater@5352: Darkvater@5352: ResetVehiclePosHash(); truelight@0: } truelight@0: truelight@0: Vehicle *GetLastVehicleInChain(Vehicle *v) truelight@0: { rubidium@7492: while (v->Next() != NULL) v = v->Next(); truelight@0: return v; truelight@0: } truelight@0: peter1138@9344: const Vehicle *GetLastVehicleInChain(const Vehicle *v) peter1138@9344: { peter1138@9344: while (v->Next() != NULL) v = v->Next(); peter1138@9344: return v; peter1138@9344: } peter1138@9344: tron@2630: uint CountVehiclesInChain(const Vehicle* v) truelight@0: { tron@2639: uint count = 0; rubidium@7492: do count++; while ((v = v->Next()) != NULL); truelight@0: return count; truelight@0: } truelight@0: bjarni@4574: /** Check if a vehicle is counted in num_engines in each player struct bjarni@4574: * @param *v Vehicle to test bjarni@4574: * @return true if the vehicle is counted in num_engines bjarni@4574: */ bjarni@4574: bool IsEngineCountable(const Vehicle *v) bjarni@4574: { bjarni@4574: switch (v->type) { rubidium@6259: case VEH_AIRCRAFT: return IsNormalAircraft(v); // don't count plane shadows and helicopter rotors rubidium@6259: case VEH_TRAIN: bjarni@4574: return !IsArticulatedPart(v) && // tenders and other articulated parts bjarni@7526: !IsRearDualheaded(v); // rear parts of multiheaded engines maedhros@6857: case VEH_ROAD: return IsRoadVehFront(v); maedhros@6857: case VEH_SHIP: return true; bjarni@4574: default: return false; // Only count player buildable vehicles bjarni@4574: } bjarni@4574: } bjarni@4574: rubidium@7412: void Vehicle::PreDestructor() truelight@0: { rubidium@7413: if (CleaningPool()) return; rubidium@7413: rubidium@7398: if (IsValidStationID(this->last_station_visited)) { rubidium@7398: GetStation(this->last_station_visited)->loading_vehicles.remove(this); rubidium@7398: rubidium@7398: HideFillingPercent(this->fill_percent_te_id); rubidium@7398: this->fill_percent_te_id = INVALID_TE_ID; rubidium@6500: } rubidium@6500: rubidium@7398: if (IsEngineCountable(this)) { rubidium@7398: GetPlayer(this->owner)->num_engines[this->engine_type]--; rubidium@7398: if (this->owner == _local_player) InvalidateAutoreplaceWindow(this->engine_type, this->group_id); rubidium@7398: rubidium@7398: if (IsValidGroupID(this->group_id)) GetGroup(this->group_id)->num_engines[this->engine_type]--; rubidium@7398: if (this->IsPrimaryVehicle()) DecreaseGroupNumVehicle(this->group_id); bjarni@5944: } bjarni@4574: rubidium@7398: if (this->type == VEH_ROAD) ClearSlot(this); rubidium@7398: rubidium@7398: if (this->type != VEH_TRAIN || (this->type == VEH_TRAIN && (IsFrontEngine(this) || IsFreeWagon(this)))) { rubidium@7398: InvalidateWindowData(WC_VEHICLE_DEPOT, this->tile); bjarni@4739: } bjarni@4739: rubidium@7398: this->cargo.Truncate(0); rubidium@7412: DeleteVehicleOrders(this); truelight@4404: truelight@4404: /* Now remove any artic part. This will trigger an other truelight@4404: * destroy vehicle, which on his turn can remove any truelight@4404: * other artic parts. */ rubidium@7398: if ((this->type == VEH_TRAIN && EngineHasArticPart(this)) || (this->type == VEH_ROAD && RoadVehHasArticPart(this))) { rubidium@7492: delete this->Next(); maedhros@6857: } rubidium@7765: rubidium@9274: extern void StopGlobalFollowVehicle(const Vehicle *v); rubidium@9274: StopGlobalFollowVehicle(this); rubidium@7412: } rubidium@7412: rubidium@7412: Vehicle::~Vehicle() rubidium@7412: { peter1138@8258: free(this->name); rubidium@7413: rubidium@7413: if (CleaningPool()) return; rubidium@7413: rubidium@7499: this->SetNext(NULL); rubidium@7412: UpdateVehiclePosHash(this, INVALID_COORD, 0); rubidium@7412: this->next_hash = NULL; rubidium@7412: this->next_new_hash = NULL; rubidium@7412: rubidium@7412: DeleteVehicleNews(this->index, INVALID_STRING_ID); rubidium@7398: rubidium@7398: new (this) InvalidVehicle(); rubidium@7398: } rubidium@7398: maedhros@6782: /** maedhros@6782: * Deletes all vehicles in a chain. maedhros@6782: * @param v The first vehicle in the chain. maedhros@6782: */ truelight@0: void DeleteVehicleChain(Vehicle *v) truelight@0: { rubidium@7702: assert(v->First() == v); maedhros@6782: truelight@0: do { truelight@0: Vehicle *u = v; smatz@8317: /* sometimes, eg. for disaster vehicles, when company bankrupts, when removing crashed/flooded vehicles, smatz@8317: * it may happen that vehicle chain is deleted when visible */ smatz@8317: if (!(v->vehstatus & VS_HIDDEN)) MarkSingleVehicleDirty(v); rubidium@7492: v = v->Next(); rubidium@7398: delete u; Darkvater@1765: } while (v != NULL); truelight@0: } truelight@0: belugas@6423: /** head of the linked list to tell what vehicles that visited a depot in a tick */ tron@2630: static Vehicle* _first_veh_in_depot_list; bjarni@2574: bjarni@2574: /** Adds a vehicle to the list of vehicles, that visited a depot this tick rubidium@4549: * @param *v vehicle to add rubidium@4549: */ bjarni@2574: void VehicleEnteredDepotThisTick(Vehicle *v) bjarni@2574: { smatz@8582: /* We need to set v->leave_depot_instantly as we have no control of it's contents at this time. smatz@8582: * Vehicle should stop in the depot if it was in 'stopping' state - train intered depot while slowing down. */ rubidium@8853: if (((v->current_order.GetDepotActionType() & ODATFB_HALT) && !(v->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) && v->current_order.IsType(OT_GOTO_DEPOT)) || smatz@8582: (v->vehstatus & VS_STOPPED)) { belugas@6423: /* we keep the vehicle in the depot since the user ordered it to stay */ bjarni@2590: v->leave_depot_instantly = false; bjarni@2590: } else { belugas@6423: /* the vehicle do not plan on stopping in the depot, so we stop it to ensure that it will not reserve the path belugas@6423: * out of the depot before we might autoreplace it to a different engine. The new engine would not own the reserved path belugas@6423: * we store that we stopped the vehicle, so autoreplace can start it again */ bjarni@2579: v->vehstatus |= VS_STOPPED; bjarni@2579: v->leave_depot_instantly = true; bjarni@2579: } bjarni@2579: bjarni@2574: if (_first_veh_in_depot_list == NULL) { bjarni@2574: _first_veh_in_depot_list = v; bjarni@2574: } else { bjarni@2574: Vehicle *w = _first_veh_in_depot_list; bjarni@2574: while (w->depot_list != NULL) w = w->depot_list; bjarni@2574: w->depot_list = v; bjarni@2574: } bjarni@2574: } truelight@0: rubidium@6247: void CallVehicleTicks() truelight@0: { rubidium@4434: _first_veh_in_depot_list = NULL; // now we are sure it's initialized at the start of each tick bjarni@2574: rubidium@6616: Station *st; rubidium@6616: FOR_ALL_STATIONS(st) LoadUnloadStation(st); rubidium@6616: rubidium@6616: Vehicle *v; truelight@0: FOR_ALL_VEHICLES(v) { rubidium@7135: v->Tick(); peter1138@4656: peter1138@4656: switch (v->type) { rubidium@6621: default: break; rubidium@6621: rubidium@6259: case VEH_TRAIN: rubidium@6259: case VEH_ROAD: rubidium@6259: case VEH_AIRCRAFT: rubidium@6259: case VEH_SHIP: rubidium@6259: if (v->type == VEH_TRAIN && IsTrainWagon(v)) continue; rubidium@6259: if (v->type == VEH_AIRCRAFT && v->subtype != AIR_HELICOPTER) continue; maedhros@6857: if (v->type == VEH_ROAD && !IsRoadVehFront(v)) continue; peter1138@4656: peter1138@4656: v->motion_counter += (v->direction & 1) ? (v->cur_speed * 3) / 4 : v->cur_speed; peter1138@4656: /* Play a running sound if the motion counter passes 256 (Do we not skip sounds?) */ peter1138@4656: if (GB(v->motion_counter, 0, 8) < v->cur_speed) PlayVehicleSound(v, VSE_RUNNING); peter1138@4656: peter1138@4656: /* Play an alterate running sound every 16 ticks */ peter1138@4656: if (GB(v->tick_counter, 0, 4) == 0) PlayVehicleSound(v, v->cur_speed > 0 ? VSE_RUNNING_16 : VSE_STOPPED_16); peter1138@4656: } bjarni@2574: } bjarni@2574: belugas@6423: /* now we handle all the vehicles that entered a depot this tick */ bjarni@2574: v = _first_veh_in_depot_list; bjarni@8996: if (v != NULL) { bjarni@8996: while (v != NULL) { bjarni@8996: /* Autoreplace needs the current player set as the vehicle owner */ bjarni@8996: _current_player = v->owner; bjarni@8996: bjarni@8996: /* Buffer v->depot_list and clear it. bjarni@8996: * Autoreplace might clear this so it has to be buffered. */ bjarni@8996: Vehicle *w = v->depot_list; bjarni@8996: v->depot_list = NULL; // it should always be NULL at the end of each tick bjarni@8996: bjarni@8996: /* Start vehicle if we stopped them in VehicleEnteredDepotThisTick() bjarni@8996: * We need to stop them between VehicleEnteredDepotThisTick() and here or we risk that bjarni@8996: * they are already leaving the depot again before being replaced. */ bjarni@8996: if (v->leave_depot_instantly) { bjarni@8996: v->leave_depot_instantly = false; bjarni@8996: v->vehstatus &= ~VS_STOPPED; bjarni@8996: } bjarni@9061: MaybeReplaceVehicle(v, DC_EXEC, true); bjarni@8996: v = w; bjarni@8996: } bjarni@8996: _current_player = OWNER_NONE; truelight@0: } truelight@0: } truelight@0: peter1138@2704: /** Check if a given engine type can be refitted to a given cargo peter1138@2704: * @param engine_type Engine type to check Darkvater@1802: * @param cid_to check refit to this cargo-type Darkvater@1802: * @return true if it is possible, false otherwise Darkvater@1802: */ peter1138@2704: bool CanRefitTo(EngineID engine_type, CargoID cid_to) Darkvater@1802: { skidd13@7928: return HasBit(EngInfo(engine_type)->refit_mask, cid_to); Darkvater@1802: } Darkvater@1802: peter1138@3973: /** Find the first cargo type that an engine can be refitted to. belugas@6484: * @param engine_type Which engine to find cargo for. peter1138@3973: * @return A climate dependent cargo type. CT_INVALID is returned if not refittable. peter1138@3973: */ peter1138@3973: CargoID FindFirstRefittableCargo(EngineID engine_type) peter1138@3973: { peter1138@3973: uint32 refit_mask = EngInfo(engine_type)->refit_mask; peter1138@3973: peter1138@3973: if (refit_mask != 0) { peter1138@6350: for (CargoID cid = 0; cid < NUM_CARGO; cid++) { skidd13@7928: if (HasBit(refit_mask, cid)) return cid; peter1138@3973: } peter1138@3973: } peter1138@3973: peter1138@3973: return CT_INVALID; peter1138@3973: } peter1138@3973: bjarni@4544: /** Learn the price of refitting a certain engine belugas@6484: * @param engine_type Which engine to refit bjarni@4544: * @return Price for refitting bjarni@4544: */ rubidium@6943: CommandCost GetRefitCost(EngineID engine_type) bjarni@4544: { rubidium@8230: Money base_cost; rubidium@8230: ExpensesType expense_type; bjarni@4544: switch (GetEngine(engine_type)->type) { rubidium@8230: case VEH_SHIP: rubidium@8230: base_cost = _price.ship_base; rubidium@8230: expense_type = EXPENSES_SHIP_RUN; rubidium@8230: break; rubidium@8230: rubidium@8230: case VEH_ROAD: rubidium@8230: base_cost = _price.roadveh_base; rubidium@8230: expense_type = EXPENSES_ROADVEH_RUN; rubidium@8230: break; rubidium@8230: rubidium@8230: case VEH_AIRCRAFT: rubidium@8230: base_cost = _price.aircraft_base; rubidium@8230: expense_type = EXPENSES_AIRCRAFT_RUN; rubidium@8230: break; rubidium@8230: rubidium@6259: case VEH_TRAIN: rubidium@8230: base_cost = 2 * ((RailVehInfo(engine_type)->railveh_type == RAILVEH_WAGON) ? rubidium@8230: _price.build_railwagon : _price.build_railvehicle); rubidium@8230: expense_type = EXPENSES_TRAIN_RUN; bjarni@4544: break; rubidium@8230: rubidium@8230: default: NOT_REACHED(); bjarni@4544: } rubidium@8230: return CommandCost(expense_type, (EngInfo(engine_type)->refit_cost * base_cost) >> 10); bjarni@4544: } peter1138@3973: Darkvater@2436: static void DoDrawVehicle(const Vehicle *v) truelight@0: { peter1138@5668: SpriteID image = v->cur_image; rubidium@8892: SpriteID pal = PAL_NONE; rubidium@8892: rubidium@8892: if (v->vehstatus & VS_DEFPAL) pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v); truelight@0: peter1138@5668: AddSortableSpriteToDraw(image, pal, v->x_pos + v->x_offs, v->y_pos + v->y_offs, frosch@8793: v->x_extent, v->y_extent, v->z_extent, v->z_pos, (v->vehstatus & VS_SHADOW) != 0); truelight@0: } truelight@0: truelight@0: void ViewportAddVehicles(DrawPixelInfo *dpi) truelight@0: { belugas@6423: /* The bounding rectangle */ tron@4174: const int l = dpi->left; tron@4174: const int r = dpi->left + dpi->width; tron@4174: const int t = dpi->top; tron@4174: const int b = dpi->top + dpi->height; tron@4174: belugas@6423: /* The hash area to scan */ rubidium@6905: int xl, xu, yl, yu; rubidium@6905: rubidium@6905: if (dpi->width + 70 < (1 << (7 + 6))) { rubidium@6905: xl = GB(l - 70, 7, 6); rubidium@6905: xu = GB(r, 7, 6); rubidium@6905: } else { rubidium@6905: /* scan whole hash row */ rubidium@6905: xl = 0; rubidium@6905: xu = 0x3F; rubidium@6905: } rubidium@6905: rubidium@6905: if (dpi->height + 70 < (1 << (6 + 6))) { rubidium@6905: yl = GB(t - 70, 6, 6) << 6; rubidium@6905: yu = GB(b, 6, 6) << 6; rubidium@6905: } else { rubidium@6905: /* scan whole column */ rubidium@6905: yl = 0; rubidium@6905: yu = 0x3F << 6; rubidium@6905: } rubidium@6905: rubidium@6905: for (int y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) { rubidium@6905: for (int x = xl;; x = (x + 1) & 0x3F) { rubidium@6905: const Vehicle *v = _vehicle_position_hash[x + y]; // already masked & 0xFFF peter1138@5574: peter1138@5574: while (v != NULL) { truelight@193: if (!(v->vehstatus & VS_HIDDEN) && tron@4174: l <= v->right_coord && tron@4174: t <= v->bottom_coord && tron@4174: r >= v->left_coord && tron@4174: b >= v->top_coord) { truelight@0: DoDrawVehicle(v); truelight@0: } peter1138@5574: v = v->next_hash; truelight@0: } truelight@0: tron@4174: if (x == xu) break; truelight@0: } tron@4174: tron@4174: if (y == yu) break; truelight@0: } truelight@0: } truelight@0: tron@2116: Vehicle *CheckClickOnVehicle(const ViewPort *vp, int x, int y) truelight@0: { truelight@0: Vehicle *found = NULL, *v; truelight@0: uint dist, best_dist = (uint)-1; truelight@0: rubidium@8892: if ((uint)(x -= vp->left) >= (uint)vp->width || (uint)(y -= vp->top) >= (uint)vp->height) return NULL; truelight@0: truelight@6626: x = ScaleByZoom(x, vp->zoom) + vp->virtual_left; truelight@6626: y = ScaleByZoom(y, vp->zoom) + vp->virtual_top; truelight@0: truelight@0: FOR_ALL_VEHICLES(v) { truelight@4346: if ((v->vehstatus & (VS_HIDDEN|VS_UNCLICKABLE)) == 0 && truelight@0: x >= v->left_coord && x <= v->right_coord && truelight@0: y >= v->top_coord && y <= v->bottom_coord) { truelight@193: truelight@0: dist = max( rubidium@8892: abs(((v->left_coord + v->right_coord) >> 1) - x), rubidium@8892: abs(((v->top_coord + v->bottom_coord) >> 1) - y) truelight@0: ); truelight@0: truelight@0: if (dist < best_dist) { truelight@0: found = v; truelight@0: best_dist = dist; truelight@0: } truelight@0: } truelight@0: } truelight@0: truelight@0: return found; truelight@0: } truelight@0: glx@7803: void CheckVehicle32Day(Vehicle *v) glx@7803: { glx@7803: if ((v->day_counter & 0x1F) != 0) return; glx@7803: glx@7803: uint16 callback = GetVehicleCallback(CBID_VEHICLE_32DAY_CALLBACK, 0, 0, v->engine_type, v); glx@7803: if (callback == CALLBACK_FAILED) return; skidd13@7928: if (HasBit(callback, 0)) TriggerVehicle(v, VEHICLE_TRIGGER_CALLBACK_32); // Trigger vehicle trigger 10 skidd13@7928: if (HasBit(callback, 1)) v->colormap = PAL_NONE; // Update colormap via callback 2D glx@7803: } truelight@0: truelight@0: void DecreaseVehicleValue(Vehicle *v) truelight@0: { truelight@0: v->value -= v->value >> 8; truelight@0: InvalidateWindow(WC_VEHICLE_DETAILS, v->index); truelight@0: } truelight@0: truelight@0: static const byte _breakdown_chance[64] = { rubidium@4344: 3, 3, 3, 3, 3, 3, 3, 3, rubidium@4344: 4, 4, 5, 5, 6, 6, 7, 7, rubidium@4344: 8, 8, 9, 9, 10, 10, 11, 11, rubidium@4344: 12, 13, 13, 13, 13, 14, 15, 16, rubidium@4344: 17, 19, 21, 25, 28, 31, 34, 37, rubidium@4344: 40, 44, 48, 52, 56, 60, 64, 68, rubidium@4344: 72, 80, 90, 100, 110, 120, 130, 140, truelight@0: 150, 170, 190, 210, 230, 250, 250, 250, truelight@0: }; truelight@0: truelight@0: void CheckVehicleBreakdown(Vehicle *v) truelight@0: { truelight@0: int rel, rel_old; truelight@0: truelight@0: /* decrease reliability */ truelight@0: v->reliability = rel = max((rel_old = v->reliability) - v->reliability_spd_dec, 0); rubidium@8980: if ((rel_old >> 8) != (rel >> 8)) InvalidateWindow(WC_VEHICLE_DETAILS, v->index); truelight@0: tron@2639: if (v->breakdown_ctr != 0 || v->vehstatus & VS_STOPPED || rubidium@8980: _opt.diff.vehicle_breakdowns < 1 || tron@2639: v->cur_speed < 5 || _game_mode == GM_MENU) { tron@2639: return; tron@2639: } truelight@0: rubidium@8892: uint32 r = Random(); truelight@0: truelight@0: /* increase chance of failure */ rubidium@8892: int chance = v->breakdown_chance + 1; rubidium@8980: if (Chance16I(1, 25, r)) chance += 25; truelight@0: v->breakdown_chance = min(255, chance); truelight@0: truelight@0: /* calculate reliability value to use in comparison */ truelight@0: rel = v->reliability; rubidium@6259: if (v->type == VEH_SHIP) rel += 0x6666; truelight@193: truelight@0: /* reduced breakdowns? */ truelight@0: if (_opt.diff.vehicle_breakdowns == 1) rel += 0x6666; truelight@0: truelight@0: /* check if to break down */ truelight@0: if (_breakdown_chance[(uint)min(rel, 0xffff) >> 10] <= v->breakdown_chance) { tron@2140: v->breakdown_ctr = GB(r, 16, 6) + 0x3F; tron@2140: v->breakdown_delay = GB(r, 24, 7) + 0x80; truelight@0: v->breakdown_chance = 0; truelight@0: } truelight@0: } truelight@0: truelight@0: static const StringID _vehicle_type_names[4] = { truelight@0: STR_019F_TRAIN, truelight@0: STR_019C_ROAD_VEHICLE, truelight@0: STR_019E_SHIP, truelight@0: STR_019D_AIRCRAFT, truelight@0: }; truelight@0: truelight@0: static void ShowVehicleGettingOld(Vehicle *v, StringID msg) truelight@0: { tron@2639: if (v->owner != _local_player) return; truelight@812: rubidium@7544: /* Do not show getting-old message if autorenew is active (and it can replace the vehicle) */ rubidium@7544: if (GetPlayer(v->owner)->engine_renew && GetEngine(v->engine_type)->player_avail != 0) return; truelight@0: bjarni@5955: SetDParam(0, _vehicle_type_names[v->type]); tron@534: SetDParam(1, v->unitnumber); rubidium@9234: AddNewsItem(msg, NS_ADVICE, v->index, 0); truelight@0: } truelight@0: truelight@0: void AgeVehicle(Vehicle *v) truelight@0: { rubidium@7544: if (v->age < 65535) v->age++; rubidium@7544: rubidium@7544: int age = v->age - v->max_age; rubidium@7544: if (age == 366*0 || age == 366*1 || age == 366*2 || age == 366*3 || age == 366*4) v->reliability_spd_dec <<= 1; truelight@193: truelight@0: InvalidateWindow(WC_VEHICLE_DETAILS, v->index); truelight@0: truelight@0: if (age == -366) { truelight@0: ShowVehicleGettingOld(v, STR_01A0_IS_GETTING_OLD); truelight@0: } else if (age == 0) { truelight@0: ShowVehicleGettingOld(v, STR_01A1_IS_GETTING_VERY_OLD); rubidium@7545: } else if (age > 0 && (age % 366) == 0) { truelight@0: ShowVehicleGettingOld(v, STR_01A2_IS_GETTING_VERY_OLD_AND); truelight@0: } truelight@0: } truelight@0: bjarni@4640: /** Starts or stops a lot of vehicles bjarni@4673: * @param tile Tile of the depot where the vehicles are started/stopped (only used for depots) belugas@6423: * @param flags type of operation bjarni@4762: * @param p1 Station/Order/Depot ID (only used for vehicle list windows) bjarni@4673: * @param p2 bitmask bjarni@4762: * - bit 0-4 Vehicle type bjarni@4762: * - bit 5 false = start vehicles, true = stop vehicles bjarni@4762: * - bit 6 if set, then it's a vehicle list window, not a depot and Tile is ignored in this case bjarni@4673: * - bit 8-11 Vehicle List Window type (ignored unless bit 1 is set) bjarni@4640: */ rubidium@6943: CommandCost CmdMassStartStopVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) bjarni@4640: { peter1138@9348: VehicleList list; rubidium@6943: CommandCost return_value = CMD_ERROR; bjarni@4640: uint stop_command; rubidium@6641: VehicleType vehicle_type = (VehicleType)GB(p2, 0, 5); skidd13@7928: bool start_stop = HasBit(p2, 5); skidd13@7928: bool vehicle_list_window = HasBit(p2, 6); bjarni@4640: bjarni@4640: switch (vehicle_type) { rubidium@6259: case VEH_TRAIN: stop_command = CMD_START_STOP_TRAIN; break; rubidium@6259: case VEH_ROAD: stop_command = CMD_START_STOP_ROADVEH; break; rubidium@6259: case VEH_SHIP: stop_command = CMD_START_STOP_SHIP; break; rubidium@6259: case VEH_AIRCRAFT: stop_command = CMD_START_STOP_AIRCRAFT; break; bjarni@4640: default: return CMD_ERROR; bjarni@4640: } bjarni@4640: bjarni@4673: if (vehicle_list_window) { bjarni@5748: uint32 id = p1; bjarni@4673: uint16 window_type = p2 & VLW_MASK; bjarni@4673: peter1138@9348: GenerateVehicleSortList(&list, vehicle_type, _current_player, id, window_type); bjarni@4673: } else { bjarni@4673: /* Get the list of vehicles in the depot */ peter1138@9348: BuildDepotVehicleList(vehicle_type, tile, &list, NULL); bjarni@4673: } bjarni@4640: peter1138@9348: for (uint i = 0; i < list.Length(); i++) { peter1138@9348: const Vehicle *v = list[i]; bjarni@4640: bjarni@4640: if (!!(v->vehstatus & VS_STOPPED) != start_stop) continue; bjarni@4673: bjarni@4673: if (!vehicle_list_window) { rubidium@6259: if (vehicle_type == VEH_TRAIN) { bjarni@4673: if (CheckTrainInDepot(v, false) == -1) continue; bjarni@4673: } else { bjarni@4673: if (!(v->vehstatus & VS_HIDDEN)) continue; bjarni@4673: } bjarni@4648: } bjarni@4648: rubidium@8892: CommandCost ret = DoCommand(tile, v->index, 0, flags, stop_command); bjarni@4640: rubidium@6946: if (CmdSucceeded(ret)) { rubidium@6950: return_value = CommandCost(); bjarni@4640: /* We know that the command is valid for at least one vehicle. bjarni@4640: * If we haven't set DC_EXEC, then there is no point in continueing because it will be valid */ bjarni@4640: if (!(flags & DC_EXEC)) break; bjarni@4640: } bjarni@4640: } bjarni@4640: bjarni@4640: return return_value; bjarni@4640: } bjarni@4640: bjarni@4659: /** Sells all vehicles in a depot belugas@6423: * @param tile Tile of the depot where the depot is belugas@6423: * @param flags type of operation belugas@6423: * @param p1 Vehicle type belugas@6423: * @param p2 unused belugas@6423: */ rubidium@6943: CommandCost CmdDepotSellAllVehicles(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) bjarni@4659: { peter1138@9348: VehicleList list; bjarni@4659: smatz@8245: CommandCost cost(EXPENSES_NEW_VEHICLES); peter1138@9345: uint sell_command; rubidium@6641: VehicleType vehicle_type = (VehicleType)GB(p1, 0, 8); bjarni@4659: bjarni@4659: switch (vehicle_type) { rubidium@6259: case VEH_TRAIN: sell_command = CMD_SELL_RAIL_WAGON; break; rubidium@6259: case VEH_ROAD: sell_command = CMD_SELL_ROAD_VEH; break; rubidium@6259: case VEH_SHIP: sell_command = CMD_SELL_SHIP; break; rubidium@6259: case VEH_AIRCRAFT: sell_command = CMD_SELL_AIRCRAFT; break; bjarni@4659: default: return CMD_ERROR; bjarni@4659: } bjarni@4659: bjarni@4659: /* Get the list of vehicles in the depot */ peter1138@9348: BuildDepotVehicleList(vehicle_type, tile, &list, &list); peter1138@9348: peter1138@9348: for (uint i = 0; i < list.Length(); i++) { peter1138@9348: CommandCost ret = DoCommand(tile, list[i]->index, 1, flags, sell_command); rubidium@6950: if (CmdSucceeded(ret)) cost.AddCost(ret); bjarni@4659: } bjarni@4659: rubidium@6950: if (cost.GetCost() == 0) return CMD_ERROR; // no vehicles to sell bjarni@4659: return cost; bjarni@4659: } bjarni@4659: bjarni@4662: /** Autoreplace all vehicles in the depot bjarni@8736: * Note: this command can make incorrect cost estimations bjarni@8736: * Luckily the final price can only drop, not increase. This is due to the fact that bjarni@8736: * estimation can't predict wagon removal so it presumes worst case which is no income from selling wagons. belugas@6423: * @param tile Tile of the depot where the vehicles are belugas@6423: * @param flags type of operation belugas@6423: * @param p1 Type of vehicle bjarni@8736: * @param p2 If bit 0 is set, then either replace all or nothing (instead of replacing until money runs out) belugas@6423: */ rubidium@6943: CommandCost CmdDepotMassAutoReplace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) bjarni@4662: { peter1138@9348: VehicleList list; bjarni@8736: CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES); rubidium@6641: VehicleType vehicle_type = (VehicleType)GB(p1, 0, 8); bjarni@8736: bool all_or_nothing = HasBit(p2, 0); bjarni@4662: rubidium@7512: if (!IsDepotTile(tile) || !IsTileOwner(tile, _current_player)) return CMD_ERROR; bjarni@4662: bjarni@4662: /* Get the list of vehicles in the depot */ peter1138@9348: BuildDepotVehicleList(vehicle_type, tile, &list, &list); peter1138@9348: peter1138@9348: for (uint i = 0; i < list.Length(); i++) { peter1138@9348: Vehicle *v = (Vehicle*)list[i]; bjarni@4662: bjarni@4662: /* Ensure that the vehicle completely in the depot */ rubidium@7490: if (!v->IsInDepot()) continue; bjarni@4662: bjarni@8996: CommandCost ret = MaybeReplaceVehicle(v, flags, false); bjarni@4662: rubidium@6946: if (CmdSucceeded(ret)) { rubidium@6950: cost.AddCost(ret); bjarni@8736: } else { bjarni@8736: if (all_or_nothing) { bjarni@8736: /* We failed to replace a vehicle even though we set all or nothing. bjarni@8736: * We should never reach this if DC_EXEC is set since then it should bjarni@8736: * have failed the estimation guess. */ bjarni@8736: assert(!(flags & DC_EXEC)); peter1138@9348: /* Now we will have to return an error. */ peter1138@9348: return CMD_ERROR; bjarni@8736: } bjarni@4662: } bjarni@4662: } bjarni@4662: rubidium@6950: if (cost.GetCost() == 0) { bjarni@8736: /* Either we didn't replace anything or something went wrong. bjarni@8736: * Either way we want to return an error and not execute this command. */ bjarni@4662: cost = CMD_ERROR; bjarni@4662: } bjarni@4662: bjarni@4662: return cost; bjarni@4662: } bjarni@4662: bjarni@2244: /** Clone a vehicle. If it is a train, it will clone all the cars too rubidium@4549: * @param tile tile of the depot where the cloned vehicle is build belugas@6423: * @param flags type of operation rubidium@4549: * @param p1 the original vehicle's index rubidium@4549: * @param p2 1 = shared orders, else copied orders rubidium@4549: */ rubidium@6943: CommandCost CmdCloneVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) bjarni@2244: { rubidium@8892: CommandCost total_cost(EXPENSES_NEW_VEHICLES); bjarni@3816: uint32 build_argument = 2; bjarni@2244: truelight@4352: if (!IsValidVehicleID(p1)) return CMD_ERROR; rubidium@8892: rubidium@8892: Vehicle *v = GetVehicle(p1); rubidium@8892: Vehicle *v_front = v; rubidium@8892: Vehicle *w = NULL; rubidium@8892: Vehicle *w_front = NULL; rubidium@8892: Vehicle *w_rear = NULL; maedhros@6444: bjarni@2563: /* bjarni@2563: * v_front is the front engine in the original vehicle maedhros@6444: * v is the car/vehicle of the original vehicle, that is currently being copied bjarni@2563: * w_front is the front engine of the cloned vehicle bjarni@2563: * w is the car/vehicle currently being cloned bjarni@2563: * w_rear is the rear end of the cloned train. It's used to add more cars and is only used by trains bjarni@2563: */ bjarni@2244: tron@2639: if (!CheckOwnership(v->owner)) return CMD_ERROR; bjarni@2244: rubidium@6259: if (v->type == VEH_TRAIN && (!IsFrontEngine(v) || v->u.rail.crash_anim_pos >= 4400)) return CMD_ERROR; bjarni@2244: belugas@6423: /* check that we can allocate enough vehicles */ bjarni@2601: if (!(flags & DC_EXEC)) { bjarni@2601: int veh_counter = 0; bjarni@2601: do { bjarni@2601: veh_counter++; rubidium@7492: } while ((v = v->Next()) != NULL); bjarni@2601: rubidium@7398: if (!Vehicle::AllocateList(NULL, veh_counter)) { bjarni@2606: return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); bjarni@2601: } bjarni@2601: } bjarni@2601: bjarni@2601: v = v_front; bjarni@2601: bjarni@2563: do { bjarni@7526: if (v->type == VEH_TRAIN && IsRearDualheaded(v)) { bjarni@2676: /* we build the rear ends of multiheaded trains with the front ones */ bjarni@2676: continue; bjarni@2676: } bjarni@2676: rubidium@8892: CommandCost cost = DoCommand(tile, v->engine_type, build_argument, flags, GetCmdBuildVeh(v)); bjarni@3819: build_argument = 3; // ensure that we only assign a number to the first engine bjarni@2563: bjarni@2563: if (CmdFailed(cost)) return cost; bjarni@2563: rubidium@6950: total_cost.AddCost(cost); bjarni@2563: bjarni@2563: if (flags & DC_EXEC) { tron@2639: w = GetVehicle(_new_vehicle_id); bjarni@2563: skidd13@7928: if (v->type == VEH_TRAIN && HasBit(v->u.rail.flags, VRF_REVERSE_DIRECTION)) { skidd13@7931: SetBit(w->u.rail.flags, VRF_REVERSE_DIRECTION); bjarni@3896: } bjarni@2563: rubidium@6259: if (v->type == VEH_TRAIN && !IsFrontEngine(v)) { belugas@6423: /* this s a train car belugas@6423: * add this unit to the end of the train */ rubidium@6943: CommandCost result = DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE); bjarni@6838: if (CmdFailed(result)) { bjarni@6838: /* The train can't be joined to make the same consist as the original. bjarni@6838: * Sell what we already made (clean up) and return an error. */ bjarni@6838: DoCommand(w_front->tile, w_front->index, 1, flags, GetCmdSellVeh(w_front)); bjarni@6838: DoCommand(w_front->tile, w->index, 1, flags, GetCmdSellVeh(w)); bjarni@6838: return result; // return error and the message returned from CMD_MOVE_RAIL_VEHICLE bjarni@6838: } bjarni@2563: } else { rubidium@7850: /* this is a front engine or not a train. */ bjarni@2563: w_front = w; bjarni@3679: w->service_interval = v->service_interval; bjarni@2563: } rubidium@4434: w_rear = w; // trains needs to know the last car in the train, so they can add more in next loop bjarni@2563: } rubidium@6259: } while (v->type == VEH_TRAIN && (v = GetNextVehicle(v)) != NULL); rubidium@6259: rubidium@6259: if (flags & DC_EXEC && v_front->type == VEH_TRAIN) { belugas@6423: /* for trains this needs to be the front engine due to the callback function */ tron@3948: _new_vehicle_id = w_front->index; bjarni@2244: } peter1138@5062: rubidium@6643: if (flags & DC_EXEC) { rubidium@6643: /* Cloned vehicles belong to the same group */ rubidium@6643: DoCommand(0, v_front->group_id, w_front->index, flags, CMD_ADD_VEHICLE_GROUP); rubidium@6643: } rubidium@6643: rubidium@6643: maedhros@6546: /* Take care of refitting. */ maedhros@6546: w = w_front; maedhros@6546: v = v_front; maedhros@6546: maedhros@6546: /* Both building and refitting are influenced by newgrf callbacks, which maedhros@6546: * makes it impossible to accurately estimate the cloning costs. In maedhros@6546: * particular, it is possible for engines of the same type to be built with maedhros@6546: * different numbers of articulated parts, so when refitting we have to maedhros@6546: * loop over real vehicles first, and then the articulated parts of those maedhros@6546: * vehicles in a different loop. */ maedhros@6546: do { maedhros@6546: do { maedhros@6546: if (flags & DC_EXEC) { maedhros@6546: assert(w != NULL); maedhros@6546: rubidium@7812: if (w->cargo_type != v->cargo_type || w->cargo_subtype != v->cargo_subtype) { rubidium@8892: CommandCost cost = DoCommand(0, w->index, v->cargo_type | (v->cargo_subtype << 8) | 1U << 16 , flags, GetCmdRefitVeh(v)); rubidium@6950: if (CmdSucceeded(cost)) total_cost.AddCost(cost); maedhros@6546: } maedhros@6546: maedhros@6546: if (w->type == VEH_TRAIN && EngineHasArticPart(w)) { maedhros@6546: w = GetNextArticPart(w); maedhros@6857: } else if (w->type == VEH_ROAD && RoadVehHasArticPart(w)) { rubidium@7492: w = w->Next(); maedhros@6546: } else { maedhros@6546: break; maedhros@6546: } maedhros@6546: } else { maedhros@6546: CargoID initial_cargo = GetEngineCargoType(v->engine_type); maedhros@6546: maedhros@6546: if (v->cargo_type != initial_cargo && initial_cargo != CT_INVALID) { rubidium@6950: total_cost.AddCost(GetRefitCost(v->engine_type)); maedhros@6546: } maedhros@6546: } maedhros@6857: maedhros@6857: if (v->type == VEH_TRAIN && EngineHasArticPart(v)) { maedhros@6857: v = GetNextArticPart(v); maedhros@6857: } else if (v->type == VEH_ROAD && RoadVehHasArticPart(v)) { rubidium@7492: v = v->Next(); maedhros@6857: } else { maedhros@6857: break; maedhros@6857: } maedhros@6857: } while (v != NULL); maedhros@6546: maedhros@6727: if ((flags & DC_EXEC) && v->type == VEH_TRAIN) w = GetNextVehicle(w); maedhros@6546: } while (v->type == VEH_TRAIN && (v = GetNextVehicle(v)) != NULL); maedhros@6546: rubidium@7850: if (flags & DC_EXEC) { rubidium@7850: /* rubidium@7850: * Set the orders of the vehicle. Cannot do it earlier as we need rubidium@7850: * the vehicle refitted before doing this, otherwise the moved rubidium@7850: * cargo types might not match (passenger vs non-passenger) rubidium@7850: */ rubidium@7850: DoCommand(0, (v_front->index << 16) | w_front->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER); rubidium@7850: } rubidium@7850: maedhros@6546: /* Since we can't estimate the cost of cloning a vehicle accurately we must maedhros@6546: * check whether the player has enough money manually. */ maedhros@6546: if (!CheckPlayerHasMoney(total_cost)) { maedhros@6546: if (flags & DC_EXEC) { maedhros@6546: /* The vehicle has already been bought, so now it must be sold again. */ maedhros@6546: DoCommand(w_front->tile, w_front->index, 1, flags, GetCmdSellVeh(w_front)); maedhros@6546: } maedhros@6546: return CMD_ERROR; maedhros@6546: } maedhros@6546: bjarni@2244: return total_cost; bjarni@2244: } bjarni@2244: bjarni@2552: bjarni@4635: /** Generates a list of vehicles inside a depot bjarni@4635: * Will enlarge allocated space for the list if they are too small, so it's ok to call with (pointer to NULL array, pointer to uninitised uint16, pointer to 0) bjarni@4635: * If one of the lists is not needed (say wagons when finding ships), all the pointers regarding that list should be set to NULL belugas@6484: * @param type Type of vehicle bjarni@4635: * @param tile The tile the depot is located in bjarni@4635: * @param ***engine_list Pointer to a pointer to an array of vehicles in the depot (old list is freed and a new one is malloced) bjarni@4635: * @param *engine_list_length Allocated size of engine_list. Needs to be set to 0 when engine_list points to a NULL array bjarni@4635: * @param *engine_count The number of engines stored in the list bjarni@4635: * @param ***wagon_list Pointer to a pointer to an array of free wagons in the depot (old list is freed and a new one is malloced) bjarni@4635: * @param *wagon_list_length Allocated size of wagon_list. Needs to be set to 0 when wagon_list points to a NULL array bjarni@4635: * @param *wagon_count The number of engines stored in the list bjarni@4635: */ rubidium@6641: void BuildDepotVehicleList(VehicleType type, TileIndex tile, Vehicle ***engine_list, uint16 *engine_list_length, uint16 *engine_count, Vehicle ***wagon_list, uint16 *wagon_list_length, uint16 *wagon_count) bjarni@4635: { peter1138@9348: VehicleList engines; peter1138@9348: VehicleList wagons; peter1138@9348: peter1138@9348: BuildDepotVehicleList(type, tile, &engines, &wagons); peter1138@9348: peter1138@9348: if (engines.Length() > 0) { peter1138@9348: *engine_list = ReallocT(*engine_list, engines.Length()); peter1138@9349: memcpy(*engine_list, engines.Begin(), sizeof(engines.Begin()) * engines.Length()); peter1138@9348: } peter1138@9348: if (engine_count != NULL) *engine_count = engines.Length(); peter1138@9348: peter1138@9348: if (wagon_list != NULL && wagon_list != engine_list) { peter1138@9348: if (wagons.Length() > 0) { peter1138@9348: *wagon_list = ReallocT(*wagon_list, wagons.Length()); peter1138@9349: memcpy(*wagon_list, wagons.Begin(), sizeof(wagons.Begin()) * wagons.Length()); peter1138@9348: } peter1138@9348: if (wagon_count != NULL) *wagon_count = wagons.Length(); peter1138@9348: } peter1138@9348: } peter1138@9348: peter1138@9348: /** peter1138@9348: * Generate a list of vehicles inside a depot. peter1138@9348: * @param type Type of vehicle peter1138@9348: * @param tile The tile the depot is located on peter1138@9348: * @param engines Pointer to list to add vehicles to peter1138@9348: * @param wagons Pointer to list to add wagons to (can be NULL) peter1138@9348: */ peter1138@9348: void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons) peter1138@9348: { peter1138@9348: engines->Clear(); peter1138@9348: if (wagons != NULL && wagons != engines) wagons->Clear(); peter1138@9348: peter1138@9348: const Vehicle *v; peter1138@9340: FOR_ALL_VEHICLES(v) { peter1138@9340: /* General tests for all vehicle types */ peter1138@9340: if (v->type != type) continue; peter1138@9340: if (v->tile != tile) continue; peter1138@9340: peter1138@9340: switch (type) { peter1138@9340: case VEH_TRAIN: peter1138@9340: if (v->u.rail.track != TRACK_BIT_DEPOT) continue; peter1138@9348: if (wagons != NULL && IsFreeWagon(v)) { peter1138@9348: *wagons->Append() = v; peter1138@9340: continue; bjarni@4635: } peter1138@9340: break; peter1138@9340: peter1138@9340: default: peter1138@9340: if (!v->IsInDepot()) continue; peter1138@9340: break; peter1138@9340: } peter1138@9340: peter1138@9340: if (!v->IsPrimaryVehicle()) continue; peter1138@9340: peter1138@9348: *engines->Append() = v; bjarni@4635: } peter1138@9348: peter1138@9348: /* Ensure the lists are not wasting too much space. If the lists are fresh peter1138@9348: * (i.e. built within a command) then this will actually do nothing. */ peter1138@9348: engines->Compact(); peter1138@9348: if (wagons != NULL && wagons != engines) wagons->Compact(); bjarni@4635: } bjarni@4635: bjarni@4497: /** rubidium@8892: * @param sort_list list to store the list in. Either NULL or the length length_of_array tells rubidium@8892: * @param length_of_array informs the length allocated for sort_list. This is not the same as the number of vehicles in the list. Needs to be 0 when sort_list is NULL rubidium@8892: * @param type type of vehicle rubidium@8892: * @param owner PlayerID of owner to generate a list for rubidium@8892: * @param index This parameter has different meanings depending on window_type rubidium@8892: * rubidium@8892: * @param window_type tells what kind of window the list is for. Use the VLW flags in vehicle_gui.h rubidium@8892: * @return the number of vehicles added to the list rubidium@8892: */ rubidium@6641: uint GenerateVehicleSortList(const Vehicle ***sort_list, uint16 *length_of_array, VehicleType type, PlayerID owner, uint32 index, uint16 window_type) bjarni@4497: { peter1138@9348: VehicleList list; peter1138@9348: GenerateVehicleSortList(&list, type, owner, index, window_type); peter1138@9348: peter1138@9348: if (list.Length() > 0) { peter1138@9348: *sort_list = ReallocT(*sort_list, list.Length()); peter1138@9349: memcpy(*sort_list, list.Begin(), sizeof(list.Begin()) * list.Length()); peter1138@9348: } peter1138@9348: peter1138@9348: return list.Length(); peter1138@9348: } peter1138@9348: peter1138@9348: /** peter1138@9348: * Generate a list of vehicles based on window type. peter1138@9348: * @param list Pointer to list to add vehicles to peter1138@9348: * @param type Type of vehicle peter1138@9348: * @param owner Player to generate list for peter1138@9348: * @param index This parameter has different meanings depending on window_type peter1138@9348: * peter1138@9348: * @param window_type The type of window the list is for, using the VLW_ flags in vehicle_gui.h peter1138@9348: */ peter1138@9348: void GenerateVehicleSortList(VehicleList *list, VehicleType type, PlayerID owner, uint32 index, uint16 window_type) peter1138@9348: { peter1138@9348: list->Clear(); peter1138@9348: bjarni@4497: const Vehicle *v; bjarni@4497: bjarni@4497: switch (window_type) { peter1138@9348: case VLW_STATION_LIST: bjarni@4497: FOR_ALL_VEHICLES(v) { maedhros@6773: if (v->type == type && v->IsPrimaryVehicle()) { bjarni@4497: const Order *order; bjarni@4497: bjarni@4497: FOR_VEHICLE_ORDERS(v, order) { rubidium@8840: if (order->IsType(OT_GOTO_STATION) && order->GetDestination() == index) { peter1138@9348: *list->Append() = v; bjarni@4497: break; bjarni@4497: } bjarni@4497: } bjarni@4497: } bjarni@4497: } bjarni@4497: break; peter1138@9348: peter1138@9348: case VLW_SHARED_ORDERS: bjarni@4497: FOR_ALL_VEHICLES(v) { bjarni@4497: /* Find a vehicle with the order in question */ peter1138@9348: if (v->orders != NULL && v->orders->index == index) { peter1138@9348: /* Add all vehicles from this vehicle's shared order list */ peter1138@9348: for (v = GetFirstVehicleFromSharedList(v); v != NULL; v = v->next_shared) { peter1138@9348: *list->Append() = v; peter1138@9348: } peter1138@9348: break; bjarni@4497: } bjarni@4497: } bjarni@4497: break; peter1138@9348: peter1138@9348: case VLW_STANDARD: bjarni@4497: FOR_ALL_VEHICLES(v) { maedhros@6773: if (v->type == type && v->owner == owner && v->IsPrimaryVehicle()) { peter1138@9348: *list->Append() = v; bjarni@4497: } bjarni@4497: } bjarni@4497: break; peter1138@9348: peter1138@9348: case VLW_DEPOT_LIST: bjarni@4681: FOR_ALL_VEHICLES(v) { maedhros@6773: if (v->type == type && v->IsPrimaryVehicle()) { bjarni@4681: const Order *order; bjarni@4681: bjarni@4681: FOR_VEHICLE_ORDERS(v, order) { rubidium@8840: if (order->IsType(OT_GOTO_DEPOT) && order->GetDestination() == index) { peter1138@9348: *list->Append() = v; bjarni@4681: break; bjarni@4681: } bjarni@4681: } bjarni@4681: } bjarni@4681: } bjarni@4681: break; bjarni@4681: rubidium@8970: case VLW_GROUP_LIST: rubidium@6643: FOR_ALL_VEHICLES(v) { maedhros@6773: if (v->type == type && v->IsPrimaryVehicle() && maedhros@6773: v->owner == owner && v->group_id == index) { peter1138@9348: *list->Append() = v; rubidium@6643: } rubidium@6643: } rubidium@6643: break; rubidium@6643: bjarni@4497: default: NOT_REACHED(); break; bjarni@4497: } bjarni@4497: peter1138@9348: list->Compact(); bjarni@4497: } bjarni@4497: rubidium@8892: /** rubidium@8892: * Send all vehicles of type to depots rubidium@4549: * @param type type of vehicle rubidium@4549: * @param flags the flags used for DoCommand() rubidium@4549: * @param service should the vehicles only get service in the depots rubidium@4549: * @param owner PlayerID of owner of the vehicles to send belugas@6484: * @param vlw_flag tells what kind of list requested the goto depot rubidium@4549: * @return 0 for success and CMD_ERROR if no vehicle is able to go to depot rubidium@4549: */ rubidium@6943: CommandCost SendAllVehiclesToDepot(VehicleType type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id) bjarni@4463: { bjarni@4678: const Vehicle **sort_list = NULL; bjarni@4678: uint16 array_length = 0; bjarni@4678: rubidium@8892: uint n = GenerateVehicleSortList(&sort_list, &array_length, type, owner, id, vlw_flag); bjarni@4465: bjarni@4463: /* Send all the vehicles to a depot */ rubidium@8892: for (uint i = 0; i < n; i++) { bjarni@4497: const Vehicle *v = sort_list[i]; rubidium@6943: CommandCost ret = DoCommand(v->tile, v->index, (service ? 1 : 0) | DEPOT_DONT_CANCEL, flags, GetCmdSendToDepot(type)); Darkvater@4560: Darkvater@4560: /* Return 0 if DC_EXEC is not set this is a valid goto depot command) Darkvater@4560: * In this case we know that at least one vehicle can be sent to a depot Darkvater@4560: * and we will issue the command. We can now safely quit the loop, knowing Darkvater@4560: * it will succeed at least once. With DC_EXEC we really need to send them to the depot */ rubidium@6946: if (CmdSucceeded(ret) && !(flags & DC_EXEC)) { bjarni@4683: free((void*)sort_list); rubidium@6950: return CommandCost(); bjarni@4463: } bjarni@4463: } bjarni@4465: bjarni@4683: free((void*)sort_list); rubidium@6950: return (flags & DC_EXEC) ? CommandCost() : CMD_ERROR; bjarni@4463: } bjarni@4463: truelight@6998: /** truelight@6998: * Calculates how full a vehicle is. truelight@6998: * @param v The Vehicle to check. For trains, use the first engine. truelight@7014: * @param color The string to show depending on if we are unloading or loading truelight@6998: * @return A percentage of how full the Vehicle is. truelight@6998: */ peter1138@9221: uint8 CalcPercentVehicleFilled(const Vehicle *v, StringID *color) truelight@6998: { truelight@6998: int count = 0; truelight@6998: int max = 0; truelight@7014: int cars = 0; truelight@7014: int unloading = 0; rubidium@7087: bool loading = false; truelight@7014: rubidium@7087: const Vehicle *u = v; rubidium@8902: const Station *st = v->last_station_visited != INVALID_STATION ? GetStation(v->last_station_visited) : NULL; rubidium@7087: truelight@6998: /* Count up max and used */ rubidium@7492: for (; v != NULL; v = v->Next()) { rubidium@7010: count += v->cargo.Count(); truelight@6998: max += v->cargo_cap; rubidium@8902: if (v->cargo_cap != 0 && color != NULL) { skidd13@7928: unloading += HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) ? 1 : 0; rubidium@8855: loading |= !(u->current_order.GetUnloadType() & OUFB_UNLOAD) && st->goods[v->cargo_type].days_since_pickup != 255; truelight@7014: cars++; truelight@7014: } truelight@6998: } truelight@6998: rubidium@8897: if (color != NULL) { rubidium@8897: if (unloading == 0 && loading) { rubidium@8897: *color = STR_PERCENT_UP; rubidium@8897: } else if (cars == unloading || !loading) { rubidium@8897: *color = STR_PERCENT_DOWN; rubidium@8897: } else { rubidium@8897: *color = STR_PERCENT_UP_DOWN; rubidium@8897: } rubidium@8892: } truelight@7014: truelight@6998: /* Train without capacity */ truelight@6998: if (max == 0) return 100; truelight@6998: truelight@6998: /* Return the percentage */ truelight@6998: return (count * 100) / max; truelight@6998: } truelight@6998: bjarni@4725: void VehicleEnterDepot(Vehicle *v) bjarni@4725: { bjarni@4725: switch (v->type) { rubidium@6259: case VEH_TRAIN: bjarni@4725: InvalidateWindowClasses(WC_TRAINS_LIST); rubidium@7497: if (!IsFrontEngine(v)) v = v->First(); smatz@8300: UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner); bjarni@4725: v->load_unload_time_rem = 0; glx@8938: ClrBit(v->u.rail.flags, VRF_TOGGLE_REVERSE); peter1138@8673: TrainConsistChanged(v); bjarni@4725: break; bjarni@4725: rubidium@6259: case VEH_ROAD: bjarni@4725: InvalidateWindowClasses(WC_ROADVEH_LIST); rubidium@7497: if (!IsRoadVehFront(v)) v = v->First(); bjarni@4725: break; bjarni@4725: rubidium@6259: case VEH_SHIP: bjarni@4725: InvalidateWindowClasses(WC_SHIPS_LIST); rubidium@5993: v->u.ship.state = TRACK_BIT_DEPOT; bjarni@4725: RecalcShipStuff(v); bjarni@4725: break; bjarni@4725: rubidium@6259: case VEH_AIRCRAFT: bjarni@4725: InvalidateWindowClasses(WC_AIRCRAFT_LIST); bjarni@4725: HandleAircraftEnterHangar(v); bjarni@4725: break; bjarni@4725: default: NOT_REACHED(); bjarni@4725: } bjarni@4725: rubidium@6259: if (v->type != VEH_TRAIN) { bjarni@4739: /* Trains update the vehicle list when the first unit enters the depot and calls VehicleEnterDepot() when the last unit enters. bjarni@4739: * We only increase the number of vehicles when the first one enters, so we will not need to search for more vehicles in the depot */ bjarni@4739: InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile); bjarni@4739: } bjarni@4725: InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); bjarni@4725: bjarni@4725: v->vehstatus |= VS_HIDDEN; bjarni@4725: v->cur_speed = 0; bjarni@4725: bjarni@4725: VehicleServiceInDepot(v); bjarni@4725: bjarni@4725: TriggerVehicle(v, VEHICLE_TRIGGER_DEPOT); bjarni@4725: rubidium@8836: if (v->current_order.IsType(OT_GOTO_DEPOT)) { bjarni@4725: InvalidateWindow(WC_VEHICLE_VIEW, v->index); bjarni@4725: rubidium@8892: Order t = v->current_order; rubidium@8836: v->current_order.MakeDummy(); bjarni@4725: rubidium@8838: if (t.IsRefit()) { bjarni@4725: _current_player = v->owner; rubidium@8892: CommandCost cost = DoCommand(v->tile, v->index, t.GetRefitCargo() | t.GetRefitSubtype() << 8, DC_EXEC, GetCmdRefitVeh(v)); bjarni@4783: bjarni@4783: if (CmdFailed(cost)) { bjarni@4783: v->leave_depot_instantly = false; // We ensure that the vehicle stays in the depot bjarni@4783: if (v->owner == _local_player) { bjarni@4783: /* Notify the user that we stopped the vehicle */ bjarni@5955: SetDParam(0, _vehicle_type_names[v->type]); bjarni@4783: SetDParam(1, v->unitnumber); rubidium@9234: AddNewsItem(STR_ORDER_REFIT_FAILED, NS_ADVICE, v->index, 0); bjarni@4783: } rubidium@6950: } else if (v->owner == _local_player && cost.GetCost() != 0) { rubidium@6950: ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost.GetCost()); bjarni@4783: } bjarni@4725: } bjarni@4725: rubidium@8853: if (t.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) { bjarni@4725: /* Part of orders */ maedhros@7070: UpdateVehicleTimetable(v, true); bjarni@4725: v->cur_order_index++; rubidium@8853: } else if (t.GetDepotActionType() & ODATFB_HALT) { bjarni@4725: /* Force depot visit */ bjarni@4725: v->vehstatus |= VS_STOPPED; bjarni@4725: if (v->owner == _local_player) { bjarni@4725: StringID string; bjarni@4725: bjarni@4725: switch (v->type) { rubidium@6259: case VEH_TRAIN: string = STR_8814_TRAIN_IS_WAITING_IN_DEPOT; break; rubidium@6259: case VEH_ROAD: string = STR_9016_ROAD_VEHICLE_IS_WAITING; break; rubidium@6259: case VEH_SHIP: string = STR_981C_SHIP_IS_WAITING_IN_DEPOT; break; rubidium@6259: case VEH_AIRCRAFT: string = STR_A014_AIRCRAFT_IS_WAITING_IN; break; bjarni@4725: default: NOT_REACHED(); string = STR_EMPTY; // Set the string to something to avoid a compiler warning bjarni@4725: } bjarni@4725: bjarni@4725: SetDParam(0, v->unitnumber); rubidium@9234: AddNewsItem(string, NS_ADVICE, v->index, 0); bjarni@4725: } bjarni@4725: } bjarni@4725: } bjarni@4725: } bjarni@2244: peter1138@7097: static bool IsUniqueVehicleName(const char *name) peter1138@7097: { peter1138@7097: const Vehicle *v; peter1138@7097: char buf[512]; peter1138@7097: peter1138@7097: FOR_ALL_VEHICLES(v) { peter1138@7097: switch (v->type) { peter1138@7097: case VEH_TRAIN: peter1138@7108: if (!IsTrainEngine(v)) continue; peter1138@7108: break; peter1138@7108: peter1138@7097: case VEH_ROAD: peter1138@7358: if (!IsRoadVehFront(v)) continue; peter1138@7108: break; peter1138@7108: peter1138@7097: case VEH_AIRCRAFT: peter1138@7108: if (!IsNormalAircraft(v)) continue; peter1138@7108: break; peter1138@7108: peter1138@7097: case VEH_SHIP: peter1138@7097: break; peter1138@7097: peter1138@7097: default: peter1138@7108: continue; peter1138@7097: } peter1138@7108: peter1138@7108: SetDParam(0, v->index); peter1138@7108: GetString(buf, STR_VEHICLE_NAME, lastof(buf)); peter1138@7108: if (strcmp(buf, name) == 0) return false; peter1138@7097: } peter1138@7097: peter1138@7097: return true; peter1138@7097: } peter1138@7097: Darkvater@1786: /** Give a custom name to your vehicle tron@3491: * @param tile unused belugas@6423: * @param flags type of operation Darkvater@1786: * @param p1 vehicle ID to name Darkvater@1786: * @param p2 unused Darkvater@1786: */ rubidium@6943: CommandCost CmdNameVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) truelight@0: { peter1138@7097: if (!IsValidVehicleID(p1) || StrEmpty(_cmd_text)) return CMD_ERROR; bjarni@1237: rubidium@8892: Vehicle *v = GetVehicle(p1); truelight@0: Darkvater@1786: if (!CheckOwnership(v->owner)) return CMD_ERROR; truelight@0: peter1138@7097: if (!IsUniqueVehicleName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE); peter1138@7097: truelight@0: if (flags & DC_EXEC) { peter1138@8258: free(v->name); peter1138@8258: v->name = strdup(_cmd_text); rubidium@9297: InvalidateWindowClassesData(WC_TRAINS_LIST, 1); truelight@0: MarkWholeScreenDirty(); truelight@0: } truelight@0: rubidium@6950: return CommandCost(); truelight@0: } truelight@0: truelight@0: tron@2819: /** Change the service interval of a vehicle tron@3491: * @param tile unused belugas@6423: * @param flags type of operation tron@2819: * @param p1 vehicle ID that is being service-interval-changed tron@2819: * @param p2 new service interval tron@2819: */ rubidium@6943: CommandCost CmdChangeServiceInt(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) tron@2819: { tron@2819: uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */ tron@2819: truelight@4352: if (serv_int != p2 || !IsValidVehicleID(p1)) return CMD_ERROR; tron@2819: rubidium@8892: Vehicle *v = GetVehicle(p1); tron@2819: truelight@4352: if (!CheckOwnership(v->owner)) return CMD_ERROR; tron@2819: tron@2819: if (flags & DC_EXEC) { tron@2819: v->service_interval = serv_int; tron@2819: InvalidateWindow(WC_VEHICLE_DETAILS, v->index); tron@2819: } tron@2819: rubidium@6950: return CommandCost(); tron@2819: } tron@2819: truelight@0: smatz@8317: static Rect _old_vehicle_coords; ///< coords of vehicle before it has moved smatz@8317: smatz@8317: /** smatz@8317: * Stores the vehicle image coords for later call to EndVehicleMove() smatz@8317: * @param v vehicle which image's coords to store smatz@8317: * @see _old_vehicle_coords smatz@8317: * @see EndVehicleMove() smatz@8317: */ smatz@8317: void BeginVehicleMove(const Vehicle *v) rubidium@7321: { smatz@8317: _old_vehicle_coords.left = v->left_coord; smatz@8317: _old_vehicle_coords.top = v->top_coord; smatz@8317: _old_vehicle_coords.right = v->right_coord; truelight@0: _old_vehicle_coords.bottom = v->bottom_coord; truelight@0: } truelight@0: smatz@8317: /** smatz@8317: * Marks screen dirty after a vehicle has moved smatz@8317: * @param v vehicle which is marked dirty smatz@8317: * @see _old_vehicle_coords smatz@8317: * @see BeginVehicleMove() smatz@8317: */ smatz@8317: void EndVehicleMove(const Vehicle *v) truelight@0: { truelight@0: MarkAllViewportsDirty( smatz@8317: min(_old_vehicle_coords.left, v->left_coord), smatz@8317: min(_old_vehicle_coords.top, v->top_coord), smatz@8317: max(_old_vehicle_coords.right, v->right_coord) + 1, smatz@8317: max(_old_vehicle_coords.bottom, v->bottom_coord) + 1 truelight@0: ); truelight@0: } truelight@0: smatz@8317: /** smatz@8317: * Marks viewports dirty where the vehicle's image is smatz@8317: * In fact, it equals smatz@8317: * BeginVehicleMove(v); EndVehicleMove(v); smatz@8317: * @param v vehicle to mark dirty smatz@8317: * @see BeginVehicleMove() smatz@8317: * @see EndVehicleMove() smatz@8317: */ smatz@8317: void MarkSingleVehicleDirty(const Vehicle *v) smatz@8317: { smatz@8317: MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1); smatz@8317: } smatz@8317: truelight@0: /* returns true if staying in the same tile */ tron@6153: GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v) truelight@0: { truelight@0: static const int8 _delta_coord[16] = { truelight@0: -1,-1,-1, 0, 1, 1, 1, 0, /* x */ truelight@0: -1, 0, 1, 1, 1, 0,-1,-1, /* y */ truelight@0: }; truelight@0: truelight@0: int x = v->x_pos + _delta_coord[v->direction]; truelight@0: int y = v->y_pos + _delta_coord[v->direction + 8]; truelight@0: tron@6153: GetNewVehiclePosResult gp; tron@6153: gp.x = x; tron@6153: gp.y = y; tron@6153: gp.old_tile = v->tile; tron@6153: gp.new_tile = TileVirtXY(x, y); tron@6153: return gp; truelight@0: } truelight@0: tron@3157: static const Direction _new_direction_table[] = { tron@3157: DIR_N , DIR_NW, DIR_W , tron@3157: DIR_NE, DIR_SE, DIR_SW, tron@3157: DIR_E , DIR_SE, DIR_S truelight@0: }; truelight@0: rubidium@8892: Direction GetDirectionTowards(const Vehicle *v, int x, int y) truelight@0: { truelight@0: int i = 0; truelight@0: truelight@0: if (y >= v->y_pos) { rubidium@8892: if (y != v->y_pos) i += 3; rubidium@8892: i += 3; truelight@0: } truelight@0: truelight@0: if (x >= v->x_pos) { truelight@0: if (x != v->x_pos) i++; truelight@0: i++; truelight@0: } truelight@0: rubidium@8892: Direction dir = v->direction; rubidium@8892: rubidium@8892: DirDiff dirdiff = DirDifference(_new_direction_table[i], dir); tron@3158: if (dirdiff == DIRDIFF_SAME) return dir; tron@3158: return ChangeDir(dir, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT); truelight@0: } truelight@0: rubidium@8892: Trackdir GetVehicleTrackdir(const Vehicle *v) matthijs@1752: { rubidium@5587: if (v->vehstatus & VS_CRASHED) return INVALID_TRACKDIR; matthijs@1758: tron@2952: switch (v->type) { rubidium@6259: case VEH_TRAIN: belugas@6423: if (v->u.rail.track == TRACK_BIT_DEPOT) // We'll assume the train is facing outwards smatz@9224: return DiagDirToDiagTrackdir(GetRailDepotDirection(v->tile)); // Train in depot belugas@6423: belugas@6423: if (v->u.rail.track == TRACK_BIT_WORMHOLE) // train in tunnel, so just use his direction and assume a diagonal track smatz@9224: return DiagDirToDiagTrackdir(DirToDiagDir(v->direction)); Darkvater@1765: rubidium@5587: return TrackDirectionToTrackdir(FindFirstTrack(v->u.rail.track), v->direction); tron@1959: rubidium@6259: case VEH_SHIP: rubidium@7490: if (v->IsInDepot()) belugas@6423: // We'll assume the ship is facing outwards smatz@9224: return DiagDirToDiagTrackdir(GetShipDepotDirection(v->tile)); Darkvater@1765: rubidium@5587: return TrackDirectionToTrackdir(FindFirstTrack(v->u.ship.state), v->direction); tron@1959: rubidium@6259: case VEH_ROAD: rubidium@7490: if (v->IsInDepot()) // We'll assume the road vehicle is facing outwards smatz@9224: return DiagDirToDiagTrackdir(GetRoadDepotDirection(v->tile)); Darkvater@1765: belugas@6423: if (IsStandardRoadStopTile(v->tile)) // We'll assume the road vehicle is facing outwards smatz@9224: return DiagDirToDiagTrackdir(GetRoadStopDir(v->tile)); // Road vehicle in a station smatz@9224: smatz@9224: if (IsDriveThroughStopTile(v->tile)) return DiagDirToDiagTrackdir(DirToDiagDir(v->direction)); rubidium@6012: Darkvater@4270: /* If vehicle's state is a valid track direction (vehicle is not turning around) return it */ rubidium@6009: if (!IsReversingRoadTrackdir((Trackdir)v->u.road.state)) return (Trackdir)v->u.road.state; Darkvater@4270: Darkvater@4270: /* Vehicle is turning around, get the direction from vehicle's direction */ smatz@9224: return DiagDirToDiagTrackdir(DirToDiagDir(v->direction)); tron@1959: rubidium@9008: /* case VEH_AIRCRAFT: case VEH_EFFECT: case VEH_DISASTER: */ rubidium@5587: default: return INVALID_TRACKDIR; matthijs@1752: } matthijs@1752: } rubidium@5991: rubidium@5991: /** rubidium@5991: * Returns some meta-data over the to be entered tile. rubidium@5991: * @see VehicleEnterTileStatus to see what the bits in the return value mean. rubidium@5991: */ tron@1977: uint32 VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y) truelight@193: { tron@3657: return _tile_type_procs[GetTileType(tile)]->vehicle_enter_tile_proc(v, tile, x, y); truelight@0: } truelight@0: rubidium@6641: UnitID GetFreeUnitNumber(VehicleType type) truelight@0: { rubidium@8892: UnitID max = 0; peter1138@2995: const Vehicle *u; peter1138@2995: static bool *cache = NULL; peter1138@2995: static UnitID gmax = 0; truelight@0: peter1138@2995: switch (type) { rubidium@6259: case VEH_TRAIN: max = _patches.max_trains; break; rubidium@6259: case VEH_ROAD: max = _patches.max_roadveh; break; rubidium@6259: case VEH_SHIP: max = _patches.max_ships; break; rubidium@6259: case VEH_AIRCRAFT: max = _patches.max_aircraft; break; peter1138@2996: default: NOT_REACHED(); peter1138@2995: } peter1138@2995: bjarni@4096: if (max == 0) { bjarni@4096: /* we can't build any of this kind of vehicle, so we just return 1 instead of looking for a free number bjarni@4096: * a max of 0 will cause the following code to write to a NULL pointer bjarni@4096: * We know that 1 is bigger than the max allowed vehicle number, so it's the same as returning something, that is too big bjarni@4096: */ bjarni@4096: return 1; bjarni@4096: } bjarni@4096: peter1138@2995: if (max > gmax) { peter1138@2995: gmax = max; peter1138@2995: free(cache); KUDr@5609: cache = MallocT(max + 1); peter1138@2995: } peter1138@2995: belugas@6423: /* Clear the cache */ peter1138@2995: memset(cache, 0, (max + 1) * sizeof(*cache)); peter1138@2995: belugas@6423: /* Fill the cache */ truelight@0: FOR_ALL_VEHICLES(u) { peter1138@2995: if (u->type == type && u->owner == _current_player && u->unitnumber != 0 && u->unitnumber <= max) peter1138@2995: cache[u->unitnumber] = true; truelight@0: } peter1138@2995: belugas@6423: /* Find the first unused unit number */ rubidium@8892: UnitID unit = 1; rubidium@8892: for (; unit <= max; unit++) { peter1138@2995: if (!cache[unit]) break; peter1138@2995: } peter1138@2995: peter1138@2995: return unit; truelight@0: } truelight@0: peter1138@6516: rubidium@7086: /** rubidium@7086: * Check whether we can build infrastructure for the given rubidium@7086: * vehicle type. This to disable building stations etc. when rubidium@7086: * you are not allowed/able to have the vehicle type yet. rubidium@7086: * @param type the vehicle type to check this for rubidium@7086: * @return true if there is any reason why you may build rubidium@7086: * the infrastructure for the given vehicle type rubidium@7086: */ rubidium@7086: bool CanBuildVehicleInfrastructure(VehicleType type) rubidium@7086: { rubidium@7086: assert(IsPlayerBuildableVehicleType(type)); rubidium@7086: maedhros@7415: if (!IsValidPlayer(_current_player)) return false; rubidium@7086: if (_patches.always_build_infrastructure) return true; rubidium@7086: rubidium@7086: UnitID max; rubidium@7086: switch (type) { rubidium@7086: case VEH_TRAIN: max = _patches.max_trains; break; rubidium@7086: case VEH_ROAD: max = _patches.max_roadveh; break; rubidium@7086: case VEH_SHIP: max = _patches.max_ships; break; rubidium@7086: case VEH_AIRCRAFT: max = _patches.max_aircraft; break; rubidium@7086: default: NOT_REACHED(); rubidium@7086: } rubidium@7086: rubidium@7086: /* We can build vehicle infrastructure when we may build the vehicle type */ rubidium@7086: if (max > 0) { rubidium@7086: /* Can we actually build the vehicle type? */ peter1138@9070: const Engine *e; peter1138@9070: FOR_ALL_ENGINES_OF_TYPE(e, type) { peter1138@9070: if (HasBit(e->player_avail, _local_player)) return true; rubidium@7086: } rubidium@7086: return false; rubidium@7086: } rubidium@7086: rubidium@7086: /* We should be able to build infrastructure when we have the actual vehicle type */ rubidium@7086: const Vehicle *v; rubidium@7086: FOR_ALL_VEHICLES(v) { rubidium@7086: if (v->owner == _local_player && v->type == type) return true; rubidium@7086: } rubidium@7086: rubidium@7086: return false; rubidium@7086: } rubidium@7086: rubidium@7086: peter1138@6516: const Livery *GetEngineLivery(EngineID engine_type, PlayerID player, EngineID parent_engine_type, const Vehicle *v) peter1138@3040: { peter1138@4603: const Player *p = GetPlayer(player); peter1138@4603: LiveryScheme scheme = LS_DEFAULT; peter1138@5717: CargoID cargo_type = v == NULL ? (CargoID)CT_INVALID : v->cargo_type; peter1138@5717: peter1138@4603: /* The default livery is always available for use, but its in_use flag determines peter1138@4603: * whether any _other_ liveries are in use. */ peter1138@4616: if (p->livery[LS_DEFAULT].in_use && (_patches.liveries == 2 || (_patches.liveries == 1 && player == _local_player))) { peter1138@4603: /* Determine the livery scheme to use */ peter1138@4603: switch (GetEngine(engine_type)->type) { rubidium@6638: default: NOT_REACHED(); rubidium@6259: case VEH_TRAIN: { tron@5763: const RailVehicleInfo *rvi = RailVehInfo(engine_type); tron@5763: rubidium@8309: if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type; rubidium@8309: if (rvi->railveh_type == RAILVEH_WAGON) { rubidium@8309: if (!GetCargo(cargo_type)->is_freight) { rubidium@8309: if (parent_engine_type == INVALID_ENGINE) { rubidium@8309: scheme = LS_PASSENGER_WAGON_STEAM; peter1138@4603: } else { rubidium@8309: switch (RailVehInfo(parent_engine_type)->engclass) { rubidium@6585: default: NOT_REACHED(); rubidium@8309: case EC_STEAM: scheme = LS_PASSENGER_WAGON_STEAM; break; rubidium@8309: case EC_DIESEL: scheme = LS_PASSENGER_WAGON_DIESEL; break; rubidium@8309: case EC_ELECTRIC: scheme = LS_PASSENGER_WAGON_ELECTRIC; break; rubidium@8309: case EC_MONORAIL: scheme = LS_PASSENGER_WAGON_MONORAIL; break; rubidium@8309: case EC_MAGLEV: scheme = LS_PASSENGER_WAGON_MAGLEV; break; peter1138@4603: } peter1138@4603: } rubidium@8309: } else { rubidium@8309: scheme = LS_FREIGHT_WAGON; peter1138@4603: } rubidium@8309: } else { rubidium@8309: bool is_mu = HasBit(EngInfo(engine_type)->misc_flags, EF_RAIL_IS_MU); rubidium@8309: rubidium@8309: switch (rvi->engclass) { rubidium@8309: default: NOT_REACHED(); rubidium@8309: case EC_STEAM: scheme = LS_STEAM; break; rubidium@8309: case EC_DIESEL: scheme = is_mu ? LS_DMU : LS_DIESEL; break; rubidium@8309: case EC_ELECTRIC: scheme = is_mu ? LS_EMU : LS_ELECTRIC; break; rubidium@8309: case EC_MONORAIL: scheme = LS_MONORAIL; break; rubidium@8309: case EC_MAGLEV: scheme = LS_MAGLEV; break; rubidium@8309: } peter1138@4603: } peter1138@4603: break; peter1138@4603: } peter1138@4603: rubidium@6259: case VEH_ROAD: { peter1138@4603: const RoadVehicleInfo *rvi = RoadVehInfo(engine_type); peter1138@4603: if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type; skidd13@7928: if (HasBit(EngInfo(engine_type)->misc_flags, EF_ROAD_TRAM)) { peter1138@6724: /* Tram */ peter1138@6724: scheme = IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_PASSENGER_TRAM : LS_FREIGHT_TRAM; peter1138@6724: } else { peter1138@6724: /* Bus or truck */ peter1138@6724: scheme = IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_BUS : LS_TRUCK; peter1138@6724: } peter1138@4603: break; peter1138@4603: } peter1138@4603: rubidium@6259: case VEH_SHIP: { peter1138@4603: const ShipVehicleInfo *svi = ShipVehInfo(engine_type); peter1138@4603: if (cargo_type == CT_INVALID) cargo_type = svi->cargo_type; peter1138@6330: scheme = IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_PASSENGER_SHIP : LS_FREIGHT_SHIP; peter1138@4603: break; peter1138@4603: } peter1138@4603: rubidium@6259: case VEH_AIRCRAFT: { peter1138@4603: const AircraftVehicleInfo *avi = AircraftVehInfo(engine_type); peter1138@4603: if (cargo_type == CT_INVALID) cargo_type = CT_PASSENGERS; peter1138@4603: switch (avi->subtype) { Darkvater@5855: case AIR_HELI: scheme = LS_HELICOPTER; break; Darkvater@5855: case AIR_CTOL: scheme = LS_SMALL_PLANE; break; Darkvater@5855: case AIR_CTOL | AIR_FAST: scheme = LS_LARGE_PLANE; break; peter1138@4603: } peter1138@4603: break; peter1138@4603: } peter1138@4603: } peter1138@4603: peter1138@4603: /* Switch back to the default scheme if the resolved scheme is not in use */ peter1138@4603: if (!p->livery[scheme].in_use) scheme = LS_DEFAULT; peter1138@4603: } peter1138@4603: peter1138@6516: return &p->livery[scheme]; peter1138@6516: } peter1138@6516: peter1138@6516: peter1138@6516: static SpriteID GetEngineColourMap(EngineID engine_type, PlayerID player, EngineID parent_engine_type, const Vehicle *v) peter1138@6516: { glx@7802: SpriteID map = (v != NULL) ? v->colormap : PAL_NONE; glx@7802: glx@7802: /* Return cached value if any */ glx@7802: if (map != PAL_NONE) return map; peter1138@6516: peter1138@6516: /* Check if we should use the colour map callback */ skidd13@7928: if (HasBit(EngInfo(engine_type)->callbackmask, CBM_VEHICLE_COLOUR_REMAP)) { peter1138@6516: uint16 callback = GetVehicleCallback(CBID_VEHICLE_COLOUR_MAPPING, 0, 0, engine_type, v); peter1138@6516: /* A return value of 0xC000 is stated to "use the default two-color peter1138@6516: * maps" which happens to be the failure action too... */ peter1138@6516: if (callback != CALLBACK_FAILED && callback != 0xC000) { peter1138@6516: map = GB(callback, 0, 14); peter1138@6516: /* If bit 14 is set, then the company colours are applied to the peter1138@6516: * map else it's returned as-is. */ skidd13@7928: if (!HasBit(callback, 14)) { glx@7802: /* Update cache */ glx@7802: if (v != NULL) ((Vehicle*)v)->colormap = map; glx@7802: return map; glx@7802: } peter1138@6516: } peter1138@6516: } peter1138@6516: skidd13@7928: bool twocc = HasBit(EngInfo(engine_type)->misc_flags, EF_USES_2CC); peter1138@5717: peter1138@5717: if (map == PAL_NONE) map = twocc ? (SpriteID)SPR_2CCMAP_BASE : (SpriteID)PALETTE_RECOLOR_START; peter1138@5717: peter1138@6516: const Livery *livery = GetEngineLivery(engine_type, player, parent_engine_type, v); peter1138@6516: peter1138@6516: map += livery->colour1; peter1138@6516: if (twocc) map += livery->colour2 * 16; peter1138@3113: glx@7802: /* Update cache */ glx@7802: if (v != NULL) ((Vehicle*)v)->colormap = map; peter1138@5668: return map; peter1138@3040: } peter1138@3040: peter1138@5668: SpriteID GetEnginePalette(EngineID engine_type, PlayerID player) peter1138@3105: { peter1138@5717: return GetEngineColourMap(engine_type, player, INVALID_ENGINE, NULL); peter1138@3105: } peter1138@3105: peter1138@5668: SpriteID GetVehiclePalette(const Vehicle *v) peter1138@3105: { rubidium@6259: if (v->type == VEH_TRAIN) { peter1138@4603: return GetEngineColourMap( peter1138@6809: (v->u.rail.first_engine != INVALID_ENGINE && (UsesWagonOverride(v) || (IsArticulatedPart(v) && RailVehInfo(v->engine_type)->railveh_type != RAILVEH_WAGON))) ? peter1138@4603: v->u.rail.first_engine : v->engine_type, peter1138@5717: v->owner, v->u.rail.first_engine, v); peter1138@4603: } peter1138@4603: peter1138@5717: return GetEngineColourMap(v->engine_type, v->owner, INVALID_ENGINE, v); peter1138@3105: } peter1138@3105: rubidium@7010: static uint8 _cargo_days; rubidium@7010: static uint16 _cargo_source; rubidium@7010: static uint32 _cargo_source_xy; rubidium@7010: static uint16 _cargo_count; rubidium@7010: static uint16 _cargo_paid_for; rubidium@7010: static Money _cargo_feeder_share; rubidium@7010: static uint32 _cargo_loaded_at_xy; rubidium@7010: rubidium@7493: /** rubidium@7493: * Make it possible to make the saveload tables "friends" of other classes. rubidium@7493: * @param vt the vehicle type. Can be VEH_END for the common vehicle description data rubidium@7493: * @return the saveload description rubidium@7493: */ rubidium@7493: const SaveLoad *GetVehicleDescription(VehicleType vt) rubidium@7493: { belugas@6423: /** Save and load of vehicles */ rubidium@7493: static const SaveLoad _common_veh_desc[] = { rubidium@4344: SLE_VAR(Vehicle, subtype, SLE_UINT8), rubidium@4344: rubidium@4344: SLE_REF(Vehicle, next, REF_VEHICLE_OLD), peter1138@8258: SLE_CONDVAR(Vehicle, name, SLE_NAME, 0, 83), peter1138@8258: SLE_CONDSTR(Vehicle, name, SLE_STR, 0, 84, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, unitnumber, SLE_FILE_U8 | SLE_VAR_U16, 0, 7), rubidium@4344: SLE_CONDVAR(Vehicle, unitnumber, SLE_UINT16, 8, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, owner, SLE_UINT8), rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, dest_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, dest_tile, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, z_pos, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, direction, SLE_UINT8), rubidium@4344: rubidium@6561: SLE_CONDNULL(2, 0, 57), rubidium@4344: SLE_VAR(Vehicle, spritenum, SLE_UINT8), rubidium@6561: SLE_CONDNULL(5, 0, 57), rubidium@4344: SLE_VAR(Vehicle, engine_type, SLE_UINT16), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, max_speed, SLE_UINT16), rubidium@4344: SLE_VAR(Vehicle, cur_speed, SLE_UINT16), rubidium@4344: SLE_VAR(Vehicle, subspeed, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, acceleration, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, progress, SLE_UINT8), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, vehstatus, SLE_UINT8), rubidium@4344: SLE_CONDVAR(Vehicle, last_station_visited, SLE_FILE_U8 | SLE_VAR_U16, 0, 4), rubidium@4344: SLE_CONDVAR(Vehicle, last_station_visited, SLE_UINT16, 5, SL_MAX_VERSION), rubidium@4344: rubidium@7010: SLE_VAR(Vehicle, cargo_type, SLE_UINT8), rubidium@7010: SLE_CONDVAR(Vehicle, cargo_subtype, SLE_UINT8, 35, SL_MAX_VERSION), rubidium@7010: SLEG_CONDVAR( _cargo_days, SLE_UINT8, 0, 67), rubidium@7010: SLEG_CONDVAR( _cargo_source, SLE_FILE_U8 | SLE_VAR_U16, 0, 6), rubidium@7010: SLEG_CONDVAR( _cargo_source, SLE_UINT16, 7, 67), rubidium@7010: SLEG_CONDVAR( _cargo_source_xy, SLE_UINT32, 44, 67), rubidium@7010: SLE_VAR(Vehicle, cargo_cap, SLE_UINT16), rubidium@7010: SLEG_CONDVAR( _cargo_count, SLE_UINT16, 0, 67), rubidium@7010: SLE_CONDLST(Vehicle, cargo, REF_CARGO_PACKET, 68, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, day_counter, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, tick_counter, SLE_UINT8), smatz@8556: SLE_CONDVAR(Vehicle, running_ticks, SLE_UINT8, 88, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, cur_order_index, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, num_orders, SLE_UINT8), truelight@956: truelight@956: /* This next line is for version 4 and prior compatibility.. it temporarily reads truelight@956: type and flags (which were both 4 bits) into type. Later on this is truelight@956: converted correctly */ rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, type), SLE_UINT8, 0, 4), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, dest), SLE_FILE_U8 | SLE_VAR_U16, 0, 4), truelight@956: truelight@956: /* Orders for version 5 and on */ rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, type), SLE_UINT8, 5, SL_MAX_VERSION), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, flags), SLE_UINT8, 5, SL_MAX_VERSION), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, dest), SLE_UINT16, 5, SL_MAX_VERSION), rubidium@4344: bjarni@4712: /* Refit in current order */ rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, refit_cargo), SLE_UINT8, 36, SL_MAX_VERSION), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, refit_subtype), SLE_UINT8, 36, SL_MAX_VERSION), bjarni@4712: maedhros@6980: /* Timetable in current order */ maedhros@6980: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, wait_time), SLE_UINT16, 67, SL_MAX_VERSION), maedhros@6980: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, travel_time), SLE_UINT16, 67, SL_MAX_VERSION), maedhros@6980: rubidium@4344: SLE_REF(Vehicle, orders, REF_ORDER), rubidium@4344: rubidium@4344: SLE_CONDVAR(Vehicle, age, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, age, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, max_age, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, max_age, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, date_of_last_service, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, date_of_last_service, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, service_interval, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, service_interval, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, reliability, SLE_UINT16), rubidium@4344: SLE_VAR(Vehicle, reliability_spd_dec, SLE_UINT16), rubidium@4344: SLE_VAR(Vehicle, breakdown_ctr, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, breakdown_delay, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, breakdowns_since_last_service, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, breakdown_chance, SLE_UINT8), rubidium@4344: SLE_CONDVAR(Vehicle, build_year, SLE_FILE_U8 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, build_year, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: rubidium@7010: SLE_VAR(Vehicle, load_unload_time_rem, SLE_UINT16), rubidium@7010: SLEG_CONDVAR( _cargo_paid_for, SLE_UINT16, 45, SL_MAX_VERSION), rubidium@7010: SLE_CONDVAR(Vehicle, vehicle_flags, SLE_UINT8, 40, SL_MAX_VERSION), rubidium@7010: rubidium@7010: SLE_CONDVAR(Vehicle, profit_this_year, SLE_FILE_I32 | SLE_VAR_I64, 0, 64), rubidium@7010: SLE_CONDVAR(Vehicle, profit_this_year, SLE_INT64, 65, SL_MAX_VERSION), rubidium@7010: SLE_CONDVAR(Vehicle, profit_last_year, SLE_FILE_I32 | SLE_VAR_I64, 0, 64), rubidium@7010: SLE_CONDVAR(Vehicle, profit_last_year, SLE_INT64, 65, SL_MAX_VERSION), rubidium@7010: SLEG_CONDVAR( _cargo_feeder_share, SLE_FILE_I32 | SLE_VAR_I64,51, 64), rubidium@7010: SLEG_CONDVAR( _cargo_feeder_share, SLE_INT64, 65, 67), rubidium@7010: SLEG_CONDVAR( _cargo_loaded_at_xy, SLE_UINT32, 51, 67), rubidium@7010: SLE_CONDVAR(Vehicle, value, SLE_FILE_I32 | SLE_VAR_I64, 0, 64), rubidium@7010: SLE_CONDVAR(Vehicle, value, SLE_INT64, 65, SL_MAX_VERSION), rubidium@4344: glx@8522: SLE_CONDVAR(Vehicle, random_bits, SLE_UINT8, 2, SL_MAX_VERSION), glx@8522: SLE_CONDVAR(Vehicle, waiting_triggers, SLE_UINT8, 2, SL_MAX_VERSION), glx@8522: glx@8522: SLE_CONDREF(Vehicle, next_shared, REF_VEHICLE, 2, SL_MAX_VERSION), glx@8522: SLE_CONDREF(Vehicle, prev_shared, REF_VEHICLE, 2, SL_MAX_VERSION), truelight@1024: rubidium@6643: SLE_CONDVAR(Vehicle, group_id, SLE_UINT16, 60, SL_MAX_VERSION), rubidium@6643: maedhros@6980: SLE_CONDVAR(Vehicle, current_order_time, SLE_UINT32, 67, SL_MAX_VERSION), maedhros@6980: SLE_CONDVAR(Vehicle, lateness_counter, SLE_INT32, 67, SL_MAX_VERSION), maedhros@6980: belugas@6423: /* reserve extra space in savegame here. (currently 10 bytes) */ rubidium@4344: SLE_CONDNULL(10, 2, SL_MAX_VERSION), truelight@193: truelight@0: SLE_END() truelight@0: }; truelight@0: truelight@0: Darkvater@1881: static const SaveLoad _train_desc[] = { rubidium@6817: SLE_WRITEBYTE(Vehicle, type, VEH_TRAIN), rubidium@7493: SLE_VEH_INCLUDEX(), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRail, crash_anim_pos), SLE_UINT16), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRail, force_proceed), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRail, railtype), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRail, track), SLE_UINT8), rubidium@6552: rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRail, flags), SLE_UINT8, 2, SL_MAX_VERSION), rubidium@6573: SLE_CONDNULL(2, 2, 59), truelight@0: Darkvater@3222: SLE_CONDNULL(2, 2, 19), belugas@6423: /* reserve extra space in savegame here. (currently 11 bytes) */ Darkvater@3222: SLE_CONDNULL(11, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: Darkvater@1881: static const SaveLoad _roadveh_desc[] = { rubidium@6817: SLE_WRITEBYTE(Vehicle, type, VEH_ROAD), rubidium@7493: SLE_VEH_INCLUDEX(), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, state), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, frame), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, blocked_ctr), SLE_UINT16), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, overtaking), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, overtaking_ctr), SLE_UINT8), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, crashed_ctr), SLE_UINT16), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, reverse_ctr), SLE_UINT8), rubidium@6552: rubidium@6552: SLE_CONDREFX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, slot), REF_ROADSTOPS, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDNULL(1, 6, SL_MAX_VERSION), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleRoad, slot_age), SLE_UINT8, 6, SL_MAX_VERSION), belugas@6423: /* reserve extra space in savegame here. (currently 16 bytes) */ rubidium@4344: SLE_CONDNULL(16, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: Darkvater@1881: static const SaveLoad _ship_desc[] = { rubidium@6817: SLE_WRITEBYTE(Vehicle, type, VEH_SHIP), rubidium@7493: SLE_VEH_INCLUDEX(), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleShip, state), SLE_UINT8), truelight@0: belugas@6423: /* reserve extra space in savegame here. (currently 16 bytes) */ Darkvater@3222: SLE_CONDNULL(16, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: Darkvater@1881: static const SaveLoad _aircraft_desc[] = { rubidium@6817: SLE_WRITEBYTE(Vehicle, type, VEH_AIRCRAFT), rubidium@7493: SLE_VEH_INCLUDEX(), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, crashed_counter), SLE_UINT16), rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, pos), SLE_UINT8), rubidium@6552: rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, targetairport), SLE_FILE_U8 | SLE_VAR_U16, 0, 4), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, targetairport), SLE_UINT16, 5, SL_MAX_VERSION), rubidium@6552: rubidium@6552: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, state), SLE_UINT8), rubidium@6552: rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleAir, previous_pos), SLE_UINT8, 2, SL_MAX_VERSION), truelight@0: belugas@6423: /* reserve extra space in savegame here. (currently 15 bytes) */ rubidium@4344: SLE_CONDNULL(15, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: Darkvater@1881: static const SaveLoad _special_desc[] = { rubidium@9008: SLE_WRITEBYTE(Vehicle, type, VEH_EFFECT), rubidium@6817: rubidium@4344: SLE_VAR(Vehicle, subtype, SLE_UINT8), rubidium@4344: rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_FILE_I16 | SLE_VAR_I32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_INT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_FILE_I16 | SLE_VAR_I32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_INT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, z_pos, SLE_UINT8), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, cur_image, SLE_UINT16), rubidium@6561: SLE_CONDNULL(5, 0, 57), rubidium@4344: SLE_VAR(Vehicle, progress, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, vehstatus, SLE_UINT8), rubidium@4344: rubidium@9008: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleEffect, animation_state), SLE_UINT16), rubidium@9008: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleEffect, animation_substate), SLE_UINT8), truelight@0: belugas@6423: /* reserve extra space in savegame here. (currently 16 bytes) */ Darkvater@3222: SLE_CONDNULL(16, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: Darkvater@1881: static const SaveLoad _disaster_desc[] = { rubidium@6817: SLE_WRITEBYTE(Vehicle, type, VEH_DISASTER), rubidium@6817: rubidium@4344: SLE_REF(Vehicle, next, REF_VEHICLE_OLD), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, subtype, SLE_UINT8), rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, tile, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, dest_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, dest_tile, SLE_UINT32, 6, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_FILE_I16 | SLE_VAR_I32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, x_pos, SLE_INT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_FILE_I16 | SLE_VAR_I32, 0, 5), rubidium@4344: SLE_CONDVAR(Vehicle, y_pos, SLE_INT32, 6, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, z_pos, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, direction, SLE_UINT8), rubidium@4344: rubidium@6561: SLE_CONDNULL(5, 0, 57), rubidium@4344: SLE_VAR(Vehicle, owner, SLE_UINT8), rubidium@4344: SLE_VAR(Vehicle, vehstatus, SLE_UINT8), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, dest), SLE_FILE_U8 | SLE_VAR_U16, 0, 4), rubidium@6552: SLE_CONDVARX(cpp_offsetof(Vehicle, current_order) + cpp_offsetof(Order, dest), SLE_UINT16, 5, SL_MAX_VERSION), rubidium@4344: rubidium@4344: SLE_VAR(Vehicle, cur_image, SLE_UINT16), rubidium@4344: SLE_CONDVAR(Vehicle, age, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Vehicle, age, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Vehicle, tick_counter, SLE_UINT8), rubidium@4344: rubidium@7334: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleDisaster, image_override), SLE_UINT16), rubidium@7334: SLE_VARX(cpp_offsetof(Vehicle, u) + cpp_offsetof(VehicleDisaster, big_ufo_destroyer_target), SLE_UINT16), truelight@0: belugas@6423: /* reserve extra space in savegame here. (currently 16 bytes) */ rubidium@4344: SLE_CONDNULL(16, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: truelight@0: rubidium@7398: static const SaveLoad *_veh_descs[] = { truelight@0: _train_desc, truelight@0: _roadveh_desc, truelight@0: _ship_desc, truelight@0: _aircraft_desc, truelight@0: _special_desc, truelight@0: _disaster_desc, rubidium@7493: _common_veh_desc, truelight@0: }; truelight@0: rubidium@7493: return _veh_descs[vt]; rubidium@7493: } rubidium@7493: belugas@6423: /** Will be called when the vehicles need to be saved. */ rubidium@6247: static void Save_VEHS() truelight@0: { truelight@0: Vehicle *v; belugas@6423: /* Write the vehicles */ truelight@0: FOR_ALL_VEHICLES(v) { truelight@4346: SlSetArrayIndex(v->index); rubidium@7493: SlObject(v, GetVehicleDescription(v->type)); truelight@0: } truelight@0: } truelight@0: belugas@6423: /** Will be called when vehicles need to be loaded. */ rubidium@8836: void Load_VEHS() truelight@0: { truelight@0: int index; truelight@0: Vehicle *v; truelight@0: rubidium@7010: _cargo_count = 0; rubidium@7010: truelight@0: while ((index = SlIterateArray()) != -1) { truelight@1279: Vehicle *v; rubidium@6817: VehicleType vtype = (VehicleType)SlReadByte(); rubidium@7010: rubidium@7010: switch (vtype) { rubidium@7398: case VEH_TRAIN: v = new (index) Train(); break; rubidium@7398: case VEH_ROAD: v = new (index) RoadVehicle(); break; rubidium@7398: case VEH_SHIP: v = new (index) Ship(); break; rubidium@7398: case VEH_AIRCRAFT: v = new (index) Aircraft(); break; rubidium@9008: case VEH_EFFECT: v = new (index) EffectVehicle(); break; rubidium@7398: case VEH_DISASTER: v = new (index) DisasterVehicle(); break; rubidium@7398: case VEH_INVALID: v = new (index) InvalidVehicle(); break; rubidium@6621: default: NOT_REACHED(); rubidium@6552: } rubidium@6552: rubidium@7493: SlObject(v, GetVehicleDescription(vtype)); rubidium@7010: rubidium@7010: if (_cargo_count != 0 && IsPlayerBuildableVehicleType(v)) { rubidium@7010: /* Don't construct the packet with station here, because that'll fail with old savegames */ rubidium@7010: CargoPacket *cp = new CargoPacket(); rubidium@7010: cp->source = _cargo_source; rubidium@7010: cp->source_xy = _cargo_source_xy; rubidium@7010: cp->count = _cargo_count; rubidium@7010: cp->days_in_transit = _cargo_days; rubidium@7010: cp->feeder_share = _cargo_feeder_share; rubidium@7010: cp->loaded_at_xy = _cargo_loaded_at_xy; rubidium@7010: v->cargo.Append(cp); rubidium@7010: } rubidium@7010: tron@2549: /* Old savegames used 'last_station_visited = 0xFF' */ truelight@2685: if (CheckSavegameVersion(5) && v->last_station_visited == 0xFF) tron@2469: v->last_station_visited = INVALID_STATION; truelight@956: truelight@2685: if (CheckSavegameVersion(5)) { truelight@956: /* Convert the current_order.type (which is a mix of type and flags, because rubidium@4549: * in those versions, they both were 4 bits big) to type and flags */ rubidium@8836: v->current_order.flags = GB(v->current_order.type, 4, 4); rubidium@8881: v->current_order.type &= 0x0F; truelight@956: } rubidium@6643: rubidium@6643: /* Advanced vehicle lists got added */ rubidium@6643: if (CheckSavegameVersion(60)) v->group_id = DEFAULT_GROUP; truelight@0: } truelight@0: truelight@1024: /* Check for shared order-lists (we now use pointers for that) */ truelight@2685: if (CheckSavegameVersionOldStyle(5, 2)) { truelight@1024: FOR_ALL_VEHICLES(v) { truelight@1024: Vehicle *u; truelight@1024: truelight@1024: FOR_ALL_VEHICLES_FROM(u, v->index + 1) { truelight@1024: /* If a vehicle has the same orders, add the link to eachother rubidium@4549: * in both vehicles */ truelight@1024: if (v->orders == u->orders) { truelight@1024: v->next_shared = u; truelight@1024: u->prev_shared = v; truelight@1024: break; truelight@1024: } truelight@1024: } truelight@1024: } truelight@1024: } truelight@0: } truelight@0: rubidium@5587: extern const ChunkHandler _veh_chunk_handlers[] = { truelight@1542: { 'VEHS', Save_VEHS, Load_VEHS, CH_SPARSE_ARRAY | CH_LAST}, truelight@0: }; KUDr@5651: KUDr@5651: void Vehicle::BeginLoading() KUDr@5651: { rubidium@6259: assert(IsTileType(tile, MP_STATION) || type == VEH_SHIP); rubidium@6550: rubidium@8836: if (this->current_order.IsType(OT_GOTO_STATION) && rubidium@8840: this->current_order.GetDestination() == this->last_station_visited) { rubidium@8881: current_order.MakeLoading(true); rubidium@8881: UpdateVehicleTimetable(this, true); rubidium@8881: rubidium@6550: /* Furthermore add the Non Stop flag to mark that this station rubidium@6550: * is the actual destination of the vehicle, which is (for example) rubidium@6550: * necessary to be known for HandleTrainLoading to determine rubidium@6550: * whether the train is lost or not; not marking a train lost rubidium@6550: * that arrives at random stations is bad. */ rubidium@8848: this->current_order.SetNonStopType(ONSF_NO_STOP_AT_ANY_STATION); rubidium@8843: rubidium@6550: } else { rubidium@8843: current_order.MakeLoading(false); rubidium@6550: } rubidium@6550: rubidium@6500: GetStation(this->last_station_visited)->loading_vehicles.push_back(this); rubidium@6553: rubidium@6565: VehiclePayment(this); rubidium@6565: smatz@9043: InvalidateWindow(GetWindowClassForVehicleType(this->type), this->owner); smatz@8350: InvalidateWindowWidget(WC_VEHICLE_VIEW, this->index, VVW_WIDGET_START_STOP_VEH); rubidium@6565: InvalidateWindow(WC_VEHICLE_DETAILS, this->index); rubidium@6565: InvalidateWindow(WC_STATION_VIEW, this->last_station_visited); rubidium@6565: peter1138@6823: GetStation(this->last_station_visited)->MarkTilesDirty(true); rubidium@6565: this->MarkDirty(); KUDr@5651: } KUDr@5651: KUDr@5651: void Vehicle::LeaveStation() KUDr@5651: { rubidium@8837: assert(current_order.IsType(OT_LOADING)); maedhros@7076: maedhros@7076: /* Only update the timetable if the vehicle was supposed to stop here. */ rubidium@8848: if (current_order.GetNonStopType() != ONSF_STOP_EVERYWHERE) UpdateVehicleTimetable(this, false); maedhros@7076: rubidium@8836: current_order.MakeLeaveStation(); peter1138@9041: Station *st = GetStation(this->last_station_visited); peter1138@9041: st->loading_vehicles.remove(this); maedhros@6980: truelight@6998: HideFillingPercent(this->fill_percent_te_id); truelight@6998: this->fill_percent_te_id = INVALID_TE_ID; peter1138@9041: peter1138@9041: /* Trigger station animation for trains only */ peter1138@9041: if (this->type == VEH_TRAIN && IsTileType(this->tile, MP_STATION)) StationAnimationTrigger(st, this->tile, STAT_ANIM_TRAIN_DEPARTS); KUDr@5651: } rubidium@6558: rubidium@6558: rubidium@6594: void Vehicle::HandleLoading(bool mode) rubidium@6594: { rubidium@8836: switch (this->current_order.GetType()) { rubidium@6594: case OT_LOADING: { maedhros@6980: uint wait_time = max(this->current_order.wait_time - this->lateness_counter, 0); maedhros@6980: rubidium@6616: /* Not the first call for this tick, or still loading */ skidd13@7928: if (mode || !HasBit(this->vehicle_flags, VF_LOADING_FINISHED) || maedhros@6980: (_patches.timetabling && this->current_order_time < wait_time)) return; rubidium@6594: rubidium@6594: this->PlayLeaveStationSound(); rubidium@6594: rubidium@8848: bool at_destination_station = this->current_order.GetNonStopType() != ONSF_STOP_EVERYWHERE; rubidium@6594: this->LeaveStation(); rubidium@6594: rubidium@6594: /* If this was not the final order, don't remove it from the list. */ rubidium@8848: if (!at_destination_station) return; rubidium@6594: break; rubidium@6594: } rubidium@6594: rubidium@6594: case OT_DUMMY: break; rubidium@6594: rubidium@6594: default: return; rubidium@6594: } rubidium@6594: rubidium@6594: this->cur_order_index++; rubidium@6594: InvalidateVehicleOrder(this); rubidium@6594: } rubidium@6594: rubidium@8891: CommandCost Vehicle::SendToDepot(uint32 flags, DepotCommand command) rubidium@8891: { rubidium@8891: if (!CheckOwnership(this->owner)) return CMD_ERROR; rubidium@8891: if (this->vehstatus & VS_CRASHED) return CMD_ERROR; rubidium@8891: if (this->IsInDepot()) return CMD_ERROR; rubidium@8891: rubidium@8891: if (this->current_order.IsType(OT_GOTO_DEPOT)) { rubidium@8891: bool halt_in_depot = this->current_order.GetDepotActionType() & ODATFB_HALT; rubidium@8891: if (!!(command & DEPOT_SERVICE) == halt_in_depot) { rubidium@8891: /* We called with a different DEPOT_SERVICE setting. rubidium@8891: * Now we change the setting to apply the new one and let the vehicle head for the same depot. rubidium@8891: * Note: the if is (true for requesting service == true for ordered to stop in depot) */ rubidium@8891: if (flags & DC_EXEC) { rubidium@8891: this->current_order.SetDepotOrderType(ODTF_MANUAL); rubidium@8891: this->current_order.SetDepotActionType(halt_in_depot ? ODATF_SERVICE_ONLY : ODATFB_HALT); rubidium@8891: InvalidateWindowWidget(WC_VEHICLE_VIEW, this->index, VVW_WIDGET_START_STOP_VEH); rubidium@8891: } rubidium@8891: return CommandCost(); rubidium@8891: } rubidium@8891: rubidium@8891: if (command & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders rubidium@8891: if (flags & DC_EXEC) { rubidium@8891: /* If the orders to 'goto depot' are in the orders list (forced servicing), rubidium@8891: * then skip to the next order; effectively cancelling this forced service */ rubidium@8891: if (this->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) this->cur_order_index++; rubidium@8891: rubidium@8891: this->current_order.MakeDummy(); rubidium@8891: InvalidateWindowWidget(WC_VEHICLE_VIEW, this->index, VVW_WIDGET_START_STOP_VEH); rubidium@8891: } rubidium@8891: return CommandCost(); rubidium@8891: } rubidium@8891: rubidium@8891: /* check if at a standstill (not stopped only) in a depot rubidium@8891: * the check is down here to make it possible to alter stop/service for trains entering the depot */ smatz@8961: if (this->type == VEH_TRAIN && IsRailDepotTile(this->tile) && this->cur_speed == 0) return CMD_ERROR; rubidium@8891: rubidium@8891: TileIndex location; rubidium@8891: DestinationID destination; rubidium@8891: bool reverse; rubidium@8891: static const StringID no_depot[] = {STR_883A_UNABLE_TO_FIND_ROUTE_TO, STR_9019_UNABLE_TO_FIND_LOCAL_DEPOT, STR_981A_UNABLE_TO_FIND_LOCAL_DEPOT, STR_A012_CAN_T_SEND_AIRCRAFT_TO}; rubidium@8892: if (!this->FindClosestDepot(&location, &destination, &reverse)) return_cmd_error(no_depot[this->type]); rubidium@8891: rubidium@8891: if (flags & DC_EXEC) { rubidium@8891: if (this->current_order.IsType(OT_LOADING)) this->LeaveStation(); rubidium@8891: rubidium@8891: this->dest_tile = location; rubidium@8891: this->current_order.MakeGoToDepot(destination, ODTF_MANUAL); rubidium@8891: if (!(command & DEPOT_SERVICE)) this->current_order.SetDepotActionType(ODATFB_HALT); rubidium@8891: InvalidateWindowWidget(WC_VEHICLE_VIEW, this->index, VVW_WIDGET_START_STOP_VEH); rubidium@8891: rubidium@8891: /* If there is no depot in front, reverse automatically (trains only) */ rubidium@8891: if (this->type == VEH_TRAIN && reverse) DoCommand(this->tile, this->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION); rubidium@8891: rubidium@8891: if (this->type == VEH_AIRCRAFT && this->u.air.state == FLYING && this->u.air.targetairport != destination) { rubidium@8892: /* The aircraft is now heading for a different hangar than the next in the orders */ rubidium@8892: extern void AircraftNextAirportPos_and_Order(Vehicle *v); rubidium@8892: AircraftNextAirportPos_and_Order(this); rubidium@8892: } rubidium@8891: } rubidium@8891: rubidium@8891: return CommandCost(); rubidium@8891: rubidium@8891: } rubidium@8891: rubidium@7497: void Vehicle::SetNext(Vehicle *next) rubidium@7497: { rubidium@7497: if (this->next != NULL) { rubidium@7497: /* We had an old next vehicle. Update the first and previous pointers */ rubidium@7497: for (Vehicle *v = this->next; v != NULL; v = v->Next()) { rubidium@7497: v->first = this->next; rubidium@7497: } rubidium@7497: this->next->previous = NULL; rubidium@7497: } rubidium@7497: rubidium@7497: this->next = next; rubidium@7497: rubidium@7497: if (this->next != NULL) { rubidium@7497: /* A new next vehicle. Update the first and previous pointers */ rubidium@7497: if (this->next->previous != NULL) this->next->previous->next = NULL; rubidium@7497: this->next->previous = this; rubidium@7497: for (Vehicle *v = this->next; v != NULL; v = v->Next()) { rubidium@7497: v->first = this->first; rubidium@7497: } rubidium@7497: } rubidium@7497: } rubidium@7497: bjarni@9061: /** Backs up a chain of vehicles bjarni@9081: * @param v The vehicle to back up bjarni@9061: */ bjarni@9081: void BackuppedVehicle::BackupVehicle(Vehicle *v) bjarni@9061: { bjarni@9081: int length = CountVehiclesInChain(v); bjarni@9081: glx@9146: size_t cargo_packages_count = 1; bjarni@9081: for (const Vehicle *v_count = v; v_count != NULL; v_count=v_count->Next()) { bjarni@9081: /* Now we count how many cargo packets we need to store. bjarni@9081: * We started with an offset by one because we also need an end of array marker. */ bjarni@9081: cargo_packages_count += v_count->cargo.packets.size(); bjarni@9081: } bjarni@9081: bjarni@9081: vehicles = MallocT(length); bjarni@9081: cargo_packets = MallocT(cargo_packages_count); bjarni@9081: bjarni@9081: /* Now we make some pointers to iterate over the arrays. */ bjarni@9081: Vehicle *copy = vehicles; bjarni@9081: CargoPacket *cargo = cargo_packets; bjarni@9081: bjarni@9081: Vehicle *original = v; bjarni@9081: bjarni@9081: for (; 0 < length; original = original->Next(), copy++, length--) { bjarni@9081: /* First we need to copy the vehicle itself. bjarni@9081: * However there is an issue as the cargo list isn't copied. bjarni@9081: * To avoid restoring invalid pointers we start by swapping the cargo list with an empty one. */ bjarni@9081: CargoList::List empty_packets; bjarni@9081: original->cargo.packets.swap(empty_packets); bjarni@9061: memcpy(copy, original, sizeof(Vehicle)); bjarni@9081: bjarni@9081: /* No need to do anything else if the cargo list is empty. bjarni@9081: * It really doesn't matter if we swap an empty list with an empty list. */ bjarni@9081: if (original->cargo.Empty()) continue; bjarni@9081: bjarni@9081: /* And now we swap the cargo lists back. The vehicle now has it's cargo again. */ bjarni@9081: original->cargo.packets.swap(empty_packets); bjarni@9081: bjarni@9081: /* The vehicle contains some cargo so we will back up the cargo as well. bjarni@9081: * We only need to store the packets and not which vehicle they came from. bjarni@9081: * We will still be able to put them together with the right vehicle when restoring. */ bjarni@9081: const CargoList::List *packets = original->cargo.Packets(); bjarni@9081: for (CargoList::List::const_iterator it = packets->begin(); it != packets->end(); it++) { bjarni@9081: memcpy(cargo, (*it), sizeof(CargoPacket)); bjarni@9081: cargo++; bjarni@9081: } bjarni@9061: } bjarni@9081: /* We should end with a 0 packet so restoring can detect the end of the array. */ bjarni@9081: memset(cargo, 0, sizeof(CargoPacket)); bjarni@9061: } bjarni@9061: bjarni@9061: /** Restore a backed up row of vehicles bjarni@9081: * @param *v The array of vehicles to restore bjarni@9081: * @param *p The owner of the vehicle bjarni@9061: */ bjarni@9081: Vehicle* BackuppedVehicle::RestoreBackupVehicle(Vehicle *v, Player *p) bjarni@9061: { bjarni@9081: Vehicle *backup = v; bjarni@9081: CargoPacket *cargo = cargo_packets; bjarni@9081: bjarni@9081: assert(v->owner == p->index); bjarni@9061: bjarni@9128: /* Cache the result of the vehicle type check since it will not change bjarni@9128: * and we need this check once for every run though the loop. */ bjarni@9128: bool is_road_veh = v->type == VEH_ROAD; bjarni@9128: bjarni@9061: while (true) { bjarni@9061: Vehicle *dest = GetVehicle(backup->index); bjarni@9061: /* The vehicle should be free since we are restoring something we just sold. */ bjarni@9061: assert(!dest->IsValid()); bjarni@9061: memcpy(dest, backup, sizeof(Vehicle)); bjarni@9061: bjarni@9061: /* We decreased the engine count when we sold the engines so we will increase it again. */ bjarni@9259: if (IsEngineCountable(backup)) { bjarni@9259: p->num_engines[backup->engine_type]++; bjarni@9259: if (IsValidGroupID(backup->group_id)) GetGroup(backup->group_id)->num_engines[backup->engine_type]++; bjarni@9259: if (backup->IsPrimaryVehicle()) IncreaseGroupNumVehicle(backup->group_id); bjarni@9259: } bjarni@9061: bjarni@9081: /* Update hash. */ bjarni@9061: Vehicle *dummy = dest; bjarni@9061: dest->old_new_hash = &dummy; bjarni@9061: dest->left_coord = INVALID_COORD; bjarni@9061: UpdateVehiclePosHash(dest, INVALID_COORD, 0); bjarni@9061: bjarni@9128: if (is_road_veh) { bjarni@9128: /* Removed the slot in the road vehicles as the slot is gone. bjarni@9128: * We don't want a pointer to a slot that's gone. */ bjarni@9128: dest->u.road.slot = NULL; bjarni@9128: } bjarni@9128: bjarni@9081: if (!dest->cargo.Empty()) { bjarni@9081: /* The vehicle in question contains some cargo. bjarni@9081: * However we lost the list so we will have to recreate it. bjarni@9081: * We know that the packets are stored in the same order as the vehicles so bjarni@9081: * the one cargo_packets points to and maybe some following ones belongs to bjarni@9081: * the current vehicle. bjarni@9081: * Now all we have to do is to add the packets to a list and keep track of how bjarni@9081: * much cargo we restore and once we reached the cached cargo hold we recovered bjarni@9081: * everything for this vehicle. */ bjarni@9081: uint cargo_count = 0; bjarni@9081: for(; cargo_count < dest->cargo.Count(); cargo++) { bjarni@9081: dest->cargo.packets.push_back(GetCargoPacket(cargo->index)); bjarni@9081: cargo_count += cargo->count; bjarni@9081: } bjarni@9081: /* This design should always end up with the right amount of cargo. */ bjarni@9081: assert(cargo_count == dest->cargo.Count()); bjarni@9081: } bjarni@9081: bjarni@9081: if (backup->Next() == NULL) break; bjarni@9061: backup++; bjarni@9061: } bjarni@9081: return GetVehicle(v->index); bjarni@9061: } bjarni@9061: bjarni@9061: /** Restores a backed up vehicle bjarni@9061: * @param *v A vehicle we should sell and take the windows from (NULL for not using this) bjarni@9081: * @param *p The owner of the vehicle bjarni@9061: * @return The vehicle we restored (front for trains) or v if we didn't have anything to restore bjarni@9061: */ bjarni@9081: Vehicle *BackuppedVehicle::Restore(Vehicle *v, Player *p) bjarni@9061: { bjarni@9061: if (!ContainsBackup()) return v; bjarni@9061: if (v != NULL) { rubidium@9280: ChangeVehicleViewWindow(v->index, INVALID_VEHICLE); bjarni@9061: DoCommand(0, v->index, 1, DC_EXEC, GetCmdSellVeh(v)); bjarni@9061: } bjarni@9081: v = RestoreBackupVehicle(this->vehicles, p); rubidium@9280: ChangeVehicleViewWindow(INVALID_VEHICLE, v->index); bjarni@9061: if (orders != NULL) RestoreVehicleOrdersBruteForce(v, orders); bjarni@9061: if (economy != NULL) economy->Restore(); bjarni@9081: /* If we stored cargo as well then we should restore it. */ bjarni@9081: cargo_packets->RestoreBackup(); bjarni@9061: return v; bjarni@9061: } bjarni@9061: bjarni@9061: /** Backs up a vehicle bjarni@9061: * This should never be called when the object already contains a backup bjarni@9061: * @param v the vehicle to backup bjarni@9061: * @param p If it's set to the vehicle's owner then economy is backed up. If NULL then economy backup will be skipped. bjarni@9061: */ bjarni@9081: void BackuppedVehicle::Backup(Vehicle *v, Player *p) bjarni@9061: { bjarni@9061: assert(!ContainsBackup()); bjarni@9061: if (p != NULL) { bjarni@9061: assert(p->index == v->owner); bjarni@9061: economy = new PlayerMoneyBackup(p); bjarni@9061: } bjarni@9081: BackupVehicle(v); bjarni@9061: if (orders != NULL) BackupVehicleOrders(v, orders); bjarni@9061: } bjarni@9061: rubidium@8144: void StopAllVehicles() rubidium@8144: { rubidium@8144: Vehicle *v; rubidium@8144: FOR_ALL_VEHICLES(v) { rubidium@8144: /* Code ripped from CmdStartStopTrain. Can't call it, because of rubidium@8144: * ownership problems, so we'll duplicate some code, for now */ rubidium@8144: v->vehstatus |= VS_STOPPED; smatz@8350: InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH); rubidium@8144: InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); rubidium@8144: } rubidium@8144: }