src/script/api/script_engine.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file script_engine.cpp Implementation of ScriptEngine. */
   9
  10 #include "../../stdafx.h"
  11 #include "script_engine.hpp"
  12 #include "script_cargo.hpp"
  13 #include "../../company_base.h"
  14 #include "../../strings_func.h"
  15 #include "../../rail.h"
  16 #include "../../road.h"
  17 #include "../../engine_base.h"
  18 #include "../../engine_func.h"
  19 #include "../../articulated_vehicles.h"
  20 #include "../../engine_cmd.h"
  21 #include "../../timer/timer_game_calendar.h"
  22 #include "table/strings.h"
  23
  24 #include "../../safeguards.h"
  25
  26 /* static */ bool ScriptEngine::IsValidEngine(EngineID engine_id)
  27 {
  28         EnforceDeityOrCompanyModeValid(false);
  29         const Engine *e = ::Engine::GetIfValid(engine_id);
  30         if (e == nullptr || !e->IsEnabled()) return false;
  31
  32         /* AIs have only access to engines they can purchase or still have in use.
  33          * Deity has access to all engined that will be or were available ever. */
  34         CompanyID company = ScriptObject::GetCompany();
  35         return ScriptCompanyMode::IsDeity() || ::IsEngineBuildable(engine_id, e->type, company) || ::Company::Get(company)->group_all[e->type].GetNumEngines(engine_id) > 0;
  36 }
  37
  38 /* static */ bool ScriptEngine::IsBuildable(EngineID engine_id)
  39 {
  40         EnforceDeityOrCompanyModeValid(false);
  41         const Engine *e = ::Engine::GetIfValid(engine_id);
  42         return e != nullptr && ::IsEngineBuildable(engine_id, e->type, ScriptObject::GetCompany());
  43 }
  44
  45 /* static */ std::optional<std::string> ScriptEngine::GetName(EngineID engine_id)
  46 {
  47         if (!IsValidEngine(engine_id)) return std::nullopt;
  48
  49         ::SetDParam(0, engine_id);
  50         return GetString(STR_ENGINE_NAME);
  51 }
  52
  53 /* static */ CargoID ScriptEngine::GetCargoType(EngineID engine_id)
  54 {
  55         if (!IsValidEngine(engine_id)) return INVALID_CARGO;
  56
  57         CargoArray cap = ::GetCapacityOfArticulatedParts(engine_id);
  58
  59         auto it = std::max_element(std::cbegin(cap), std::cend(cap));
  60         if (*it == 0) return INVALID_CARGO;
  61
  62         return CargoID(std::distance(std::cbegin(cap), it));
  63 }
  64
  65 /* static */ bool ScriptEngine::CanRefitCargo(EngineID engine_id, CargoID cargo_id)
  66 {
  67         if (!IsValidEngine(engine_id)) return false;
  68         if (!ScriptCargo::IsValidCargo(cargo_id)) return false;
  69
  70         return HasBit(::GetUnionOfArticulatedRefitMasks(engine_id, true), cargo_id);
  71 }
  72
  73 /* static */ bool ScriptEngine::CanPullCargo(EngineID engine_id, CargoID cargo_id)
  74 {
  75         if (!IsValidEngine(engine_id)) return false;
  76         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return false;
  77         if (!ScriptCargo::IsValidCargo(cargo_id)) return false;
  78
  79         return (::RailVehInfo(engine_id)->ai_passenger_only != 1) || ScriptCargo::HasCargoClass(cargo_id, ScriptCargo::CC_PASSENGERS);
  80 }
  81
  82
  83 /* static */ SQInteger ScriptEngine::GetCapacity(EngineID engine_id)
  84 {
  85         if (!IsValidEngine(engine_id)) return -1;
  86
  87         const Engine *e = ::Engine::Get(engine_id);
  88         switch (e->type) {
  89                 case VEH_ROAD:
  90                 case VEH_TRAIN: {
  91                         CargoArray capacities = GetCapacityOfArticulatedParts(engine_id);
  92                         for (uint &cap : capacities) {
  93                                 if (cap != 0) return cap;
  94                         }
  95                         return -1;
  96                 }
  97
  98                 case VEH_SHIP:
  99                 case VEH_AIRCRAFT:
 100                         return e->GetDisplayDefaultCapacity();
 101
 102                 default: NOT_REACHED();
 103         }
 104 }
 105
 106 /* static */ SQInteger ScriptEngine::GetReliability(EngineID engine_id)
 107 {
 108         if (!IsValidEngine(engine_id)) return -1;
 109         if (GetVehicleType(engine_id) == ScriptVehicle::VT_RAIL && IsWagon(engine_id)) return -1;
 110
 111         return ::ToPercent16(::Engine::Get(engine_id)->reliability);
 112 }
 113
 114 /* static */ SQInteger ScriptEngine::GetMaxSpeed(EngineID engine_id)
 115 {
 116         if (!IsValidEngine(engine_id)) return -1;
 117
 118         const Engine *e = ::Engine::Get(engine_id);
 119         uint max_speed = e->GetDisplayMaxSpeed(); // km-ish/h
 120         if (e->type == VEH_AIRCRAFT) max_speed /= _settings_game.vehicle.plane_speed;
 121         return max_speed;
 122 }
 123
 124 /* static */ Money ScriptEngine::GetPrice(EngineID engine_id)
 125 {
 126         if (!IsValidEngine(engine_id)) return -1;
 127
 128         return ::Engine::Get(engine_id)->GetCost();
 129 }
 130
 131 /* static */ SQInteger ScriptEngine::GetMaxAge(EngineID engine_id)
 132 {
 133         if (!IsValidEngine(engine_id)) return -1;
 134         if (GetVehicleType(engine_id) == ScriptVehicle::VT_RAIL && IsWagon(engine_id)) return -1;
 135
 136         return ::Engine::Get(engine_id)->GetLifeLengthInDays().base();
 137 }
 138
 139 /* static */ Money ScriptEngine::GetRunningCost(EngineID engine_id)
 140 {
 141         if (!IsValidEngine(engine_id)) return -1;
 142
 143         return ::Engine::Get(engine_id)->GetRunningCost();
 144 }
 145
 146 /* static */ SQInteger ScriptEngine::GetPower(EngineID engine_id)
 147 {
 148         if (!IsValidEngine(engine_id)) return -1;
 149         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL && GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD) return -1;
 150         if (IsWagon(engine_id)) return -1;
 151
 152         return ::Engine::Get(engine_id)->GetPower();
 153 }
 154
 155 /* static */ SQInteger ScriptEngine::GetWeight(EngineID engine_id)
 156 {
 157         if (!IsValidEngine(engine_id)) return -1;
 158         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL && GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD) return -1;
 159
 160         return ::Engine::Get(engine_id)->GetDisplayWeight();
 161 }
 162
 163 /* static */ SQInteger ScriptEngine::GetMaxTractiveEffort(EngineID engine_id)
 164 {
 165         if (!IsValidEngine(engine_id)) return -1;
 166         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL && GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD) return -1;
 167         if (IsWagon(engine_id)) return -1;
 168
 169         return ::Engine::Get(engine_id)->GetDisplayMaxTractiveEffort() / 1000;
 170 }
 171
 172 /* static */ ScriptDate::Date ScriptEngine::GetDesignDate(EngineID engine_id)
 173 {
 174         if (!IsValidEngine(engine_id)) return ScriptDate::DATE_INVALID;
 175
 176         return (ScriptDate::Date)::Engine::Get(engine_id)->intro_date.base();
 177 }
 178
 179 /* static */ ScriptVehicle::VehicleType ScriptEngine::GetVehicleType(EngineID engine_id)
 180 {
 181         if (!IsValidEngine(engine_id)) return ScriptVehicle::VT_INVALID;
 182
 183         switch (::Engine::Get(engine_id)->type) {
 184                 case VEH_ROAD:     return ScriptVehicle::VT_ROAD;
 185                 case VEH_TRAIN:    return ScriptVehicle::VT_RAIL;
 186                 case VEH_SHIP:     return ScriptVehicle::VT_WATER;
 187                 case VEH_AIRCRAFT: return ScriptVehicle::VT_AIR;
 188                 default: NOT_REACHED();
 189         }
 190 }
 191
 192 /* static */ bool ScriptEngine::IsWagon(EngineID engine_id)
 193 {
 194         if (!IsValidEngine(engine_id)) return false;
 195         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return false;
 196
 197         return ::RailVehInfo(engine_id)->power == 0;
 198 }
 199
 200 /* static */ bool ScriptEngine::CanRunOnRail(EngineID engine_id, ScriptRail::RailType track_rail_type)
 201 {
 202         if (!IsValidEngine(engine_id)) return false;
 203         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return false;
 204         if (!ScriptRail::IsRailTypeAvailable(track_rail_type)) return false;
 205
 206         return ::IsCompatibleRail((::RailType)::RailVehInfo(engine_id)->railtype, (::RailType)track_rail_type);
 207 }
 208
 209 /* static */ bool ScriptEngine::HasPowerOnRail(EngineID engine_id, ScriptRail::RailType track_rail_type)
 210 {
 211         if (!IsValidEngine(engine_id)) return false;
 212         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return false;
 213         if (!ScriptRail::IsRailTypeAvailable(track_rail_type)) return false;
 214
 215         return ::HasPowerOnRail((::RailType)::RailVehInfo(engine_id)->railtype, (::RailType)track_rail_type);
 216 }
 217
 218 /* static */ bool ScriptEngine::CanRunOnRoad(EngineID engine_id, ScriptRoad::RoadType road_type)
 219 {
 220         return HasPowerOnRoad(engine_id, road_type);
 221 }
 222
 223 /* static */ bool ScriptEngine::HasPowerOnRoad(EngineID engine_id, ScriptRoad::RoadType road_type)
 224 {
 225         if (!IsValidEngine(engine_id)) return false;
 226         if (GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD) return false;
 227         if (!ScriptRoad::IsRoadTypeAvailable(road_type)) return false;
 228
 229         return ::HasPowerOnRoad((::RoadType)::RoadVehInfo(engine_id)->roadtype, (::RoadType)road_type);
 230 }
 231
 232 /* static */ ScriptRoad::RoadType ScriptEngine::GetRoadType(EngineID engine_id)
 233 {
 234         if (!IsValidEngine(engine_id)) return ScriptRoad::ROADTYPE_INVALID;
 235         if (GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD) return ScriptRoad::ROADTYPE_INVALID;
 236
 237         return (ScriptRoad::RoadType)(uint)::RoadVehInfo(engine_id)->roadtype;
 238 }
 239
 240 /* static */ ScriptRail::RailType ScriptEngine::GetRailType(EngineID engine_id)
 241 {
 242         if (!IsValidEngine(engine_id)) return ScriptRail::RAILTYPE_INVALID;
 243         if (GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return ScriptRail::RAILTYPE_INVALID;
 244
 245         return (ScriptRail::RailType)(uint)::RailVehInfo(engine_id)->railtype;
 246 }
 247
 248 /* static */ bool ScriptEngine::IsArticulated(EngineID engine_id)
 249 {
 250         if (!IsValidEngine(engine_id)) return false;
 251         if (GetVehicleType(engine_id) != ScriptVehicle::VT_ROAD && GetVehicleType(engine_id) != ScriptVehicle::VT_RAIL) return false;
 252
 253         return IsArticulatedEngine(engine_id);
 254 }
 255
 256 /* static */ ScriptAirport::PlaneType ScriptEngine::GetPlaneType(EngineID engine_id)
 257 {
 258         if (!IsValidEngine(engine_id)) return ScriptAirport::PT_INVALID;
 259         if (GetVehicleType(engine_id) != ScriptVehicle::VT_AIR) return ScriptAirport::PT_INVALID;
 260
 261         return (ScriptAirport::PlaneType)::AircraftVehInfo(engine_id)->subtype;
 262 }
 263
 264 /* static */ SQInteger ScriptEngine::GetMaximumOrderDistance(EngineID engine_id)
 265 {
 266         if (!IsValidEngine(engine_id)) return 0;
 267         if (GetVehicleType(engine_id) != ScriptVehicle::VT_AIR) return 0;
 268
 269         return (SQInteger)::Engine::Get(engine_id)->GetRange() * ::Engine::Get(engine_id)->GetRange();
 270 }
 271
 272 /* static */ bool ScriptEngine::EnableForCompany(EngineID engine_id, ScriptCompany::CompanyID company)
 273 {
 274         company = ScriptCompany::ResolveCompanyID(company);
 275
 276         EnforceDeityMode(false);
 277         EnforcePrecondition(false, IsValidEngine(engine_id));
 278         EnforcePrecondition(false, company != ScriptCompany::COMPANY_INVALID);
 279
 280         return ScriptObject::Command<CMD_ENGINE_CTRL>::Do(engine_id, (::CompanyID)company, true);
 281 }
 282
 283 /* static */ bool ScriptEngine::DisableForCompany(EngineID engine_id, ScriptCompany::CompanyID company)
 284 {
 285         company = ScriptCompany::ResolveCompanyID(company);
 286
 287         EnforceDeityMode(false);
 288         EnforcePrecondition(false, IsValidEngine(engine_id));
 289         EnforcePrecondition(false, company != ScriptCompany::COMPANY_INVALID);
 290
 291         return ScriptObject::Command<CMD_ENGINE_CTRL>::Do(engine_id, (::CompanyID)company, false);
 292 }