command_type.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef COMMAND_TYPE_H
#define COMMAND_TYPE_H
 
#include "company_type.h"
#include "economy_type.h"
#include "strings_type.h"
#include "tile_type.h"
 
struct GRFFile;

class CommandCost {
  Money cost;                                 
  StringID message;                           
  ExpensesType expense_type;                  
  bool success;                               
  Owner owner = CompanyID::Invalid(); 
  StringID extra_message = INVALID_STRING_ID; 
  EncodedString encoded_message{}; 
 
public:
  CommandCost() : cost(0), message(INVALID_STRING_ID), expense_type(INVALID_EXPENSES), success(true) {}

  explicit CommandCost(StringID msg, StringID extra_msg = INVALID_STRING_ID) : cost(0), message(msg), expense_type(INVALID_EXPENSES), success(false), extra_message(extra_msg) {}

  explicit CommandCost(ExpensesType ex_t) : cost(0), message(INVALID_STRING_ID), expense_type(ex_t), success(true) {}

  CommandCost(ExpensesType ex_t, const Money &cst) : cost(cst), message(INVALID_STRING_ID), expense_type(ex_t), success(true) {}

  inline void SetErrorOwner(Owner owner)
  {
    this->owner = owner;
  }

  void SetEncodedMessage(EncodedString &&message)
  {
    this->encoded_message = std::move(message);
  }

  EncodedString &GetEncodedMessage()
  {
    return this->encoded_message;
  }

  inline CompanyID GetErrorOwner() const
  {
    return this->owner;
  }

  inline void AddCost(const Money &cost)
  {
    this->cost += cost;
  }
 
  void AddCost(CommandCost &&cmd_cost);

  inline void MultiplyCost(int factor)
  {
    this->cost *= factor;
  }

  inline Money GetCost() const
  {
    return this->cost;
  }

  inline ExpensesType GetExpensesType() const
  {
    return this->expense_type;
  }

  void MakeError(StringID message)
  {
    assert(message != INVALID_STRING_ID);
    this->success = false;
    this->message = message;
    this->extra_message = INVALID_STRING_ID;
  }

  StringID GetErrorMessage() const
  {
    if (this->success) return INVALID_STRING_ID;
    return this->message;
  }

  StringID GetExtraErrorMessage() const
  {
    if (this->success) return INVALID_STRING_ID;
    return this->extra_message;
  }

  inline bool Succeeded() const
  {
    return this->success;
  }

  inline bool Failed() const
  {
    return !this->success;
  }
};
 
CommandCost CommandCostWithParam(StringID str, uint64_t value);
CommandCost CommandCostWithParam(StringID str, ConvertibleThroughBase auto value) { return CommandCostWithParam(str, value.base()); }

enum class Commands : uint8_t {
  BuildRailLong, 
  RemoveRailLong, 
  BuildRail, 
  RemoveRail, 
  LandscapeClear, 
  BuildBridge, 
  BuildRailStation, 
  BuildRailDepot, 
  BuildSignal, 
  RemoveSignal, 
  TerraformLand, 
  BuildObject, 
  BuildObjectArea, 
  BuildTunnel, 
 
  RemoveFromRailStation, 
  ConvertRail, 
 
  BuildRailWaypoint, 
  RenameWaypoint, 
  MoveWaypointNAme, 
  RemoveFromRailWaypoint, 
 
  BuildRoadWaypoint, 
  RemoveFromRoadWaypoint, 
 
  BuildRoadStop, 
  RemoveRoadStop, 
  BuildRoadLong, 
  RemoveRoadLong, 
  BuildRoad, 
  BuildRoadDepot, 
  ConvertRoad, 
 
  BuildAirport, 
 
  BuildDock, 
 
  BuildShipDepot, 
  BuildBuoy, 
 
  PlantTree, 
 
  BuildVehicle, 
  SellVehicle, 
  RefitVehicle, 
  SendVehicleToDepot, 
  SetVehicleVisibility, 
 
  MoveRailVehicle, 
  ForceTrainProceed, 
  ReverseTrainDirection, 
 
  ClearOrderBackup, 
  ModifyOrder, 
  SkipToOrder, 
  DeleteOrder, 
  InsertOrder, 
 
  ChangeServiceInterval, 
 
  BuildIndustry, 
  IndustrySetFlags, 
  IndustrySetExclusivity, 
  IndustrySetText, 
  IndustrySetProduction, 
 
  SetCompanyManagerFace, 
  SetCompanyColour, 
 
  IncreaseLoan, 
  DecreaseLoan, 
  SetCompanyMaxLoan, 
 
  WantEnginePreview, 
  EngineControl, 
 
  RenameVehicle, 
  RenameEngine, 
  RenameCompany, 
  RenamePresident, 
  RenameStation, 
  MoveStationName, 
  RenameDepot, 
 
  PlaceSign, 
  RenameSign, 
  MoveSign, 
 
  TurnRoadVehicle, 
 
  Pause, 
 
  BuyCompany, 
 
  FoundTown, 
  RenameTown, 
  TownAction, 
  TownCargoGoal, 
  TownGrowthRate, 
  TownRating, 
  TownSetText, 
  ExpandTown, 
  DeleteTown, 
  PlaceHouse, 
  PlaceHouseArea, 
 
  OrderRefit, 
  CloneOrder, 
  ClearArea, 
 
  MoneyCheat, 
  ChangeBankBalance, 
  BuildCanal, 
 
  CreateSubsidy, 
  CompanyControl, 
  CompanyAllowListControl, 
  CreateCustomNewsItem, 
  CreateGoal, 
  RemoveGoal, 
  SetGoalDestination, 
  SetGoalText, 
  SetGoalProgress, 
  SetGoalCompleted, 
  GoalQuestion, 
  GoalQuestionAnswer, 
  CreateStoryPage, 
  CreateStoryPageElement, 
  UpdateStoryPageElement, 
  SetStoryPageTitle, 
  SetStoryPageDate, 
  ShowStoryPage, 
  RemoveStoryPage, 
  RemoveStoryPageElement, 
  ScrollViewport, 
  StoryPageButton, 
 
  LevelLand, 
 
  BuildLock, 
 
  BuildSignalLong, 
  RemoveSignalLong, 
 
  GiveMoney, 
  ChangeSetting, 
  ChangeCompanySetting, 
 
  SetAutoreplace, 
 
  CloneVehicle, 
  StartStopVehicle, 
  MassStartStop, 
  AutoreplaceVehicle, 
  DepotMassSell, 
  DepotMassAutoreplace, 
 
  CreateGroup, 
  DeleteGroup, 
  AlterGroup, 
  AddVehicleToGroup, 
  AddSharedVehiclesToGroup, 
  RemoveAllVehiclesGroup, 
  SetGroupFlag, 
  SetGroupLivery, 
 
  MoveOrder, 
  ChangeTimetable, 
  ChangeTimetableBulk, 
  SetVehicleOnTime, 
  AutofillTimetable, 
  SetTimetableStart, 
 
  OpenCloseAirport, 
 
  CreateLeagueTable, 
  CreateLeagueTableElement, 
  UpdateLeagueTableElementData, 
  UpdateLeagueTableElementScore, 
  RemoveLeagueTableElement, 
 
  End, 
};

enum class DoCommandFlag : uint8_t {
  Execute, 
  Auto, 
  QueryCost, 
  NoWater, 
  NoTestTownRating, 
  Bankrupt, 
  AutoReplace, 
  NoCargoCapacityCheck, 
  AllTiles, 
  NoModifyTownRating, 
  ForceClearTile, 
};
using DoCommandFlags = EnumBitSet<DoCommandFlag, uint16_t>;

enum class CommandFlag : uint8_t {
  Server, 
  Spectator, 
  Offline, 
  Auto, 
  AllTiles, 
  NoTest, 
  NoWater, 
  ClientID, 
  Deity, 
  StrCtrl, 
  NoEst, 
  Location, 
};
using CommandFlags = EnumBitSet<CommandFlag, uint16_t>;

enum class CommandType : uint8_t {
  LandscapeConstruction, 
  VehicleConstruction, 
  MoneyManagement, 
  VehicleManagement, 
  RouteManagement, 
  OtherManagement, 
  CompanySetting, 
  ServerSetting, 
  Cheat, 
 
  End, 
};

 
enum class CommandPauseLevel : uint8_t {
  NoActions, 
  NoConstruction, 
  NoLandscaping, 
  AllActions, 
};
 
 
template <typename T> struct CommandFunctionTraitHelper;
template <typename... Targs>
struct CommandFunctionTraitHelper<CommandCost(*)(DoCommandFlags, Targs...)> {
  using Args = std::tuple<std::decay_t<Targs>...>;
  using RetTypes = void;
  using CbArgs = Args;
  using CbProcType = void(*)(Commands, const CommandCost &);
};
template <template <typename...> typename Tret, typename... Tretargs, typename... Targs>
struct CommandFunctionTraitHelper<Tret<CommandCost, Tretargs...>(*)(DoCommandFlags, Targs...)> {
  using Args = std::tuple<std::decay_t<Targs>...>;
  using RetTypes = std::tuple<std::decay_t<Tretargs>...>;
  using CbArgs = std::tuple<std::decay_t<Tretargs>..., std::decay_t<Targs>...>;
  using CbProcType = void(*)(Commands, const CommandCost &, Tretargs...);
};

template <Commands Tcmd> struct CommandTraits;
 
#define DEF_CMD_TRAIT(cmd_, proc_, flags_, type_) \
  template <> struct CommandTraits<cmd_> { \
    using ProcType = decltype(&proc_); \
    using Args = typename CommandFunctionTraitHelper<ProcType>::Args; \
    using RetTypes = typename CommandFunctionTraitHelper<ProcType>::RetTypes; \
    using CbArgs = typename CommandFunctionTraitHelper<ProcType>::CbArgs; \
    using RetCallbackProc = typename CommandFunctionTraitHelper<ProcType>::CbProcType; \
    static constexpr Commands cmd = cmd_; \
    static constexpr auto &proc = proc_; \
    static constexpr CommandFlags flags = flags_; \
    static constexpr CommandType type = type_; \
    static inline constexpr std::string_view name = #proc_; \
  };

typedef std::vector<uint8_t> CommandDataBuffer;

typedef void CommandCallback(Commands cmd, const CommandCost &result, TileIndex tile);

typedef void CommandCallbackData(Commands cmd, const CommandCost &result, const CommandDataBuffer &data, CommandDataBuffer result_data);
 
#endif /* COMMAND_TYPE_H */