From cb888544ce703420f642cbb96fbf4f5ef66504ec Mon Sep 17 00:00:00 2001 From: Pavel Stupnikov Date: Tue, 3 Jan 2023 15:35:06 +0400 Subject: [PATCH] Try to fix cmclient command callbacks --- gen_commands.py | 20 +- src/citymania/CMakeLists.txt | 2 + src/citymania/cm_blueprint.cpp | 2 +- src/citymania/cm_command_type.hpp | 34 +- src/citymania/cm_commands.cpp | 85 +- src/citymania/cm_commands.hpp | 15 +- src/citymania/cm_highlight.cpp | 2 +- src/citymania/cm_station_gui.cpp | 1 - src/citymania/cm_type.hpp | 7 +- src/citymania/generated/cm_gen_commands.cpp | 911 +++++++++++--------- src/citymania/generated/cm_gen_commands.hpp | 647 ++++++++------ src/command.cpp | 2 +- src/command_func.h | 4 + src/network/network_command.cpp | 7 +- src/rail_gui.cpp | 195 +---- 15 files changed, 1040 insertions(+), 894 deletions(-) diff --git a/gen_commands.py b/gen_commands.py index ecbaa054d5..d7fb565bd4 100644 --- a/gen_commands.py +++ b/gen_commands.py @@ -74,7 +74,7 @@ inline constexpr size_t _callback_tuple_size = std::tuple_size_v inline auto MakeCallbackTable(std::index_sequence) noexcept { - return std::array{{ reinterpret_cast(reinterpret_cast(std::get(_callback_tuple)))... }}; // MingW64 fails linking when casting a pointer to its own type. To work around, cast it to some other type first. + return std::array<::CommandCallback *, sizeof...(i)>{{ reinterpret_cast<::CommandCallback *>(reinterpret_cast(std::get(_callback_tuple)))... }}; // MingW64 fails linking when casting a pointer to its own type. To work around, cast it to some other type first. } /** Type-erased table of callbacks. */ static auto _callback_table = MakeCallbackTable(std::make_index_sequence<_callback_tuple_size>{});\n @@ -87,7 +87,7 @@ struct CallbackArgsHelper # pragma GCC diagnostic pop #endif -static size_t FindCallbackIndex(CommandCallback *callback) { +static size_t FindCallbackIndex(::CommandCallback *callback) { if (auto it = std::find(std::cbegin(_callback_table), std::cend(_callback_table), callback); it != std::cend(_callback_table)) { return static_cast(std::distance(std::cbegin(_callback_table), it)); } @@ -102,7 +102,7 @@ template constexpr auto MakeCallback() noexcept { /* Check if the callback matches with the command arguments. If not, don''t generate an Unpack proc. */ using Tcallback = std::tuple_element_t; - if constexpr (std::is_same_v || + if constexpr (std::is_same_v || std::is_same_v || std::is_same_v::CbArgs, typename CallbackArgsHelper::Args> || (!std::is_void_v::RetTypes> && std::is_same_v::RetCallbackProc const>::Args, typename CallbackArgsHelper::Args>)) { @@ -170,8 +170,9 @@ def run(): f.write( f' ~{name}() override {{}}\n' f'\n' - f' bool do_post(CommandCallback * callback) override;\n' - f' bool do_test() override;\n' + f' bool _post(::CommandCallback * callback) override;\n' + f' CommandCost _do(DoCommandFlag flags) override;\n' + f' Commands get_command() override;\n' f'}};\n\n' ) f.write( @@ -198,7 +199,7 @@ def run(): ' * but the table is not the same.\n' ' */\n' 'static constexpr auto _callback_tuple = std::make_tuple(\n' - ' (CommandCallback *)nullptr, // Make sure this is actually a pointer-to-function.\n' + ' (::CommandCallback *)nullptr, // Make sure this is actually a pointer-to-function.\n' ) for i, cb in enumerate(callbacks): comma = ',' if i != len(callbacks) - 1 else '' @@ -226,12 +227,13 @@ def run(): sep_args_type_list = ', ' + args_type_list sep_this_args_list = ', ' + this_args_list f.write( + f'Commands {name}::get_command() {{ return {constant}; }}\n' f'static constexpr auto _{name}_dispatch = MakeDispatchTable<{constant}{sep_args_type_list}>();\n' - f'bool {name}::do_post(CommandCallback *callback) {{\n' + f'bool {name}::_post(::CommandCallback *callback) {{\n' f' return _{name}_dispatch[FindCallbackIndex(callback)](this->error, this->tile{sep_this_args_list});\n' '}\n' - f'bool {name}::do_test() {{\n' - f' return {cost_getter}(::Command<{constant}>::Do(DC_NONE, {test_args_list})).Succeeded();\n' + f'CommandCost {name}::_do(DoCommandFlag flags) {{\n' + f' return {cost_getter}(::Command<{constant}>::Do(flags, {test_args_list}));\n' '}\n' ) f.write('\n') diff --git a/src/citymania/CMakeLists.txt b/src/citymania/CMakeLists.txt index 07302e560e..dfb08fc958 100644 --- a/src/citymania/CMakeLists.txt +++ b/src/citymania/CMakeLists.txt @@ -42,6 +42,8 @@ add_files( cm_minimap.cpp cm_misc_gui.hpp cm_misc_gui.cpp + cm_rail_gui.hpp + cm_rail_gui.cpp cm_station_gui.hpp cm_station_gui.cpp cm_tooltips.hpp diff --git a/src/citymania/cm_blueprint.cpp b/src/citymania/cm_blueprint.cpp index 8a3355db77..45ca1b4ee1 100644 --- a/src/citymania/cm_blueprint.cpp +++ b/src/citymania/cm_blueprint.cpp @@ -128,7 +128,7 @@ up GetBlueprintCommand(TileIndex start, const Blueprint::Item &item) { end_tile = new_tile; tdir = NextTrackdir(tdir); } - return make_up( + return std::make_unique( end_tile, start_tile, _cur_railtype, diff --git a/src/citymania/cm_command_type.hpp b/src/citymania/cm_command_type.hpp index 8e1d5d7bbc..caefb903e0 100644 --- a/src/citymania/cm_command_type.hpp +++ b/src/citymania/cm_command_type.hpp @@ -8,6 +8,7 @@ #include "../group_cmd.h" #include "../engine_type.h" #include "../livery.h" +#include "../network/network_type.h" #include "../misc_cmd.h" #include "../news_type.h" #include "../object_type.h" @@ -23,43 +24,59 @@ enum StationClassID : byte; namespace citymania { +typedef std::function CommandCallback; + +extern bool _auto_command; +extern CommandCallback _current_callback; + class Command { public: TileIndex tile = 0; bool automatic = false; CompanyID company = INVALID_COMPANY; StringID error = (StringID)0; + CommandCallback callback = nullptr; Command() {} Command(TileIndex tile) :tile{tile} {} virtual ~Command() {} - virtual bool do_post(CommandCallback *callback)=0; - virtual bool do_test()=0; + virtual bool _post(::CommandCallback *callback)=0; + virtual CommandCost _do(DoCommandFlag flags)=0; + virtual Commands get_command()=0; template bool post(Tcallback callback) { CompanyID old = _current_company; if (this->company != INVALID_COMPANY) _current_company = company; - bool res = this->do_post(reinterpret_cast(reinterpret_cast(callback))); + _auto_command = this->automatic; + _current_callback = this->callback; + bool res = this->_post(reinterpret_cast<::CommandCallback *>(reinterpret_cast(callback))); + assert(_current_callback == nullptr); + _current_callback = nullptr; + _auto_command = false; _current_company = old; return res; } bool post() { - return this->post(nullptr); + return this->post<::CommandCallback *>(nullptr); } - bool test() { + CommandCost call(DoCommandFlag flags) { CompanyID old = _current_company; if (this->company != INVALID_COMPANY) _current_company = company; - bool res = this->do_test(); + auto res = this->_do(flags); _current_company = old; return res; } + bool test() { + return this->call(DC_NONE).Succeeded(); + } + Command &with_tile(TileIndex tile) { this->tile = tile; return *this; @@ -79,6 +96,11 @@ public: this->company = company; return *this; } + + Command &with_callback(CommandCallback callback) { + this->callback = callback; + return *this; + } }; } // namaespace citymania diff --git a/src/citymania/cm_commands.cpp b/src/citymania/cm_commands.cpp index 875afff464..934a401855 100644 --- a/src/citymania/cm_commands.cpp +++ b/src/citymania/cm_commands.cpp @@ -3,10 +3,13 @@ #include "cm_commands.hpp" #include "../command_func.h" +#include "../debug.h" #include "../network/network.h" #include "../network/network_client.h" #include +#include + namespace citymania { @@ -14,6 +17,9 @@ const uint32 MAX_CALLBACK_LIFETIME = 30; // it should be executed within few fr std::map>> _command_callbacks; std::queue> _command_sent; +CommandCallback _current_callback = nullptr; +bool _auto_command = false; +std::queue> _callback_queue; uint GetCurrentQueueDelay(); @@ -24,11 +30,62 @@ void hash_combine(std::size_t& seed, const T& v, const Rest&... rest) (hash_combine(seed, rest), ...); } -size_t GetCommandHash(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text) { +} // namespace citymania +namespace std { + template + struct hash> { + typedef std::vector argument_type; + typedef std::size_t result_type; + result_type operator()(argument_type const& in) const { + size_t size = in.size(); + size_t seed = 0; + for (size_t i = 0; i < size; i++) + citymania::hash_combine(seed, in[i]); + return seed; + } + }; +} // namespace std +namespace citymania { + +size_t GetCommandHash(Commands cmd, CompanyID company_id, StringID err_msg, ::CommandCallback callback, TileIndex tile, const CommandDataBuffer &data) { size_t res = 0; - // hash_combine(res, tile, p1, p2, cmd, text); + hash_combine(res, cmd, (uint16)company_id, err_msg, callback, (uint32)tile, data); return res; } + +void ExecuteCurrentCallback(const CommandCost &cost) { + if (_current_callback != nullptr) { + _current_callback(cost.Succeeded()); + _current_callback == nullptr; + } +} + +void BeforeNetworkCommandExecution(const CommandPacket* cp) { + if (!cp->my_cmd) return; + size_t hash = GetCommandHash(cp->cmd, cp->company, cp->err_msg, cp->callback, cp->tile, cp->data); + while (!_callback_queue.empty() && _callback_queue.front().first != hash) { + Debug(misc, 0, "CM Dismissing command from callback queue: cmd={}", cp->cmd); + _callback_queue.pop(); + } + if (_callback_queue.empty()) { + Debug(misc, 0, "CM Received unexpected network command: cmd={}", cp->cmd); + return; + } + _current_callback = _callback_queue.front().second; + _callback_queue.pop(); + return; +} + +void AfterNetworkCommandExecution(const CommandPacket* cp) { + _current_callback = nullptr; +} + +void AddCommandCallback(const CommandPacket *cp) { + size_t hash = GetCommandHash(cp->cmd, cp->company, cp->err_msg, cp->callback, cp->tile, cp->data); + _callback_queue.push(std::make_pair(hash, _current_callback)); + _current_callback = nullptr; +} + /* void AddCommandCallback(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text, CommandCallback callback) { if (!_networking) { @@ -43,21 +100,8 @@ void AddCommandCallback(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const // fprintf(stderr, "CALLBACK %lu (%u %u %u %u %s)\n", hash, tile, p1, p2, (uint)(cmd & CMD_ID_MASK), text.c_str()); } -bool DoCommandWithCallback(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, ::CommandCallback *callback, const std::string &text, CommandCallback cm_callback) { - if (_networking) { - AddCommandCallback(tile, p1, p2, cmd, text, cm_callback); - return DoCommandP(tile, p1, p2, cmd, callback, text); - } - auto res = DoCommandP(tile, p1, p2, cmd, callback, text); - cm_callback(res); - return res; -} - -bool DoCommandWithCallback(const CommandContainer &cc, CommandCallback callback) { - return DoCommandWithCallback(cc.tile, cc.p1, cc.p2, cc.cmd, cc.callback, cc.text, callback); -} */ -void HandleCommandExecution(bool res, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text) { +//void HandleCommandExecution(bool res, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text) { /* FIXME auto hash = GetCommandHash(tile, p1, p2, cmd & CMD_ID_MASK, text); auto p = _command_callbacks.find(hash); @@ -66,7 +110,7 @@ void HandleCommandExecution(bool res, TileIndex tile, uint32 p1, uint32 p2, uint for (auto &cb : p->second.second) cb(res); _command_callbacks.erase(p); */ -} +//} void ClearOldCallbacks() { while(!_command_sent.empty() && _command_sent.front().second + MAX_CALLBACK_LIFETIME < _frame_counter) { @@ -107,16 +151,17 @@ void FlushCommandQueue() { void HandleNextClientFrame() { _commands_this_frame = 0; FlushCommandQueue(); - ClearOldCallbacks(); + // ClearOldCallbacks(); } -/*void SendClientCommand(const CommandPacket *cp) { +void SendClientCommand(const CommandPacket *cp) { + AddCommandCallback(cp); if (_outgoing_queue.empty() && CanSendCommand()) { MyClient::SendCommand(cp); _commands_this_frame++; return; } _outgoing_queue.push(*cp); -}*/ +} } // namespace citymania diff --git a/src/citymania/cm_commands.hpp b/src/citymania/cm_commands.hpp index d6dc226f36..2158648fc3 100644 --- a/src/citymania/cm_commands.hpp +++ b/src/citymania/cm_commands.hpp @@ -3,21 +3,22 @@ #include "../command_type.h" #include "../tile_type.h" -#include "../network/network_internal.h" #include "generated/cm_gen_commands.hpp" +struct CommandPacket; + namespace citymania { -typedef std::function CommandCallback; -// void AddCommandCallback(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text, CommandCallback callback); -// bool DoCommandWithCallback(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, ::CommandCallback *callback, const std::string &text, CommandCallback cm_callback); -// bool DoCommandWithCallback(const CommandContainer &cc, CommandCallback callback); -void HandleCommandExecution(bool res, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text); +// void HandleCommandExecution(bool res, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text); +void AddCommandCallback(const CommandPacket *cp); +void ExecuteCurrentCallback(const CommandCost &cost); +void BeforeNetworkCommandExecution(const CommandPacket* cp); +void AfterNetworkCommandExecution(const CommandPacket* cp); void InitCommandQueue(); void HandleNextClientFrame(); -// void SendClientCommand(const CommandPacket *cp); +void SendClientCommand(const CommandPacket *cp); } // namespace citymania diff --git a/src/citymania/cm_highlight.cpp b/src/citymania/cm_highlight.cpp index d5a9e8b46e..3125737bbd 100644 --- a/src/citymania/cm_highlight.cpp +++ b/src/citymania/cm_highlight.cpp @@ -472,7 +472,7 @@ void ObjectHighlight::UpdateTiles() { auto add_track = [this, z](TileIndex tile, TileIndex end_tile, Trackdir trackdir, SpriteID palette, TileIndex point1, TileIndex point2) { if (trackdir == INVALID_TRACKDIR) return; - for(;;) { + while(tile <= MapSize()) { this->sprites.emplace_back( RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, z * TILE_HEIGHT + 7 /* z_offset */), SPR_AUTORAIL_BASE + _AutorailTilehSprite[0][TrackdirToTrack(trackdir)], diff --git a/src/citymania/cm_station_gui.cpp b/src/citymania/cm_station_gui.cpp index f6cb78ef0b..e69a6bc9b6 100644 --- a/src/citymania/cm_station_gui.cpp +++ b/src/citymania/cm_station_gui.cpp @@ -31,7 +31,6 @@ #include - extern const Station *_viewport_highlight_station; extern TileHighlightData _thd; extern void MarkCatchmentTilesDirty(); diff --git a/src/citymania/cm_type.hpp b/src/citymania/cm_type.hpp index d2b0b42597..79135ea837 100644 --- a/src/citymania/cm_type.hpp +++ b/src/citymania/cm_type.hpp @@ -43,6 +43,10 @@ template typename _Unique_if::_Known_bound make_up(Args&&...) = delete; +// template const auto make_up = std::make_unique; +// template const auto make_sp = std::make_shared; +template const auto make_sp = std::make_shared; + enum class GameType: uint8 { GENERIC = 0, @@ -65,9 +69,6 @@ enum class ControllerType: uint8 { TOWN_DEFENCE = 6, }; -// template const auto make_up = std::make_unique; -// template const auto make_sp = std::make_shared; - } // namespace citymania #endif diff --git a/src/citymania/generated/cm_gen_commands.cpp b/src/citymania/generated/cm_gen_commands.cpp index 9a5dc552d8..d40deacbbd 100644 --- a/src/citymania/generated/cm_gen_commands.cpp +++ b/src/citymania/generated/cm_gen_commands.cpp @@ -18,7 +18,7 @@ namespace cmd { * but the table is not the same. */ static constexpr auto _callback_tuple = std::make_tuple( - (CommandCallback *)nullptr, // Make sure this is actually a pointer-to-function. + (::CommandCallback *)nullptr, // Make sure this is actually a pointer-to-function. &CcBuildDocks, &CcPlaySound_CONSTRUCTION_WATER, &CcBuildPrimaryVehicle, @@ -54,7 +54,7 @@ inline constexpr size_t _callback_tuple_size = std::tuple_size_v inline auto MakeCallbackTable(std::index_sequence) noexcept { - return std::array{{ reinterpret_cast(reinterpret_cast(std::get(_callback_tuple)))... }}; // MingW64 fails linking when casting a pointer to its own type. To work around, cast it to some other type first. + return std::array<::CommandCallback *, sizeof...(i)>{{ reinterpret_cast<::CommandCallback *>(reinterpret_cast(std::get(_callback_tuple)))... }}; // MingW64 fails linking when casting a pointer to its own type. To work around, cast it to some other type first. } /** Type-erased table of callbacks. */ static auto _callback_table = MakeCallbackTable(std::make_index_sequence<_callback_tuple_size>{}); @@ -68,7 +68,7 @@ struct CallbackArgsHelper # pragma GCC diagnostic pop #endif -static size_t FindCallbackIndex(CommandCallback *callback) { +static size_t FindCallbackIndex(::CommandCallback *callback) { if (auto it = std::find(std::cbegin(_callback_table), std::cend(_callback_table), callback); it != std::cend(_callback_table)) { return static_cast(std::distance(std::cbegin(_callback_table), it)); } @@ -83,7 +83,7 @@ template constexpr auto MakeCallback() noexcept { /* Check if the callback matches with the command arguments. If not, don''t generate an Unpack proc. */ using Tcallback = std::tuple_element_t; - if constexpr (std::is_same_v || + if constexpr (std::is_same_v || std::is_same_v || std::is_same_v::CbArgs, typename CallbackArgsHelper::Args> || (!std::is_void_v::RetTypes> && std::is_same_v::RetCallbackProc const>::Args, typename CallbackArgsHelper::Args>)) { @@ -105,1036 +105,1165 @@ inline constexpr auto MakeDispatchTable() noexcept return MakeDispatchTableHelper(std::make_index_sequence<_callback_tuple_size>{}); } +Commands CreateGoal::get_command() { return CMD_CREATE_GOAL; } static constexpr auto _CreateGoal_dispatch = MakeDispatchTable(); -bool CreateGoal::do_post(CommandCallback *callback) { +bool CreateGoal::_post(::CommandCallback *callback) { return _CreateGoal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->company, this->type, this->dest, this->text); } -bool CreateGoal::do_test() { - return std::get<0>(::Command::Do(DC_NONE, company, type, dest, text)).Succeeded(); +CommandCost CreateGoal::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, company, type, dest, text)); } +Commands RemoveGoal::get_command() { return CMD_REMOVE_GOAL; } static constexpr auto _RemoveGoal_dispatch = MakeDispatchTable(); -bool RemoveGoal::do_post(CommandCallback *callback) { +bool RemoveGoal::_post(::CommandCallback *callback) { return _RemoveGoal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->goal); } -bool RemoveGoal::do_test() { - return (::Command::Do(DC_NONE, goal)).Succeeded(); +CommandCost RemoveGoal::_do(DoCommandFlag flags) { + return (::Command::Do(flags, goal)); } +Commands SetGoalText::get_command() { return CMD_SET_GOAL_TEXT; } static constexpr auto _SetGoalText_dispatch = MakeDispatchTable(); -bool SetGoalText::do_post(CommandCallback *callback) { +bool SetGoalText::_post(::CommandCallback *callback) { return _SetGoalText_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->goal, this->text); } -bool SetGoalText::do_test() { - return (::Command::Do(DC_NONE, goal, text)).Succeeded(); +CommandCost SetGoalText::_do(DoCommandFlag flags) { + return (::Command::Do(flags, goal, text)); } +Commands SetGoalProgress::get_command() { return CMD_SET_GOAL_PROGRESS; } static constexpr auto _SetGoalProgress_dispatch = MakeDispatchTable(); -bool SetGoalProgress::do_post(CommandCallback *callback) { +bool SetGoalProgress::_post(::CommandCallback *callback) { return _SetGoalProgress_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->goal, this->text); } -bool SetGoalProgress::do_test() { - return (::Command::Do(DC_NONE, goal, text)).Succeeded(); +CommandCost SetGoalProgress::_do(DoCommandFlag flags) { + return (::Command::Do(flags, goal, text)); } +Commands SetGoalCompleted::get_command() { return CMD_SET_GOAL_COMPLETED; } static constexpr auto _SetGoalCompleted_dispatch = MakeDispatchTable(); -bool SetGoalCompleted::do_post(CommandCallback *callback) { +bool SetGoalCompleted::_post(::CommandCallback *callback) { return _SetGoalCompleted_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->goal, this->completed); } -bool SetGoalCompleted::do_test() { - return (::Command::Do(DC_NONE, goal, completed)).Succeeded(); +CommandCost SetGoalCompleted::_do(DoCommandFlag flags) { + return (::Command::Do(flags, goal, completed)); } +Commands GoalQuestion::get_command() { return CMD_GOAL_QUESTION; } static constexpr auto _GoalQuestion_dispatch = MakeDispatchTable(); -bool GoalQuestion::do_post(CommandCallback *callback) { +bool GoalQuestion::_post(::CommandCallback *callback) { return _GoalQuestion_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->uniqueid, this->target, this->is_client, this->button_mask, this->type, this->text); } -bool GoalQuestion::do_test() { - return (::Command::Do(DC_NONE, uniqueid, target, is_client, button_mask, type, text)).Succeeded(); +CommandCost GoalQuestion::_do(DoCommandFlag flags) { + return (::Command::Do(flags, uniqueid, target, is_client, button_mask, type, text)); } +Commands GoalQuestionAnswer::get_command() { return CMD_GOAL_QUESTION_ANSWER; } static constexpr auto _GoalQuestionAnswer_dispatch = MakeDispatchTable(); -bool GoalQuestionAnswer::do_post(CommandCallback *callback) { +bool GoalQuestionAnswer::_post(::CommandCallback *callback) { return _GoalQuestionAnswer_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->uniqueid, this->button); } -bool GoalQuestionAnswer::do_test() { - return (::Command::Do(DC_NONE, uniqueid, button)).Succeeded(); +CommandCost GoalQuestionAnswer::_do(DoCommandFlag flags) { + return (::Command::Do(flags, uniqueid, button)); } +Commands CustomNewsItem::get_command() { return CMD_CUSTOM_NEWS_ITEM; } static constexpr auto _CustomNewsItem_dispatch = MakeDispatchTable(); -bool CustomNewsItem::do_post(CommandCallback *callback) { +bool CustomNewsItem::_post(::CommandCallback *callback) { return _CustomNewsItem_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->type, this->reftype1, this->company, this->reference, this->text); } -bool CustomNewsItem::do_test() { - return (::Command::Do(DC_NONE, type, reftype1, company, reference, text)).Succeeded(); +CommandCost CustomNewsItem::_do(DoCommandFlag flags) { + return (::Command::Do(flags, type, reftype1, company, reference, text)); } +Commands CreateStoryPage::get_command() { return CMD_CREATE_STORY_PAGE; } static constexpr auto _CreateStoryPage_dispatch = MakeDispatchTable(); -bool CreateStoryPage::do_post(CommandCallback *callback) { +bool CreateStoryPage::_post(::CommandCallback *callback) { return _CreateStoryPage_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->company, this->text); } -bool CreateStoryPage::do_test() { - return std::get<0>(::Command::Do(DC_NONE, company, text)).Succeeded(); +CommandCost CreateStoryPage::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, company, text)); } +Commands CreateStoryPageElement::get_command() { return CMD_CREATE_STORY_PAGE_ELEMENT; } static constexpr auto _CreateStoryPageElement_dispatch = MakeDispatchTable(); -bool CreateStoryPageElement::do_post(CommandCallback *callback) { +bool CreateStoryPageElement::_post(::CommandCallback *callback) { return _CreateStoryPageElement_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_id, this->type, this->reference, this->text); } -bool CreateStoryPageElement::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, page_id, type, reference, text)).Succeeded(); +CommandCost CreateStoryPageElement::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, page_id, type, reference, text)); } +Commands UpdateStoryPageElement::get_command() { return CMD_UPDATE_STORY_PAGE_ELEMENT; } static constexpr auto _UpdateStoryPageElement_dispatch = MakeDispatchTable(); -bool UpdateStoryPageElement::do_post(CommandCallback *callback) { +bool UpdateStoryPageElement::_post(::CommandCallback *callback) { return _UpdateStoryPageElement_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_element_id, this->reference, this->text); } -bool UpdateStoryPageElement::do_test() { - return (::Command::Do(DC_NONE, this->tile, page_element_id, reference, text)).Succeeded(); +CommandCost UpdateStoryPageElement::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, page_element_id, reference, text)); } +Commands SetStoryPageTitle::get_command() { return CMD_SET_STORY_PAGE_TITLE; } static constexpr auto _SetStoryPageTitle_dispatch = MakeDispatchTable(); -bool SetStoryPageTitle::do_post(CommandCallback *callback) { +bool SetStoryPageTitle::_post(::CommandCallback *callback) { return _SetStoryPageTitle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_id, this->text); } -bool SetStoryPageTitle::do_test() { - return (::Command::Do(DC_NONE, page_id, text)).Succeeded(); +CommandCost SetStoryPageTitle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, page_id, text)); } +Commands SetStoryPageDate::get_command() { return CMD_SET_STORY_PAGE_DATE; } static constexpr auto _SetStoryPageDate_dispatch = MakeDispatchTable(); -bool SetStoryPageDate::do_post(CommandCallback *callback) { +bool SetStoryPageDate::_post(::CommandCallback *callback) { return _SetStoryPageDate_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_id, this->date); } -bool SetStoryPageDate::do_test() { - return (::Command::Do(DC_NONE, page_id, date)).Succeeded(); +CommandCost SetStoryPageDate::_do(DoCommandFlag flags) { + return (::Command::Do(flags, page_id, date)); } +Commands ShowStoryPage::get_command() { return CMD_SHOW_STORY_PAGE; } static constexpr auto _ShowStoryPage_dispatch = MakeDispatchTable(); -bool ShowStoryPage::do_post(CommandCallback *callback) { +bool ShowStoryPage::_post(::CommandCallback *callback) { return _ShowStoryPage_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_id); } -bool ShowStoryPage::do_test() { - return (::Command::Do(DC_NONE, page_id)).Succeeded(); +CommandCost ShowStoryPage::_do(DoCommandFlag flags) { + return (::Command::Do(flags, page_id)); } +Commands RemoveStoryPage::get_command() { return CMD_REMOVE_STORY_PAGE; } static constexpr auto _RemoveStoryPage_dispatch = MakeDispatchTable(); -bool RemoveStoryPage::do_post(CommandCallback *callback) { +bool RemoveStoryPage::_post(::CommandCallback *callback) { return _RemoveStoryPage_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_id); } -bool RemoveStoryPage::do_test() { - return (::Command::Do(DC_NONE, page_id)).Succeeded(); +CommandCost RemoveStoryPage::_do(DoCommandFlag flags) { + return (::Command::Do(flags, page_id)); } +Commands RemoveStoryPageElement::get_command() { return CMD_REMOVE_STORY_PAGE_ELEMENT; } static constexpr auto _RemoveStoryPageElement_dispatch = MakeDispatchTable(); -bool RemoveStoryPageElement::do_post(CommandCallback *callback) { +bool RemoveStoryPageElement::_post(::CommandCallback *callback) { return _RemoveStoryPageElement_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_element_id); } -bool RemoveStoryPageElement::do_test() { - return (::Command::Do(DC_NONE, page_element_id)).Succeeded(); +CommandCost RemoveStoryPageElement::_do(DoCommandFlag flags) { + return (::Command::Do(flags, page_element_id)); } +Commands StoryPageButton::get_command() { return CMD_STORY_PAGE_BUTTON; } static constexpr auto _StoryPageButton_dispatch = MakeDispatchTable(); -bool StoryPageButton::do_post(CommandCallback *callback) { +bool StoryPageButton::_post(::CommandCallback *callback) { return _StoryPageButton_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->page_element_id, this->reference); } -bool StoryPageButton::do_test() { - return (::Command::Do(DC_NONE, this->tile, page_element_id, reference)).Succeeded(); +CommandCost StoryPageButton::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, page_element_id, reference)); } +Commands BuildVehicle::get_command() { return CMD_BUILD_VEHICLE; } static constexpr auto _BuildVehicle_dispatch = MakeDispatchTable(); -bool BuildVehicle::do_post(CommandCallback *callback) { +bool BuildVehicle::_post(::CommandCallback *callback) { return _BuildVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->eid, this->use_free_vehicles, this->cargo, this->client_id); } -bool BuildVehicle::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, eid, use_free_vehicles, cargo, client_id)).Succeeded(); +CommandCost BuildVehicle::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, eid, use_free_vehicles, cargo, client_id)); } +Commands SellVehicle::get_command() { return CMD_SELL_VEHICLE; } static constexpr auto _SellVehicle_dispatch = MakeDispatchTable(); -bool SellVehicle::do_post(CommandCallback *callback) { +bool SellVehicle::_post(::CommandCallback *callback) { return _SellVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->v_id, this->sell_chain, this->backup_order, this->client_id); } -bool SellVehicle::do_test() { - return (::Command::Do(DC_NONE, v_id, sell_chain, backup_order, client_id)).Succeeded(); +CommandCost SellVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, v_id, sell_chain, backup_order, client_id)); } +Commands RefitVehicle::get_command() { return CMD_REFIT_VEHICLE; } static constexpr auto _RefitVehicle_dispatch = MakeDispatchTable(); -bool RefitVehicle::do_post(CommandCallback *callback) { +bool RefitVehicle::_post(::CommandCallback *callback) { return _RefitVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->new_cid, this->new_subtype, this->auto_refit, this->only_this, this->num_vehicles); } -bool RefitVehicle::do_test() { - return std::get<0>(::Command::Do(DC_NONE, veh_id, new_cid, new_subtype, auto_refit, only_this, num_vehicles)).Succeeded(); +CommandCost RefitVehicle::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, veh_id, new_cid, new_subtype, auto_refit, only_this, num_vehicles)); } +Commands SendVehicleToDepot::get_command() { return CMD_SEND_VEHICLE_TO_DEPOT; } static constexpr auto _SendVehicleToDepot_dispatch = MakeDispatchTable(); -bool SendVehicleToDepot::do_post(CommandCallback *callback) { +bool SendVehicleToDepot::_post(::CommandCallback *callback) { return _SendVehicleToDepot_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->depot_cmd, this->vli); } -bool SendVehicleToDepot::do_test() { - return (::Command::Do(DC_NONE, veh_id, depot_cmd, vli)).Succeeded(); +CommandCost SendVehicleToDepot::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, depot_cmd, vli)); } +Commands ChangeServiceInt::get_command() { return CMD_CHANGE_SERVICE_INT; } static constexpr auto _ChangeServiceInt_dispatch = MakeDispatchTable(); -bool ChangeServiceInt::do_post(CommandCallback *callback) { +bool ChangeServiceInt::_post(::CommandCallback *callback) { return _ChangeServiceInt_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->serv_int, this->is_custom, this->is_percent); } -bool ChangeServiceInt::do_test() { - return (::Command::Do(DC_NONE, veh_id, serv_int, is_custom, is_percent)).Succeeded(); +CommandCost ChangeServiceInt::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, serv_int, is_custom, is_percent)); } +Commands RenameVehicle::get_command() { return CMD_RENAME_VEHICLE; } static constexpr auto _RenameVehicle_dispatch = MakeDispatchTable(); -bool RenameVehicle::do_post(CommandCallback *callback) { +bool RenameVehicle::_post(::CommandCallback *callback) { return _RenameVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->text); } -bool RenameVehicle::do_test() { - return (::Command::Do(DC_NONE, veh_id, text)).Succeeded(); +CommandCost RenameVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, text)); } +Commands CloneVehicle::get_command() { return CMD_CLONE_VEHICLE; } static constexpr auto _CloneVehicle_dispatch = MakeDispatchTable(); -bool CloneVehicle::do_post(CommandCallback *callback) { +bool CloneVehicle::_post(::CommandCallback *callback) { return _CloneVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->share_orders); } -bool CloneVehicle::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, veh_id, share_orders)).Succeeded(); +CommandCost CloneVehicle::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, veh_id, share_orders)); } +Commands StartStopVehicle::get_command() { return CMD_START_STOP_VEHICLE; } static constexpr auto _StartStopVehicle_dispatch = MakeDispatchTable(); -bool StartStopVehicle::do_post(CommandCallback *callback) { +bool StartStopVehicle::_post(::CommandCallback *callback) { return _StartStopVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->evaluate_startstop_cb); } -bool StartStopVehicle::do_test() { - return (::Command::Do(DC_NONE, veh_id, evaluate_startstop_cb)).Succeeded(); +CommandCost StartStopVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, evaluate_startstop_cb)); } +Commands MassStartStopVehicle::get_command() { return CMD_MASS_START_STOP; } static constexpr auto _MassStartStopVehicle_dispatch = MakeDispatchTable(); -bool MassStartStopVehicle::do_post(CommandCallback *callback) { +bool MassStartStopVehicle::_post(::CommandCallback *callback) { return _MassStartStopVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->do_start, this->vehicle_list_window, this->vli); } -bool MassStartStopVehicle::do_test() { - return (::Command::Do(DC_NONE, this->tile, do_start, vehicle_list_window, vli)).Succeeded(); +CommandCost MassStartStopVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, do_start, vehicle_list_window, vli)); } +Commands DepotSellAllVehicles::get_command() { return CMD_DEPOT_SELL_ALL_VEHICLES; } static constexpr auto _DepotSellAllVehicles_dispatch = MakeDispatchTable(); -bool DepotSellAllVehicles::do_post(CommandCallback *callback) { +bool DepotSellAllVehicles::_post(::CommandCallback *callback) { return _DepotSellAllVehicles_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->vehicle_type); } -bool DepotSellAllVehicles::do_test() { - return (::Command::Do(DC_NONE, this->tile, vehicle_type)).Succeeded(); +CommandCost DepotSellAllVehicles::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, vehicle_type)); } +Commands DepotMassAutoReplace::get_command() { return CMD_DEPOT_MASS_AUTOREPLACE; } static constexpr auto _DepotMassAutoReplace_dispatch = MakeDispatchTable(); -bool DepotMassAutoReplace::do_post(CommandCallback *callback) { +bool DepotMassAutoReplace::_post(::CommandCallback *callback) { return _DepotMassAutoReplace_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->vehicle_type); } -bool DepotMassAutoReplace::do_test() { - return (::Command::Do(DC_NONE, this->tile, vehicle_type)).Succeeded(); +CommandCost DepotMassAutoReplace::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, vehicle_type)); } +Commands ChangeSetting::get_command() { return CMD_CHANGE_SETTING; } static constexpr auto _ChangeSetting_dispatch = MakeDispatchTable(); -bool ChangeSetting::do_post(CommandCallback *callback) { +bool ChangeSetting::_post(::CommandCallback *callback) { return _ChangeSetting_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->name, this->value); } -bool ChangeSetting::do_test() { - return (::Command::Do(DC_NONE, name, value)).Succeeded(); +CommandCost ChangeSetting::_do(DoCommandFlag flags) { + return (::Command::Do(flags, name, value)); } +Commands ChangeCompanySetting::get_command() { return CMD_CHANGE_COMPANY_SETTING; } static constexpr auto _ChangeCompanySetting_dispatch = MakeDispatchTable(); -bool ChangeCompanySetting::do_post(CommandCallback *callback) { +bool ChangeCompanySetting::_post(::CommandCallback *callback) { return _ChangeCompanySetting_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->name, this->value); } -bool ChangeCompanySetting::do_test() { - return (::Command::Do(DC_NONE, name, value)).Succeeded(); +CommandCost ChangeCompanySetting::_do(DoCommandFlag flags) { + return (::Command::Do(flags, name, value)); } +Commands CreateGroup::get_command() { return CMD_CREATE_GROUP; } static constexpr auto _CreateGroup_dispatch = MakeDispatchTable(); -bool CreateGroup::do_post(CommandCallback *callback) { +bool CreateGroup::_post(::CommandCallback *callback) { return _CreateGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->vt, this->parent_group); } -bool CreateGroup::do_test() { - return std::get<0>(::Command::Do(DC_NONE, vt, parent_group)).Succeeded(); +CommandCost CreateGroup::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, vt, parent_group)); } +Commands AlterGroup::get_command() { return CMD_ALTER_GROUP; } static constexpr auto _AlterGroup_dispatch = MakeDispatchTable(); -bool AlterGroup::do_post(CommandCallback *callback) { +bool AlterGroup::_post(::CommandCallback *callback) { return _AlterGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->mode, this->group_id, this->parent_id, this->text); } -bool AlterGroup::do_test() { - return (::Command::Do(DC_NONE, mode, group_id, parent_id, text)).Succeeded(); +CommandCost AlterGroup::_do(DoCommandFlag flags) { + return (::Command::Do(flags, mode, group_id, parent_id, text)); } +Commands DeleteGroup::get_command() { return CMD_DELETE_GROUP; } static constexpr auto _DeleteGroup_dispatch = MakeDispatchTable(); -bool DeleteGroup::do_post(CommandCallback *callback) { +bool DeleteGroup::_post(::CommandCallback *callback) { return _DeleteGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->group_id); } -bool DeleteGroup::do_test() { - return (::Command::Do(DC_NONE, group_id)).Succeeded(); +CommandCost DeleteGroup::_do(DoCommandFlag flags) { + return (::Command::Do(flags, group_id)); } +Commands AddVehicleGroup::get_command() { return CMD_ADD_VEHICLE_GROUP; } static constexpr auto _AddVehicleGroup_dispatch = MakeDispatchTable(); -bool AddVehicleGroup::do_post(CommandCallback *callback) { +bool AddVehicleGroup::_post(::CommandCallback *callback) { return _AddVehicleGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->group_id, this->veh_id, this->add_shared); } -bool AddVehicleGroup::do_test() { - return std::get<0>(::Command::Do(DC_NONE, group_id, veh_id, add_shared)).Succeeded(); +CommandCost AddVehicleGroup::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, group_id, veh_id, add_shared)); } +Commands AddSharedVehicleGroup::get_command() { return CMD_ADD_SHARED_VEHICLE_GROUP; } static constexpr auto _AddSharedVehicleGroup_dispatch = MakeDispatchTable(); -bool AddSharedVehicleGroup::do_post(CommandCallback *callback) { +bool AddSharedVehicleGroup::_post(::CommandCallback *callback) { return _AddSharedVehicleGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->id_g, this->type); } -bool AddSharedVehicleGroup::do_test() { - return (::Command::Do(DC_NONE, id_g, type)).Succeeded(); +CommandCost AddSharedVehicleGroup::_do(DoCommandFlag flags) { + return (::Command::Do(flags, id_g, type)); } +Commands RemoveAllVehiclesGroup::get_command() { return CMD_REMOVE_ALL_VEHICLES_GROUP; } static constexpr auto _RemoveAllVehiclesGroup_dispatch = MakeDispatchTable(); -bool RemoveAllVehiclesGroup::do_post(CommandCallback *callback) { +bool RemoveAllVehiclesGroup::_post(::CommandCallback *callback) { return _RemoveAllVehiclesGroup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->group_id); } -bool RemoveAllVehiclesGroup::do_test() { - return (::Command::Do(DC_NONE, group_id)).Succeeded(); +CommandCost RemoveAllVehiclesGroup::_do(DoCommandFlag flags) { + return (::Command::Do(flags, group_id)); } +Commands SetGroupFlag::get_command() { return CMD_SET_GROUP_FLAG; } static constexpr auto _SetGroupFlag_dispatch = MakeDispatchTable(); -bool SetGroupFlag::do_post(CommandCallback *callback) { +bool SetGroupFlag::_post(::CommandCallback *callback) { return _SetGroupFlag_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->group_id, this->flag, this->value, this->recursive); } -bool SetGroupFlag::do_test() { - return (::Command::Do(DC_NONE, group_id, flag, value, recursive)).Succeeded(); +CommandCost SetGroupFlag::_do(DoCommandFlag flags) { + return (::Command::Do(flags, group_id, flag, value, recursive)); } +Commands SetGroupLivery::get_command() { return CMD_SET_GROUP_LIVERY; } static constexpr auto _SetGroupLivery_dispatch = MakeDispatchTable(); -bool SetGroupLivery::do_post(CommandCallback *callback) { +bool SetGroupLivery::_post(::CommandCallback *callback) { return _SetGroupLivery_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->group_id, this->primary, this->colour); } -bool SetGroupLivery::do_test() { - return (::Command::Do(DC_NONE, group_id, primary, colour)).Succeeded(); +CommandCost SetGroupLivery::_do(DoCommandFlag flags) { + return (::Command::Do(flags, group_id, primary, colour)); } +Commands TurnRoadVeh::get_command() { return CMD_TURN_ROADVEH; } static constexpr auto _TurnRoadVeh_dispatch = MakeDispatchTable(); -bool TurnRoadVeh::do_post(CommandCallback *callback) { +bool TurnRoadVeh::_post(::CommandCallback *callback) { return _TurnRoadVeh_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id); } -bool TurnRoadVeh::do_test() { - return (::Command::Do(DC_NONE, veh_id)).Succeeded(); +CommandCost TurnRoadVeh::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id)); } +Commands ChangeTimetable::get_command() { return CMD_CHANGE_TIMETABLE; } static constexpr auto _ChangeTimetable_dispatch = MakeDispatchTable(); -bool ChangeTimetable::do_post(CommandCallback *callback) { +bool ChangeTimetable::_post(::CommandCallback *callback) { return _ChangeTimetable_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->order_number, this->mtf, this->data); } -bool ChangeTimetable::do_test() { - return (::Command::Do(DC_NONE, veh, order_number, mtf, data)).Succeeded(); +CommandCost ChangeTimetable::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, order_number, mtf, data)); } +Commands SetVehicleOnTime::get_command() { return CMD_SET_VEHICLE_ON_TIME; } static constexpr auto _SetVehicleOnTime_dispatch = MakeDispatchTable(); -bool SetVehicleOnTime::do_post(CommandCallback *callback) { +bool SetVehicleOnTime::_post(::CommandCallback *callback) { return _SetVehicleOnTime_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh); } -bool SetVehicleOnTime::do_test() { - return (::Command::Do(DC_NONE, veh)).Succeeded(); +CommandCost SetVehicleOnTime::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh)); } +Commands AutofillTimetable::get_command() { return CMD_AUTOFILL_TIMETABLE; } static constexpr auto _AutofillTimetable_dispatch = MakeDispatchTable(); -bool AutofillTimetable::do_post(CommandCallback *callback) { +bool AutofillTimetable::_post(::CommandCallback *callback) { return _AutofillTimetable_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->autofill, this->preserve_wait_time); } -bool AutofillTimetable::do_test() { - return (::Command::Do(DC_NONE, veh, autofill, preserve_wait_time)).Succeeded(); +CommandCost AutofillTimetable::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, autofill, preserve_wait_time)); } +Commands SetTimetableStart::get_command() { return CMD_SET_TIMETABLE_START; } static constexpr auto _SetTimetableStart_dispatch = MakeDispatchTable(); -bool SetTimetableStart::do_post(CommandCallback *callback) { +bool SetTimetableStart::_post(::CommandCallback *callback) { return _SetTimetableStart_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->timetable_all, this->start_date); } -bool SetTimetableStart::do_test() { - return (::Command::Do(DC_NONE, veh_id, timetable_all, start_date)).Succeeded(); +CommandCost SetTimetableStart::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, timetable_all, start_date)); } +Commands WantEnginePreview::get_command() { return CMD_WANT_ENGINE_PREVIEW; } static constexpr auto _WantEnginePreview_dispatch = MakeDispatchTable(); -bool WantEnginePreview::do_post(CommandCallback *callback) { +bool WantEnginePreview::_post(::CommandCallback *callback) { return _WantEnginePreview_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->engine_id); } -bool WantEnginePreview::do_test() { - return (::Command::Do(DC_NONE, engine_id)).Succeeded(); +CommandCost WantEnginePreview::_do(DoCommandFlag flags) { + return (::Command::Do(flags, engine_id)); } +Commands EngineCtrl::get_command() { return CMD_ENGINE_CTRL; } static constexpr auto _EngineCtrl_dispatch = MakeDispatchTable(); -bool EngineCtrl::do_post(CommandCallback *callback) { +bool EngineCtrl::_post(::CommandCallback *callback) { return _EngineCtrl_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->engine_id, this->company_id, this->allow); } -bool EngineCtrl::do_test() { - return (::Command::Do(DC_NONE, engine_id, company_id, allow)).Succeeded(); +CommandCost EngineCtrl::_do(DoCommandFlag flags) { + return (::Command::Do(flags, engine_id, company_id, allow)); } +Commands RenameEngine::get_command() { return CMD_RENAME_ENGINE; } static constexpr auto _RenameEngine_dispatch = MakeDispatchTable(); -bool RenameEngine::do_post(CommandCallback *callback) { +bool RenameEngine::_post(::CommandCallback *callback) { return _RenameEngine_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->engine_id, this->text); } -bool RenameEngine::do_test() { - return (::Command::Do(DC_NONE, engine_id, text)).Succeeded(); +CommandCost RenameEngine::_do(DoCommandFlag flags) { + return (::Command::Do(flags, engine_id, text)); } +Commands SetVehicleVisibility::get_command() { return CMD_SET_VEHICLE_VISIBILITY; } static constexpr auto _SetVehicleVisibility_dispatch = MakeDispatchTable(); -bool SetVehicleVisibility::do_post(CommandCallback *callback) { +bool SetVehicleVisibility::_post(::CommandCallback *callback) { return _SetVehicleVisibility_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->engine_id, this->hide); } -bool SetVehicleVisibility::do_test() { - return (::Command::Do(DC_NONE, engine_id, hide)).Succeeded(); +CommandCost SetVehicleVisibility::_do(DoCommandFlag flags) { + return (::Command::Do(flags, engine_id, hide)); } +Commands PlantTree::get_command() { return CMD_PLANT_TREE; } static constexpr auto _PlantTree_dispatch = MakeDispatchTable(); -bool PlantTree::do_post(CommandCallback *callback) { +bool PlantTree::_post(::CommandCallback *callback) { return _PlantTree_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->tree_to_plant); } -bool PlantTree::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, tree_to_plant)).Succeeded(); +CommandCost PlantTree::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, tree_to_plant)); } +Commands LandscapeClear::get_command() { return CMD_LANDSCAPE_CLEAR; } static constexpr auto _LandscapeClear_dispatch = MakeDispatchTable(); -bool LandscapeClear::do_post(CommandCallback *callback) { +bool LandscapeClear::_post(::CommandCallback *callback) { return _LandscapeClear_dispatch[FindCallbackIndex(callback)](this->error, this->tile); } -bool LandscapeClear::do_test() { - return (::Command::Do(DC_NONE, this->tile)).Succeeded(); +CommandCost LandscapeClear::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile)); } +Commands ClearArea::get_command() { return CMD_CLEAR_AREA; } static constexpr auto _ClearArea_dispatch = MakeDispatchTable(); -bool ClearArea::do_post(CommandCallback *callback) { +bool ClearArea::_post(::CommandCallback *callback) { return _ClearArea_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->diagonal); } -bool ClearArea::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, start_tile, diagonal)).Succeeded(); +CommandCost ClearArea::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, start_tile, diagonal)); } +Commands BuildAirport::get_command() { return CMD_BUILD_AIRPORT; } static constexpr auto _BuildAirport_dispatch = MakeDispatchTable(); -bool BuildAirport::do_post(CommandCallback *callback) { +bool BuildAirport::_post(::CommandCallback *callback) { return _BuildAirport_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->airport_type, this->layout, this->station_to_join, this->adjacent); } -bool BuildAirport::do_test() { - return (::Command::Do(DC_NONE, this->tile, airport_type, layout, station_to_join, adjacent)).Succeeded(); +CommandCost BuildAirport::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, airport_type, layout, station_to_join, adjacent)); } +Commands BuildDock::get_command() { return CMD_BUILD_DOCK; } static constexpr auto _BuildDock_dispatch = MakeDispatchTable(); -bool BuildDock::do_post(CommandCallback *callback) { +bool BuildDock::_post(::CommandCallback *callback) { return _BuildDock_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->station_to_join, this->adjacent); } -bool BuildDock::do_test() { - return (::Command::Do(DC_NONE, this->tile, station_to_join, adjacent)).Succeeded(); +CommandCost BuildDock::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, station_to_join, adjacent)); } +Commands BuildRailStation::get_command() { return CMD_BUILD_RAIL_STATION; } static constexpr auto _BuildRailStation_dispatch = MakeDispatchTable(); -bool BuildRailStation::do_post(CommandCallback *callback) { +bool BuildRailStation::_post(::CommandCallback *callback) { return _BuildRailStation_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->rt, this->axis, this->numtracks, this->plat_len, this->spec_class, this->spec_index, this->station_to_join, this->adjacent); } -bool BuildRailStation::do_test() { - return (::Command::Do(DC_NONE, this->tile, rt, axis, numtracks, plat_len, spec_class, spec_index, station_to_join, adjacent)).Succeeded(); +CommandCost BuildRailStation::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, rt, axis, numtracks, plat_len, spec_class, spec_index, station_to_join, adjacent)); } +Commands RemoveFromRailStation::get_command() { return CMD_REMOVE_FROM_RAIL_STATION; } static constexpr auto _RemoveFromRailStation_dispatch = MakeDispatchTable(); -bool RemoveFromRailStation::do_post(CommandCallback *callback) { +bool RemoveFromRailStation::_post(::CommandCallback *callback) { return _RemoveFromRailStation_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->end, this->keep_rail); } -bool RemoveFromRailStation::do_test() { - return (::Command::Do(DC_NONE, this->tile, end, keep_rail)).Succeeded(); +CommandCost RemoveFromRailStation::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, end, keep_rail)); } +Commands BuildRoadStop::get_command() { return CMD_BUILD_ROAD_STOP; } static constexpr auto _BuildRoadStop_dispatch = MakeDispatchTable(); -bool BuildRoadStop::do_post(CommandCallback *callback) { +bool BuildRoadStop::_post(::CommandCallback *callback) { return _BuildRoadStop_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->width, this->length, this->stop_type, this->is_drive_through, this->ddir, this->rt, this->station_to_join, this->adjacent); } -bool BuildRoadStop::do_test() { - return (::Command::Do(DC_NONE, this->tile, width, length, stop_type, is_drive_through, ddir, rt, station_to_join, adjacent)).Succeeded(); +CommandCost BuildRoadStop::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, width, length, stop_type, is_drive_through, ddir, rt, station_to_join, adjacent)); } +Commands RemoveRoadStop::get_command() { return CMD_REMOVE_ROAD_STOP; } static constexpr auto _RemoveRoadStop_dispatch = MakeDispatchTable(); -bool RemoveRoadStop::do_post(CommandCallback *callback) { +bool RemoveRoadStop::_post(::CommandCallback *callback) { return _RemoveRoadStop_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->width, this->height, this->stop_type, this->remove_road); } -bool RemoveRoadStop::do_test() { - return (::Command::Do(DC_NONE, this->tile, width, height, stop_type, remove_road)).Succeeded(); +CommandCost RemoveRoadStop::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, width, height, stop_type, remove_road)); } +Commands RenameStation::get_command() { return CMD_RENAME_STATION; } static constexpr auto _RenameStation_dispatch = MakeDispatchTable(); -bool RenameStation::do_post(CommandCallback *callback) { +bool RenameStation::_post(::CommandCallback *callback) { return _RenameStation_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->station_id, this->text); } -bool RenameStation::do_test() { - return (::Command::Do(DC_NONE, station_id, text)).Succeeded(); +CommandCost RenameStation::_do(DoCommandFlag flags) { + return (::Command::Do(flags, station_id, text)); } +Commands OpenCloseAirport::get_command() { return CMD_OPEN_CLOSE_AIRPORT; } static constexpr auto _OpenCloseAirport_dispatch = MakeDispatchTable(); -bool OpenCloseAirport::do_post(CommandCallback *callback) { +bool OpenCloseAirport::_post(::CommandCallback *callback) { return _OpenCloseAirport_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->station_id); } -bool OpenCloseAirport::do_test() { - return (::Command::Do(DC_NONE, station_id)).Succeeded(); +CommandCost OpenCloseAirport::_do(DoCommandFlag flags) { + return (::Command::Do(flags, station_id)); } +Commands CompanyCtrl::get_command() { return CMD_COMPANY_CTRL; } static constexpr auto _CompanyCtrl_dispatch = MakeDispatchTable(); -bool CompanyCtrl::do_post(CommandCallback *callback) { +bool CompanyCtrl::_post(::CommandCallback *callback) { return _CompanyCtrl_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->cca, this->company_id, this->reason, this->client_id); } -bool CompanyCtrl::do_test() { - return (::Command::Do(DC_NONE, cca, company_id, reason, client_id)).Succeeded(); +CommandCost CompanyCtrl::_do(DoCommandFlag flags) { + return (::Command::Do(flags, cca, company_id, reason, client_id)); } +Commands GiveMoney::get_command() { return CMD_GIVE_MONEY; } static constexpr auto _GiveMoney_dispatch = MakeDispatchTable(); -bool GiveMoney::do_post(CommandCallback *callback) { +bool GiveMoney::_post(::CommandCallback *callback) { return _GiveMoney_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->money, this->dest_company); } -bool GiveMoney::do_test() { - return (::Command::Do(DC_NONE, money, dest_company)).Succeeded(); +CommandCost GiveMoney::_do(DoCommandFlag flags) { + return (::Command::Do(flags, money, dest_company)); } +Commands RenameCompany::get_command() { return CMD_RENAME_COMPANY; } static constexpr auto _RenameCompany_dispatch = MakeDispatchTable(); -bool RenameCompany::do_post(CommandCallback *callback) { +bool RenameCompany::_post(::CommandCallback *callback) { return _RenameCompany_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->text); } -bool RenameCompany::do_test() { - return (::Command::Do(DC_NONE, text)).Succeeded(); +CommandCost RenameCompany::_do(DoCommandFlag flags) { + return (::Command::Do(flags, text)); } +Commands RenamePresident::get_command() { return CMD_RENAME_PRESIDENT; } static constexpr auto _RenamePresident_dispatch = MakeDispatchTable(); -bool RenamePresident::do_post(CommandCallback *callback) { +bool RenamePresident::_post(::CommandCallback *callback) { return _RenamePresident_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->text); } -bool RenamePresident::do_test() { - return (::Command::Do(DC_NONE, text)).Succeeded(); +CommandCost RenamePresident::_do(DoCommandFlag flags) { + return (::Command::Do(flags, text)); } +Commands SetCompanyManagerFace::get_command() { return CMD_SET_COMPANY_MANAGER_FACE; } static constexpr auto _SetCompanyManagerFace_dispatch = MakeDispatchTable(); -bool SetCompanyManagerFace::do_post(CommandCallback *callback) { +bool SetCompanyManagerFace::_post(::CommandCallback *callback) { return _SetCompanyManagerFace_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->cmf); } -bool SetCompanyManagerFace::do_test() { - return (::Command::Do(DC_NONE, cmf)).Succeeded(); +CommandCost SetCompanyManagerFace::_do(DoCommandFlag flags) { + return (::Command::Do(flags, cmf)); } +Commands SetCompanyColour::get_command() { return CMD_SET_COMPANY_COLOUR; } static constexpr auto _SetCompanyColour_dispatch = MakeDispatchTable(); -bool SetCompanyColour::do_post(CommandCallback *callback) { +bool SetCompanyColour::_post(::CommandCallback *callback) { return _SetCompanyColour_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->scheme, this->primary, this->colour); } -bool SetCompanyColour::do_test() { - return (::Command::Do(DC_NONE, scheme, primary, colour)).Succeeded(); +CommandCost SetCompanyColour::_do(DoCommandFlag flags) { + return (::Command::Do(flags, scheme, primary, colour)); } +Commands RenameDepot::get_command() { return CMD_RENAME_DEPOT; } static constexpr auto _RenameDepot_dispatch = MakeDispatchTable(); -bool RenameDepot::do_post(CommandCallback *callback) { +bool RenameDepot::_post(::CommandCallback *callback) { return _RenameDepot_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->depot_id, this->text); } -bool RenameDepot::do_test() { - return (::Command::Do(DC_NONE, depot_id, text)).Succeeded(); +CommandCost RenameDepot::_do(DoCommandFlag flags) { + return (::Command::Do(flags, depot_id, text)); } +Commands AutoreplaceVehicle::get_command() { return CMD_AUTOREPLACE_VEHICLE; } static constexpr auto _AutoreplaceVehicle_dispatch = MakeDispatchTable(); -bool AutoreplaceVehicle::do_post(CommandCallback *callback) { +bool AutoreplaceVehicle::_post(::CommandCallback *callback) { return _AutoreplaceVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id); } -bool AutoreplaceVehicle::do_test() { - return (::Command::Do(DC_NONE, veh_id)).Succeeded(); +CommandCost AutoreplaceVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id)); } +Commands SetAutoReplace::get_command() { return CMD_SET_AUTOREPLACE; } static constexpr auto _SetAutoReplace_dispatch = MakeDispatchTable(); -bool SetAutoReplace::do_post(CommandCallback *callback) { +bool SetAutoReplace::_post(::CommandCallback *callback) { return _SetAutoReplace_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->id_g, this->old_engine_type, this->new_engine_type, this->when_old); } -bool SetAutoReplace::do_test() { - return (::Command::Do(DC_NONE, id_g, old_engine_type, new_engine_type, when_old)).Succeeded(); +CommandCost SetAutoReplace::_do(DoCommandFlag flags) { + return (::Command::Do(flags, id_g, old_engine_type, new_engine_type, when_old)); } +Commands BuildShipDepot::get_command() { return CMD_BUILD_SHIP_DEPOT; } static constexpr auto _BuildShipDepot_dispatch = MakeDispatchTable(); -bool BuildShipDepot::do_post(CommandCallback *callback) { +bool BuildShipDepot::_post(::CommandCallback *callback) { return _BuildShipDepot_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->axis); } -bool BuildShipDepot::do_test() { - return (::Command::Do(DC_NONE, this->tile, axis)).Succeeded(); +CommandCost BuildShipDepot::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, axis)); } +Commands BuildCanal::get_command() { return CMD_BUILD_CANAL; } static constexpr auto _BuildCanal_dispatch = MakeDispatchTable(); -bool BuildCanal::do_post(CommandCallback *callback) { +bool BuildCanal::_post(::CommandCallback *callback) { return _BuildCanal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->wc, this->diagonal); } -bool BuildCanal::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, wc, diagonal)).Succeeded(); +CommandCost BuildCanal::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, wc, diagonal)); } +Commands BuildLock::get_command() { return CMD_BUILD_LOCK; } static constexpr auto _BuildLock_dispatch = MakeDispatchTable(); -bool BuildLock::do_post(CommandCallback *callback) { +bool BuildLock::_post(::CommandCallback *callback) { return _BuildLock_dispatch[FindCallbackIndex(callback)](this->error, this->tile); } -bool BuildLock::do_test() { - return (::Command::Do(DC_NONE, this->tile)).Succeeded(); +CommandCost BuildLock::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile)); } +Commands BuildLongRoad::get_command() { return CMD_BUILD_LONG_ROAD; } static constexpr auto _BuildLongRoad_dispatch = MakeDispatchTable(); -bool BuildLongRoad::do_post(CommandCallback *callback) { +bool BuildLongRoad::_post(::CommandCallback *callback) { return _BuildLongRoad_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->rt, this->axis, this->drd, this->start_half, this->end_half, this->is_ai); } -bool BuildLongRoad::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, rt, axis, drd, start_half, end_half, is_ai)).Succeeded(); +CommandCost BuildLongRoad::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, rt, axis, drd, start_half, end_half, is_ai)); } +Commands RemoveLongRoad::get_command() { return CMD_REMOVE_LONG_ROAD; } static constexpr auto _RemoveLongRoad_dispatch = MakeDispatchTable(); -bool RemoveLongRoad::do_post(CommandCallback *callback) { +bool RemoveLongRoad::_post(::CommandCallback *callback) { return _RemoveLongRoad_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->rt, this->axis, this->start_half, this->end_half); } -bool RemoveLongRoad::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, start_tile, rt, axis, start_half, end_half)).Succeeded(); +CommandCost RemoveLongRoad::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, start_tile, rt, axis, start_half, end_half)); } +Commands BuildRoad::get_command() { return CMD_BUILD_ROAD; } static constexpr auto _BuildRoad_dispatch = MakeDispatchTable(); -bool BuildRoad::do_post(CommandCallback *callback) { +bool BuildRoad::_post(::CommandCallback *callback) { return _BuildRoad_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->pieces, this->rt, this->toggle_drd, this->town_id); } -bool BuildRoad::do_test() { - return (::Command::Do(DC_NONE, this->tile, pieces, rt, toggle_drd, town_id)).Succeeded(); +CommandCost BuildRoad::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, pieces, rt, toggle_drd, town_id)); } +Commands BuildRoadDepot::get_command() { return CMD_BUILD_ROAD_DEPOT; } static constexpr auto _BuildRoadDepot_dispatch = MakeDispatchTable(); -bool BuildRoadDepot::do_post(CommandCallback *callback) { +bool BuildRoadDepot::_post(::CommandCallback *callback) { return _BuildRoadDepot_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->rt, this->dir); } -bool BuildRoadDepot::do_test() { - return (::Command::Do(DC_NONE, this->tile, rt, dir)).Succeeded(); +CommandCost BuildRoadDepot::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, rt, dir)); } +Commands ConvertRoad::get_command() { return CMD_CONVERT_ROAD; } static constexpr auto _ConvertRoad_dispatch = MakeDispatchTable(); -bool ConvertRoad::do_post(CommandCallback *callback) { +bool ConvertRoad::_post(::CommandCallback *callback) { return _ConvertRoad_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->area_start, this->to_type); } -bool ConvertRoad::do_test() { - return (::Command::Do(DC_NONE, this->tile, area_start, to_type)).Succeeded(); +CommandCost ConvertRoad::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, area_start, to_type)); } +Commands BuildRailroadTrack::get_command() { return CMD_BUILD_RAILROAD_TRACK; } static constexpr auto _BuildRailroadTrack_dispatch = MakeDispatchTable(); -bool BuildRailroadTrack::do_post(CommandCallback *callback) { +bool BuildRailroadTrack::_post(::CommandCallback *callback) { return _BuildRailroadTrack_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->railtype, this->track, this->auto_remove_signals, this->fail_on_obstacle); } -bool BuildRailroadTrack::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, railtype, track, auto_remove_signals, fail_on_obstacle)).Succeeded(); +CommandCost BuildRailroadTrack::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, railtype, track, auto_remove_signals, fail_on_obstacle)); } +Commands RemoveRailroadTrack::get_command() { return CMD_REMOVE_RAILROAD_TRACK; } static constexpr auto _RemoveRailroadTrack_dispatch = MakeDispatchTable(); -bool RemoveRailroadTrack::do_post(CommandCallback *callback) { +bool RemoveRailroadTrack::_post(::CommandCallback *callback) { return _RemoveRailroadTrack_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->track); } -bool RemoveRailroadTrack::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, track)).Succeeded(); +CommandCost RemoveRailroadTrack::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, track)); } +Commands BuildSingleRail::get_command() { return CMD_BUILD_SINGLE_RAIL; } static constexpr auto _BuildSingleRail_dispatch = MakeDispatchTable(); -bool BuildSingleRail::do_post(CommandCallback *callback) { +bool BuildSingleRail::_post(::CommandCallback *callback) { return _BuildSingleRail_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->railtype, this->track, this->auto_remove_signals); } -bool BuildSingleRail::do_test() { - return (::Command::Do(DC_NONE, this->tile, railtype, track, auto_remove_signals)).Succeeded(); +CommandCost BuildSingleRail::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, railtype, track, auto_remove_signals)); } +Commands RemoveSingleRail::get_command() { return CMD_REMOVE_SINGLE_RAIL; } static constexpr auto _RemoveSingleRail_dispatch = MakeDispatchTable(); -bool RemoveSingleRail::do_post(CommandCallback *callback) { +bool RemoveSingleRail::_post(::CommandCallback *callback) { return _RemoveSingleRail_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->track); } -bool RemoveSingleRail::do_test() { - return (::Command::Do(DC_NONE, this->tile, track)).Succeeded(); +CommandCost RemoveSingleRail::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, track)); } +Commands BuildTrainDepot::get_command() { return CMD_BUILD_TRAIN_DEPOT; } static constexpr auto _BuildTrainDepot_dispatch = MakeDispatchTable(); -bool BuildTrainDepot::do_post(CommandCallback *callback) { +bool BuildTrainDepot::_post(::CommandCallback *callback) { return _BuildTrainDepot_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->railtype, this->dir); } -bool BuildTrainDepot::do_test() { - return (::Command::Do(DC_NONE, this->tile, railtype, dir)).Succeeded(); +CommandCost BuildTrainDepot::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, railtype, dir)); } +Commands BuildSingleSignal::get_command() { return CMD_BUILD_SIGNALS; } static constexpr auto _BuildSingleSignal_dispatch = MakeDispatchTable(); -bool BuildSingleSignal::do_post(CommandCallback *callback) { +bool BuildSingleSignal::_post(::CommandCallback *callback) { return _BuildSingleSignal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->track, this->sigtype, this->sigvar, this->convert_signal, this->skip_existing_signals, this->ctrl_pressed, this->cycle_start, this->cycle_stop, this->num_dir_cycle, this->signals_copy); } -bool BuildSingleSignal::do_test() { - return (::Command::Do(DC_NONE, this->tile, track, sigtype, sigvar, convert_signal, skip_existing_signals, ctrl_pressed, cycle_start, cycle_stop, num_dir_cycle, signals_copy)).Succeeded(); +CommandCost BuildSingleSignal::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, track, sigtype, sigvar, convert_signal, skip_existing_signals, ctrl_pressed, cycle_start, cycle_stop, num_dir_cycle, signals_copy)); } +Commands RemoveSingleSignal::get_command() { return CMD_REMOVE_SIGNALS; } static constexpr auto _RemoveSingleSignal_dispatch = MakeDispatchTable(); -bool RemoveSingleSignal::do_post(CommandCallback *callback) { +bool RemoveSingleSignal::_post(::CommandCallback *callback) { return _RemoveSingleSignal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->track); } -bool RemoveSingleSignal::do_test() { - return (::Command::Do(DC_NONE, this->tile, track)).Succeeded(); +CommandCost RemoveSingleSignal::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, track)); } +Commands ConvertRail::get_command() { return CMD_CONVERT_RAIL; } static constexpr auto _ConvertRail_dispatch = MakeDispatchTable(); -bool ConvertRail::do_post(CommandCallback *callback) { +bool ConvertRail::_post(::CommandCallback *callback) { return _ConvertRail_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->area_start, this->totype, this->diagonal); } -bool ConvertRail::do_test() { - return (::Command::Do(DC_NONE, this->tile, area_start, totype, diagonal)).Succeeded(); +CommandCost ConvertRail::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, area_start, totype, diagonal)); } +Commands BuildSignalTrack::get_command() { return CMD_BUILD_SIGNAL_TRACK; } static constexpr auto _BuildSignalTrack_dispatch = MakeDispatchTable(); -bool BuildSignalTrack::do_post(CommandCallback *callback) { +bool BuildSignalTrack::_post(::CommandCallback *callback) { return _BuildSignalTrack_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->end_tile, this->track, this->sigtype, this->sigvar, this->mode, this->autofill, this->minimise_gaps, this->signal_density); } -bool BuildSignalTrack::do_test() { - return (::Command::Do(DC_NONE, this->tile, end_tile, track, sigtype, sigvar, mode, autofill, minimise_gaps, signal_density)).Succeeded(); +CommandCost BuildSignalTrack::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, end_tile, track, sigtype, sigvar, mode, autofill, minimise_gaps, signal_density)); } +Commands RemoveSignalTrack::get_command() { return CMD_REMOVE_SIGNAL_TRACK; } static constexpr auto _RemoveSignalTrack_dispatch = MakeDispatchTable(); -bool RemoveSignalTrack::do_post(CommandCallback *callback) { +bool RemoveSignalTrack::_post(::CommandCallback *callback) { return _RemoveSignalTrack_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->end_tile, this->track, this->autofill); } -bool RemoveSignalTrack::do_test() { - return (::Command::Do(DC_NONE, this->tile, end_tile, track, autofill)).Succeeded(); +CommandCost RemoveSignalTrack::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, end_tile, track, autofill)); } +Commands BuildIndustry::get_command() { return CMD_BUILD_INDUSTRY; } static constexpr auto _BuildIndustry_dispatch = MakeDispatchTable(); -bool BuildIndustry::do_post(CommandCallback *callback) { +bool BuildIndustry::_post(::CommandCallback *callback) { return _BuildIndustry_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->it, this->first_layout, this->fund, this->seed); } -bool BuildIndustry::do_test() { - return (::Command::Do(DC_NONE, this->tile, it, first_layout, fund, seed)).Succeeded(); +CommandCost BuildIndustry::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, it, first_layout, fund, seed)); } +Commands IndustryCtrl::get_command() { return CMD_INDUSTRY_CTRL; } static constexpr auto _IndustryCtrl_dispatch = MakeDispatchTable(); -bool IndustryCtrl::do_post(CommandCallback *callback) { +bool IndustryCtrl::_post(::CommandCallback *callback) { return _IndustryCtrl_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->ind_id, this->action, this->ctlflags, this->company_id, this->text); } -bool IndustryCtrl::do_test() { - return (::Command::Do(DC_NONE, ind_id, action, ctlflags, company_id, text)).Succeeded(); +CommandCost IndustryCtrl::_do(DoCommandFlag flags) { + return (::Command::Do(flags, ind_id, action, ctlflags, company_id, text)); } +Commands BuildRailWaypoint::get_command() { return CMD_BUILD_RAIL_WAYPOINT; } static constexpr auto _BuildRailWaypoint_dispatch = MakeDispatchTable(); -bool BuildRailWaypoint::do_post(CommandCallback *callback) { +bool BuildRailWaypoint::_post(::CommandCallback *callback) { return _BuildRailWaypoint_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->axis, this->width, this->height, this->spec_class, this->spec_index, this->station_to_join, this->adjacent); } -bool BuildRailWaypoint::do_test() { - return (::Command::Do(DC_NONE, this->tile, axis, width, height, spec_class, spec_index, station_to_join, adjacent)).Succeeded(); +CommandCost BuildRailWaypoint::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, axis, width, height, spec_class, spec_index, station_to_join, adjacent)); } +Commands RemoveFromRailWaypoint::get_command() { return CMD_REMOVE_FROM_RAIL_WAYPOINT; } static constexpr auto _RemoveFromRailWaypoint_dispatch = MakeDispatchTable(); -bool RemoveFromRailWaypoint::do_post(CommandCallback *callback) { +bool RemoveFromRailWaypoint::_post(::CommandCallback *callback) { return _RemoveFromRailWaypoint_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->end, this->keep_rail); } -bool RemoveFromRailWaypoint::do_test() { - return (::Command::Do(DC_NONE, this->tile, end, keep_rail)).Succeeded(); +CommandCost RemoveFromRailWaypoint::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, end, keep_rail)); } +Commands BuildBuoy::get_command() { return CMD_BUILD_BUOY; } static constexpr auto _BuildBuoy_dispatch = MakeDispatchTable(); -bool BuildBuoy::do_post(CommandCallback *callback) { +bool BuildBuoy::_post(::CommandCallback *callback) { return _BuildBuoy_dispatch[FindCallbackIndex(callback)](this->error, this->tile); } -bool BuildBuoy::do_test() { - return (::Command::Do(DC_NONE, this->tile)).Succeeded(); +CommandCost BuildBuoy::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile)); } +Commands RenameWaypoint::get_command() { return CMD_RENAME_WAYPOINT; } static constexpr auto _RenameWaypoint_dispatch = MakeDispatchTable(); -bool RenameWaypoint::do_post(CommandCallback *callback) { +bool RenameWaypoint::_post(::CommandCallback *callback) { return _RenameWaypoint_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->waypoint_id, this->text); } -bool RenameWaypoint::do_test() { - return (::Command::Do(DC_NONE, waypoint_id, text)).Succeeded(); +CommandCost RenameWaypoint::_do(DoCommandFlag flags) { + return (::Command::Do(flags, waypoint_id, text)); } +Commands FoundTown::get_command() { return CMD_FOUND_TOWN; } static constexpr auto _FoundTown_dispatch = MakeDispatchTable(); -bool FoundTown::do_post(CommandCallback *callback) { +bool FoundTown::_post(::CommandCallback *callback) { return _FoundTown_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->size, this->city, this->layout, this->random_location, this->townnameparts, this->text); } -bool FoundTown::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, size, city, layout, random_location, townnameparts, text)).Succeeded(); +CommandCost FoundTown::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, size, city, layout, random_location, townnameparts, text)); } +Commands RenameTown::get_command() { return CMD_RENAME_TOWN; } static constexpr auto _RenameTown_dispatch = MakeDispatchTable(); -bool RenameTown::do_post(CommandCallback *callback) { +bool RenameTown::_post(::CommandCallback *callback) { return _RenameTown_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->text); } -bool RenameTown::do_test() { - return (::Command::Do(DC_NONE, town_id, text)).Succeeded(); +CommandCost RenameTown::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, text)); } +Commands DoTownAction::get_command() { return CMD_DO_TOWN_ACTION; } static constexpr auto _DoTownAction_dispatch = MakeDispatchTable(); -bool DoTownAction::do_post(CommandCallback *callback) { +bool DoTownAction::_post(::CommandCallback *callback) { return _DoTownAction_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->action); } -bool DoTownAction::do_test() { - return (::Command::Do(DC_NONE, town_id, action)).Succeeded(); +CommandCost DoTownAction::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, action)); } +Commands TownGrowthRate::get_command() { return CMD_TOWN_GROWTH_RATE; } static constexpr auto _TownGrowthRate_dispatch = MakeDispatchTable(); -bool TownGrowthRate::do_post(CommandCallback *callback) { +bool TownGrowthRate::_post(::CommandCallback *callback) { return _TownGrowthRate_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->growth_rate); } -bool TownGrowthRate::do_test() { - return (::Command::Do(DC_NONE, town_id, growth_rate)).Succeeded(); +CommandCost TownGrowthRate::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, growth_rate)); } +Commands TownRating::get_command() { return CMD_TOWN_RATING; } static constexpr auto _TownRating_dispatch = MakeDispatchTable(); -bool TownRating::do_post(CommandCallback *callback) { +bool TownRating::_post(::CommandCallback *callback) { return _TownRating_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->company_id, this->rating); } -bool TownRating::do_test() { - return (::Command::Do(DC_NONE, town_id, company_id, rating)).Succeeded(); +CommandCost TownRating::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, company_id, rating)); } +Commands TownCargoGoal::get_command() { return CMD_TOWN_CARGO_GOAL; } static constexpr auto _TownCargoGoal_dispatch = MakeDispatchTable(); -bool TownCargoGoal::do_post(CommandCallback *callback) { +bool TownCargoGoal::_post(::CommandCallback *callback) { return _TownCargoGoal_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->te, this->goal); } -bool TownCargoGoal::do_test() { - return (::Command::Do(DC_NONE, town_id, te, goal)).Succeeded(); +CommandCost TownCargoGoal::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, te, goal)); } +Commands TownSetText::get_command() { return CMD_TOWN_SET_TEXT; } static constexpr auto _TownSetText_dispatch = MakeDispatchTable(); -bool TownSetText::do_post(CommandCallback *callback) { +bool TownSetText::_post(::CommandCallback *callback) { return _TownSetText_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->text); } -bool TownSetText::do_test() { - return (::Command::Do(DC_NONE, town_id, text)).Succeeded(); +CommandCost TownSetText::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, text)); } +Commands ExpandTown::get_command() { return CMD_EXPAND_TOWN; } static constexpr auto _ExpandTown_dispatch = MakeDispatchTable(); -bool ExpandTown::do_post(CommandCallback *callback) { +bool ExpandTown::_post(::CommandCallback *callback) { return _ExpandTown_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id, this->grow_amount); } -bool ExpandTown::do_test() { - return (::Command::Do(DC_NONE, town_id, grow_amount)).Succeeded(); +CommandCost ExpandTown::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id, grow_amount)); } +Commands DeleteTown::get_command() { return CMD_DELETE_TOWN; } static constexpr auto _DeleteTown_dispatch = MakeDispatchTable(); -bool DeleteTown::do_post(CommandCallback *callback) { +bool DeleteTown::_post(::CommandCallback *callback) { return _DeleteTown_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->town_id); } -bool DeleteTown::do_test() { - return (::Command::Do(DC_NONE, town_id)).Succeeded(); +CommandCost DeleteTown::_do(DoCommandFlag flags) { + return (::Command::Do(flags, town_id)); } +Commands BuildObject::get_command() { return CMD_BUILD_OBJECT; } static constexpr auto _BuildObject_dispatch = MakeDispatchTable(); -bool BuildObject::do_post(CommandCallback *callback) { +bool BuildObject::_post(::CommandCallback *callback) { return _BuildObject_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->type, this->view); } -bool BuildObject::do_test() { - return (::Command::Do(DC_NONE, this->tile, type, view)).Succeeded(); +CommandCost BuildObject::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, type, view)); } +Commands BuildObjectArea::get_command() { return CMD_BUILD_OBJECT_AREA; } static constexpr auto _BuildObjectArea_dispatch = MakeDispatchTable(); -bool BuildObjectArea::do_post(CommandCallback *callback) { +bool BuildObjectArea::_post(::CommandCallback *callback) { return _BuildObjectArea_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->type, this->view, this->diagonal); } -bool BuildObjectArea::do_test() { - return (::Command::Do(DC_NONE, this->tile, start_tile, type, view, diagonal)).Succeeded(); +CommandCost BuildObjectArea::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, start_tile, type, view, diagonal)); } +Commands MoveRailVehicle::get_command() { return CMD_MOVE_RAIL_VEHICLE; } static constexpr auto _MoveRailVehicle_dispatch = MakeDispatchTable(); -bool MoveRailVehicle::do_post(CommandCallback *callback) { +bool MoveRailVehicle::_post(::CommandCallback *callback) { return _MoveRailVehicle_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->src_veh, this->dest_veh, this->move_chain); } -bool MoveRailVehicle::do_test() { - return (::Command::Do(DC_NONE, src_veh, dest_veh, move_chain)).Succeeded(); +CommandCost MoveRailVehicle::_do(DoCommandFlag flags) { + return (::Command::Do(flags, src_veh, dest_veh, move_chain)); } +Commands ForceTrainProceed::get_command() { return CMD_FORCE_TRAIN_PROCEED; } static constexpr auto _ForceTrainProceed_dispatch = MakeDispatchTable(); -bool ForceTrainProceed::do_post(CommandCallback *callback) { +bool ForceTrainProceed::_post(::CommandCallback *callback) { return _ForceTrainProceed_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id); } -bool ForceTrainProceed::do_test() { - return (::Command::Do(DC_NONE, veh_id)).Succeeded(); +CommandCost ForceTrainProceed::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id)); } +Commands ReverseTrainDirection::get_command() { return CMD_REVERSE_TRAIN_DIRECTION; } static constexpr auto _ReverseTrainDirection_dispatch = MakeDispatchTable(); -bool ReverseTrainDirection::do_post(CommandCallback *callback) { +bool ReverseTrainDirection::_post(::CommandCallback *callback) { return _ReverseTrainDirection_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->reverse_single_veh); } -bool ReverseTrainDirection::do_test() { - return (::Command::Do(DC_NONE, veh_id, reverse_single_veh)).Succeeded(); +CommandCost ReverseTrainDirection::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, reverse_single_veh)); } +Commands PlaceSign::get_command() { return CMD_PLACE_SIGN; } static constexpr auto _PlaceSign_dispatch = MakeDispatchTable(); -bool PlaceSign::do_post(CommandCallback *callback) { +bool PlaceSign::_post(::CommandCallback *callback) { return _PlaceSign_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->text); } -bool PlaceSign::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, text)).Succeeded(); +CommandCost PlaceSign::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, text)); } +Commands RenameSign::get_command() { return CMD_RENAME_SIGN; } static constexpr auto _RenameSign_dispatch = MakeDispatchTable(); -bool RenameSign::do_post(CommandCallback *callback) { +bool RenameSign::_post(::CommandCallback *callback) { return _RenameSign_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->sign_id, this->text); } -bool RenameSign::do_test() { - return (::Command::Do(DC_NONE, sign_id, text)).Succeeded(); +CommandCost RenameSign::_do(DoCommandFlag flags) { + return (::Command::Do(flags, sign_id, text)); } +Commands BuildBridge::get_command() { return CMD_BUILD_BRIDGE; } static constexpr auto _BuildBridge_dispatch = MakeDispatchTable(); -bool BuildBridge::do_post(CommandCallback *callback) { +bool BuildBridge::_post(::CommandCallback *callback) { return _BuildBridge_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->tile_start, this->transport_type, this->bridge_type, this->road_rail_type); } -bool BuildBridge::do_test() { - return (::Command::Do(DC_NONE, this->tile, tile_start, transport_type, bridge_type, road_rail_type)).Succeeded(); +CommandCost BuildBridge::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, tile_start, transport_type, bridge_type, road_rail_type)); } +Commands BuildTunnel::get_command() { return CMD_BUILD_TUNNEL; } static constexpr auto _BuildTunnel_dispatch = MakeDispatchTable(); -bool BuildTunnel::do_post(CommandCallback *callback) { +bool BuildTunnel::_post(::CommandCallback *callback) { return _BuildTunnel_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->transport_type, this->road_rail_type); } -bool BuildTunnel::do_test() { - return (::Command::Do(DC_NONE, this->tile, transport_type, road_rail_type)).Succeeded(); +CommandCost BuildTunnel::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, transport_type, road_rail_type)); } +Commands TerraformLand::get_command() { return CMD_TERRAFORM_LAND; } static constexpr auto _TerraformLand_dispatch = MakeDispatchTable(); -bool TerraformLand::do_post(CommandCallback *callback) { +bool TerraformLand::_post(::CommandCallback *callback) { return _TerraformLand_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->slope, this->dir_up); } -bool TerraformLand::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, slope, dir_up)).Succeeded(); +CommandCost TerraformLand::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, slope, dir_up)); } +Commands LevelLand::get_command() { return CMD_LEVEL_LAND; } static constexpr auto _LevelLand_dispatch = MakeDispatchTable(); -bool LevelLand::do_post(CommandCallback *callback) { +bool LevelLand::_post(::CommandCallback *callback) { return _LevelLand_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->start_tile, this->diagonal, this->lm); } -bool LevelLand::do_test() { - return std::get<0>(::Command::Do(DC_NONE, this->tile, start_tile, diagonal, lm)).Succeeded(); +CommandCost LevelLand::_do(DoCommandFlag flags) { + return std::get<0>(::Command::Do(flags, this->tile, start_tile, diagonal, lm)); } +Commands MoneyCheat::get_command() { return CMD_MONEY_CHEAT; } static constexpr auto _MoneyCheat_dispatch = MakeDispatchTable(); -bool MoneyCheat::do_post(CommandCallback *callback) { +bool MoneyCheat::_post(::CommandCallback *callback) { return _MoneyCheat_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->amount); } -bool MoneyCheat::do_test() { - return (::Command::Do(DC_NONE, amount)).Succeeded(); +CommandCost MoneyCheat::_do(DoCommandFlag flags) { + return (::Command::Do(flags, amount)); } +Commands ChangeBankBalance::get_command() { return CMD_CHANGE_BANK_BALANCE; } static constexpr auto _ChangeBankBalance_dispatch = MakeDispatchTable(); -bool ChangeBankBalance::do_post(CommandCallback *callback) { +bool ChangeBankBalance::_post(::CommandCallback *callback) { return _ChangeBankBalance_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->delta, this->company, this->expenses_type); } -bool ChangeBankBalance::do_test() { - return (::Command::Do(DC_NONE, this->tile, delta, company, expenses_type)).Succeeded(); +CommandCost ChangeBankBalance::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, delta, company, expenses_type)); } +Commands IncreaseLoan::get_command() { return CMD_INCREASE_LOAN; } static constexpr auto _IncreaseLoan_dispatch = MakeDispatchTable(); -bool IncreaseLoan::do_post(CommandCallback *callback) { +bool IncreaseLoan::_post(::CommandCallback *callback) { return _IncreaseLoan_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->cmd, this->amount); } -bool IncreaseLoan::do_test() { - return (::Command::Do(DC_NONE, cmd, amount)).Succeeded(); +CommandCost IncreaseLoan::_do(DoCommandFlag flags) { + return (::Command::Do(flags, cmd, amount)); } +Commands DecreaseLoan::get_command() { return CMD_DECREASE_LOAN; } static constexpr auto _DecreaseLoan_dispatch = MakeDispatchTable(); -bool DecreaseLoan::do_post(CommandCallback *callback) { +bool DecreaseLoan::_post(::CommandCallback *callback) { return _DecreaseLoan_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->cmd, this->amount); } -bool DecreaseLoan::do_test() { - return (::Command::Do(DC_NONE, cmd, amount)).Succeeded(); +CommandCost DecreaseLoan::_do(DoCommandFlag flags) { + return (::Command::Do(flags, cmd, amount)); } +Commands Pause::get_command() { return CMD_PAUSE; } static constexpr auto _Pause_dispatch = MakeDispatchTable(); -bool Pause::do_post(CommandCallback *callback) { +bool Pause::_post(::CommandCallback *callback) { return _Pause_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->mode, this->pause); } -bool Pause::do_test() { - return (::Command::Do(DC_NONE, mode, pause)).Succeeded(); +CommandCost Pause::_do(DoCommandFlag flags) { + return (::Command::Do(flags, mode, pause)); } +Commands ModifyOrder::get_command() { return CMD_MODIFY_ORDER; } static constexpr auto _ModifyOrder_dispatch = MakeDispatchTable(); -bool ModifyOrder::do_post(CommandCallback *callback) { +bool ModifyOrder::_post(::CommandCallback *callback) { return _ModifyOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->sel_ord, this->mof, this->data); } -bool ModifyOrder::do_test() { - return (::Command::Do(DC_NONE, veh, sel_ord, mof, data)).Succeeded(); +CommandCost ModifyOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, sel_ord, mof, data)); } +Commands SkipToOrder::get_command() { return CMD_SKIP_TO_ORDER; } static constexpr auto _SkipToOrder_dispatch = MakeDispatchTable(); -bool SkipToOrder::do_post(CommandCallback *callback) { +bool SkipToOrder::_post(::CommandCallback *callback) { return _SkipToOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->sel_ord); } -bool SkipToOrder::do_test() { - return (::Command::Do(DC_NONE, veh_id, sel_ord)).Succeeded(); +CommandCost SkipToOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, sel_ord)); } +Commands DeleteOrder::get_command() { return CMD_DELETE_ORDER; } static constexpr auto _DeleteOrder_dispatch = MakeDispatchTable(); -bool DeleteOrder::do_post(CommandCallback *callback) { +bool DeleteOrder::_post(::CommandCallback *callback) { return _DeleteOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh_id, this->sel_ord); } -bool DeleteOrder::do_test() { - return (::Command::Do(DC_NONE, veh_id, sel_ord)).Succeeded(); +CommandCost DeleteOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh_id, sel_ord)); } +Commands InsertOrder::get_command() { return CMD_INSERT_ORDER; } static constexpr auto _InsertOrder_dispatch = MakeDispatchTable(); -bool InsertOrder::do_post(CommandCallback *callback) { +bool InsertOrder::_post(::CommandCallback *callback) { return _InsertOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->sel_ord, this->new_order); } -bool InsertOrder::do_test() { - return (::Command::Do(DC_NONE, veh, sel_ord, new_order)).Succeeded(); +CommandCost InsertOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, sel_ord, new_order)); } +Commands OrderRefit::get_command() { return CMD_ORDER_REFIT; } static constexpr auto _OrderRefit_dispatch = MakeDispatchTable(); -bool OrderRefit::do_post(CommandCallback *callback) { +bool OrderRefit::_post(::CommandCallback *callback) { return _OrderRefit_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->order_number, this->cargo); } -bool OrderRefit::do_test() { - return (::Command::Do(DC_NONE, veh, order_number, cargo)).Succeeded(); +CommandCost OrderRefit::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, order_number, cargo)); } +Commands CloneOrder::get_command() { return CMD_CLONE_ORDER; } static constexpr auto _CloneOrder_dispatch = MakeDispatchTable(); -bool CloneOrder::do_post(CommandCallback *callback) { +bool CloneOrder::_post(::CommandCallback *callback) { return _CloneOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->action, this->veh_dst, this->veh_src); } -bool CloneOrder::do_test() { - return (::Command::Do(DC_NONE, action, veh_dst, veh_src)).Succeeded(); +CommandCost CloneOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, action, veh_dst, veh_src)); } +Commands MoveOrder::get_command() { return CMD_MOVE_ORDER; } static constexpr auto _MoveOrder_dispatch = MakeDispatchTable(); -bool MoveOrder::do_post(CommandCallback *callback) { +bool MoveOrder::_post(::CommandCallback *callback) { return _MoveOrder_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->veh, this->moving_order, this->target_order); } -bool MoveOrder::do_test() { - return (::Command::Do(DC_NONE, veh, moving_order, target_order)).Succeeded(); +CommandCost MoveOrder::_do(DoCommandFlag flags) { + return (::Command::Do(flags, veh, moving_order, target_order)); } +Commands ClearOrderBackup::get_command() { return CMD_CLEAR_ORDER_BACKUP; } static constexpr auto _ClearOrderBackup_dispatch = MakeDispatchTable(); -bool ClearOrderBackup::do_post(CommandCallback *callback) { +bool ClearOrderBackup::_post(::CommandCallback *callback) { return _ClearOrderBackup_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->user_id); } -bool ClearOrderBackup::do_test() { - return (::Command::Do(DC_NONE, this->tile, user_id)).Succeeded(); +CommandCost ClearOrderBackup::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, user_id)); } +Commands CreateSubsidy::get_command() { return CMD_CREATE_SUBSIDY; } static constexpr auto _CreateSubsidy_dispatch = MakeDispatchTable(); -bool CreateSubsidy::do_post(CommandCallback *callback) { +bool CreateSubsidy::_post(::CommandCallback *callback) { return _CreateSubsidy_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->cid, this->src_type, this->src, this->dst_type, this->dst); } -bool CreateSubsidy::do_test() { - return (::Command::Do(DC_NONE, cid, src_type, src, dst_type, dst)).Succeeded(); +CommandCost CreateSubsidy::_do(DoCommandFlag flags) { + return (::Command::Do(flags, cid, src_type, src, dst_type, dst)); } +Commands ScrollViewport::get_command() { return CMD_SCROLL_VIEWPORT; } static constexpr auto _ScrollViewport_dispatch = MakeDispatchTable(); -bool ScrollViewport::do_post(CommandCallback *callback) { +bool ScrollViewport::_post(::CommandCallback *callback) { return _ScrollViewport_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->target, this->ref); } -bool ScrollViewport::do_test() { - return (::Command::Do(DC_NONE, this->tile, target, ref)).Succeeded(); +CommandCost ScrollViewport::_do(DoCommandFlag flags) { + return (::Command::Do(flags, this->tile, target, ref)); } +Commands BuyShareInCompany::get_command() { return CMD_BUY_SHARE_IN_COMPANY; } static constexpr auto _BuyShareInCompany_dispatch = MakeDispatchTable(); -bool BuyShareInCompany::do_post(CommandCallback *callback) { +bool BuyShareInCompany::_post(::CommandCallback *callback) { return _BuyShareInCompany_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->target_company); } -bool BuyShareInCompany::do_test() { - return (::Command::Do(DC_NONE, target_company)).Succeeded(); +CommandCost BuyShareInCompany::_do(DoCommandFlag flags) { + return (::Command::Do(flags, target_company)); } +Commands SellShareInCompany::get_command() { return CMD_SELL_SHARE_IN_COMPANY; } static constexpr auto _SellShareInCompany_dispatch = MakeDispatchTable(); -bool SellShareInCompany::do_post(CommandCallback *callback) { +bool SellShareInCompany::_post(::CommandCallback *callback) { return _SellShareInCompany_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->target_company); } -bool SellShareInCompany::do_test() { - return (::Command::Do(DC_NONE, target_company)).Succeeded(); +CommandCost SellShareInCompany::_do(DoCommandFlag flags) { + return (::Command::Do(flags, target_company)); } +Commands BuyCompany::get_command() { return CMD_BUY_COMPANY; } static constexpr auto _BuyCompany_dispatch = MakeDispatchTable(); -bool BuyCompany::do_post(CommandCallback *callback) { +bool BuyCompany::_post(::CommandCallback *callback) { return _BuyCompany_dispatch[FindCallbackIndex(callback)](this->error, this->tile, this->target_company); } -bool BuyCompany::do_test() { - return (::Command::Do(DC_NONE, target_company)).Succeeded(); +CommandCost BuyCompany::_do(DoCommandFlag flags) { + return (::Command::Do(flags, target_company)); } } // namespace cmd diff --git a/src/citymania/generated/cm_gen_commands.hpp b/src/citymania/generated/cm_gen_commands.hpp index 716c53a97a..703e52c0af 100644 --- a/src/citymania/generated/cm_gen_commands.hpp +++ b/src/citymania/generated/cm_gen_commands.hpp @@ -43,7 +43,7 @@ namespace citymania { namespace cmd { -class CreateGoal: public Command { +class CreateGoal: public citymania::Command { public: CompanyID company; GoalType type; @@ -54,8 +54,9 @@ public: :company{company}, type{type}, dest{dest}, text{text} {} ~CreateGoal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveGoal: public Command { @@ -66,8 +67,9 @@ public: :goal{goal} {} ~RemoveGoal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetGoalText: public Command { @@ -79,8 +81,9 @@ public: :goal{goal}, text{text} {} ~SetGoalText() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetGoalProgress: public Command { @@ -92,8 +95,9 @@ public: :goal{goal}, text{text} {} ~SetGoalProgress() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetGoalCompleted: public Command { @@ -105,8 +109,9 @@ public: :goal{goal}, completed{completed} {} ~SetGoalCompleted() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class GoalQuestion: public Command { @@ -122,8 +127,9 @@ public: :uniqueid{uniqueid}, target{target}, is_client{is_client}, button_mask{button_mask}, type{type}, text{text} {} ~GoalQuestion() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class GoalQuestionAnswer: public Command { @@ -135,8 +141,9 @@ public: :uniqueid{uniqueid}, button{button} {} ~GoalQuestionAnswer() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CustomNewsItem: public Command { @@ -151,8 +158,9 @@ public: :type{type}, reftype1{reftype1}, company{company}, reference{reference}, text{text} {} ~CustomNewsItem() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CreateStoryPage: public Command { @@ -164,8 +172,9 @@ public: :company{company}, text{text} {} ~CreateStoryPage() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CreateStoryPageElement: public Command { @@ -181,8 +190,9 @@ public: :Command{tile}, page_id{page_id}, type{type}, reference{reference}, text{text} {} ~CreateStoryPageElement() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class UpdateStoryPageElement: public Command { @@ -197,8 +207,9 @@ public: :Command{tile}, page_element_id{page_element_id}, reference{reference}, text{text} {} ~UpdateStoryPageElement() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetStoryPageTitle: public Command { @@ -210,8 +221,9 @@ public: :page_id{page_id}, text{text} {} ~SetStoryPageTitle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetStoryPageDate: public Command { @@ -223,8 +235,9 @@ public: :page_id{page_id}, date{date} {} ~SetStoryPageDate() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ShowStoryPage: public Command { @@ -235,8 +248,9 @@ public: :page_id{page_id} {} ~ShowStoryPage() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveStoryPage: public Command { @@ -247,8 +261,9 @@ public: :page_id{page_id} {} ~RemoveStoryPage() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveStoryPageElement: public Command { @@ -259,8 +274,9 @@ public: :page_element_id{page_element_id} {} ~RemoveStoryPageElement() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class StoryPageButton: public Command { @@ -274,8 +290,9 @@ public: :Command{tile}, page_element_id{page_element_id}, reference{reference} {} ~StoryPageButton() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildVehicle: public Command { @@ -291,8 +308,9 @@ public: :Command{tile}, eid{eid}, use_free_vehicles{use_free_vehicles}, cargo{cargo}, client_id{client_id} {} ~BuildVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SellVehicle: public Command { @@ -306,8 +324,9 @@ public: :v_id{v_id}, sell_chain{sell_chain}, backup_order{backup_order}, client_id{client_id} {} ~SellVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RefitVehicle: public Command { @@ -323,8 +342,9 @@ public: :veh_id{veh_id}, new_cid{new_cid}, new_subtype{new_subtype}, auto_refit{auto_refit}, only_this{only_this}, num_vehicles{num_vehicles} {} ~RefitVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SendVehicleToDepot: public Command { @@ -337,8 +357,9 @@ public: :veh_id{veh_id}, depot_cmd{depot_cmd}, vli{vli} {} ~SendVehicleToDepot() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ChangeServiceInt: public Command { @@ -352,8 +373,9 @@ public: :veh_id{veh_id}, serv_int{serv_int}, is_custom{is_custom}, is_percent{is_percent} {} ~ChangeServiceInt() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameVehicle: public Command { @@ -365,8 +387,9 @@ public: :veh_id{veh_id}, text{text} {} ~RenameVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CloneVehicle: public Command { @@ -380,8 +403,9 @@ public: :Command{tile}, veh_id{veh_id}, share_orders{share_orders} {} ~CloneVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class StartStopVehicle: public Command { @@ -393,8 +417,9 @@ public: :veh_id{veh_id}, evaluate_startstop_cb{evaluate_startstop_cb} {} ~StartStopVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class MassStartStopVehicle: public Command { @@ -409,8 +434,9 @@ public: :Command{tile}, do_start{do_start}, vehicle_list_window{vehicle_list_window}, vli{vli} {} ~MassStartStopVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DepotSellAllVehicles: public Command { @@ -423,8 +449,9 @@ public: :Command{tile}, vehicle_type{vehicle_type} {} ~DepotSellAllVehicles() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DepotMassAutoReplace: public Command { @@ -437,8 +464,9 @@ public: :Command{tile}, vehicle_type{vehicle_type} {} ~DepotMassAutoReplace() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ChangeSetting: public Command { @@ -450,8 +478,9 @@ public: :name{name}, value{value} {} ~ChangeSetting() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ChangeCompanySetting: public Command { @@ -463,8 +492,9 @@ public: :name{name}, value{value} {} ~ChangeCompanySetting() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CreateGroup: public Command { @@ -476,8 +506,9 @@ public: :vt{vt}, parent_group{parent_group} {} ~CreateGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class AlterGroup: public Command { @@ -491,8 +522,9 @@ public: :mode{mode}, group_id{group_id}, parent_id{parent_id}, text{text} {} ~AlterGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DeleteGroup: public Command { @@ -503,8 +535,9 @@ public: :group_id{group_id} {} ~DeleteGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class AddVehicleGroup: public Command { @@ -517,8 +550,9 @@ public: :group_id{group_id}, veh_id{veh_id}, add_shared{add_shared} {} ~AddVehicleGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class AddSharedVehicleGroup: public Command { @@ -530,8 +564,9 @@ public: :id_g{id_g}, type{type} {} ~AddSharedVehicleGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveAllVehiclesGroup: public Command { @@ -542,8 +577,9 @@ public: :group_id{group_id} {} ~RemoveAllVehiclesGroup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetGroupFlag: public Command { @@ -557,8 +593,9 @@ public: :group_id{group_id}, flag{flag}, value{value}, recursive{recursive} {} ~SetGroupFlag() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetGroupLivery: public Command { @@ -571,8 +608,9 @@ public: :group_id{group_id}, primary{primary}, colour{colour} {} ~SetGroupLivery() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TurnRoadVeh: public Command { @@ -583,8 +621,9 @@ public: :veh_id{veh_id} {} ~TurnRoadVeh() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ChangeTimetable: public Command { @@ -598,8 +637,9 @@ public: :veh{veh}, order_number{order_number}, mtf{mtf}, data{data} {} ~ChangeTimetable() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetVehicleOnTime: public Command { @@ -610,8 +650,9 @@ public: :veh{veh} {} ~SetVehicleOnTime() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class AutofillTimetable: public Command { @@ -624,8 +665,9 @@ public: :veh{veh}, autofill{autofill}, preserve_wait_time{preserve_wait_time} {} ~AutofillTimetable() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetTimetableStart: public Command { @@ -638,8 +680,9 @@ public: :veh_id{veh_id}, timetable_all{timetable_all}, start_date{start_date} {} ~SetTimetableStart() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class WantEnginePreview: public Command { @@ -650,8 +693,9 @@ public: :engine_id{engine_id} {} ~WantEnginePreview() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class EngineCtrl: public Command { @@ -664,8 +708,9 @@ public: :engine_id{engine_id}, company_id{company_id}, allow{allow} {} ~EngineCtrl() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameEngine: public Command { @@ -677,8 +722,9 @@ public: :engine_id{engine_id}, text{text} {} ~RenameEngine() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetVehicleVisibility: public Command { @@ -690,8 +736,9 @@ public: :engine_id{engine_id}, hide{hide} {} ~SetVehicleVisibility() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class PlantTree: public Command { @@ -705,8 +752,9 @@ public: :Command{tile}, start_tile{start_tile}, tree_to_plant{tree_to_plant} {} ~PlantTree() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class LandscapeClear: public Command { @@ -717,8 +765,9 @@ public: :Command{tile} {} ~LandscapeClear() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ClearArea: public Command { @@ -732,8 +781,9 @@ public: :Command{tile}, start_tile{start_tile}, diagonal{diagonal} {} ~ClearArea() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildAirport: public Command { @@ -749,8 +799,9 @@ public: :Command{tile}, airport_type{airport_type}, layout{layout}, station_to_join{station_to_join}, adjacent{adjacent} {} ~BuildAirport() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildDock: public Command { @@ -764,8 +815,9 @@ public: :Command{tile}, station_to_join{station_to_join}, adjacent{adjacent} {} ~BuildDock() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRailStation: public Command { @@ -785,8 +837,9 @@ public: :Command{tile}, rt{rt}, axis{axis}, numtracks{numtracks}, plat_len{plat_len}, spec_class{spec_class}, spec_index{spec_index}, station_to_join{station_to_join}, adjacent{adjacent} {} ~BuildRailStation() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveFromRailStation: public Command { @@ -800,8 +853,9 @@ public: :Command{tile}, end{end}, keep_rail{keep_rail} {} ~RemoveFromRailStation() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRoadStop: public Command { @@ -821,8 +875,9 @@ public: :Command{tile}, width{width}, length{length}, stop_type{stop_type}, is_drive_through{is_drive_through}, ddir{ddir}, rt{rt}, station_to_join{station_to_join}, adjacent{adjacent} {} ~BuildRoadStop() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveRoadStop: public Command { @@ -838,8 +893,9 @@ public: :Command{tile}, width{width}, height{height}, stop_type{stop_type}, remove_road{remove_road} {} ~RemoveRoadStop() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameStation: public Command { @@ -851,8 +907,9 @@ public: :station_id{station_id}, text{text} {} ~RenameStation() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class OpenCloseAirport: public Command { @@ -863,8 +920,9 @@ public: :station_id{station_id} {} ~OpenCloseAirport() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CompanyCtrl: public Command { @@ -878,8 +936,9 @@ public: :cca{cca}, company_id{company_id}, reason{reason}, client_id{client_id} {} ~CompanyCtrl() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class GiveMoney: public Command { @@ -891,8 +950,9 @@ public: :money{money}, dest_company{dest_company} {} ~GiveMoney() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameCompany: public Command { @@ -903,8 +963,9 @@ public: :text{text} {} ~RenameCompany() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenamePresident: public Command { @@ -915,8 +976,9 @@ public: :text{text} {} ~RenamePresident() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetCompanyManagerFace: public Command { @@ -927,8 +989,9 @@ public: :cmf{cmf} {} ~SetCompanyManagerFace() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetCompanyColour: public Command { @@ -941,8 +1004,9 @@ public: :scheme{scheme}, primary{primary}, colour{colour} {} ~SetCompanyColour() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameDepot: public Command { @@ -954,8 +1018,9 @@ public: :depot_id{depot_id}, text{text} {} ~RenameDepot() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class AutoreplaceVehicle: public Command { @@ -966,8 +1031,9 @@ public: :veh_id{veh_id} {} ~AutoreplaceVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SetAutoReplace: public Command { @@ -981,8 +1047,9 @@ public: :id_g{id_g}, old_engine_type{old_engine_type}, new_engine_type{new_engine_type}, when_old{when_old} {} ~SetAutoReplace() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildShipDepot: public Command { @@ -995,8 +1062,9 @@ public: :Command{tile}, axis{axis} {} ~BuildShipDepot() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildCanal: public Command { @@ -1011,8 +1079,9 @@ public: :Command{tile}, start_tile{start_tile}, wc{wc}, diagonal{diagonal} {} ~BuildCanal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildLock: public Command { @@ -1023,8 +1092,9 @@ public: :Command{tile} {} ~BuildLock() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildLongRoad: public Command { @@ -1043,8 +1113,9 @@ public: :Command{tile}, start_tile{start_tile}, rt{rt}, axis{axis}, drd{drd}, start_half{start_half}, end_half{end_half}, is_ai{is_ai} {} ~BuildLongRoad() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveLongRoad: public Command { @@ -1061,8 +1132,9 @@ public: :Command{tile}, start_tile{start_tile}, rt{rt}, axis{axis}, start_half{start_half}, end_half{end_half} {} ~RemoveLongRoad() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRoad: public Command { @@ -1078,8 +1150,9 @@ public: :Command{tile}, pieces{pieces}, rt{rt}, toggle_drd{toggle_drd}, town_id{town_id} {} ~BuildRoad() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRoadDepot: public Command { @@ -1093,8 +1166,9 @@ public: :Command{tile}, rt{rt}, dir{dir} {} ~BuildRoadDepot() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ConvertRoad: public Command { @@ -1108,8 +1182,9 @@ public: :Command{tile}, area_start{area_start}, to_type{to_type} {} ~ConvertRoad() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRailroadTrack: public Command { @@ -1126,8 +1201,9 @@ public: :Command{tile}, start_tile{start_tile}, railtype{railtype}, track{track}, auto_remove_signals{auto_remove_signals}, fail_on_obstacle{fail_on_obstacle} {} ~BuildRailroadTrack() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveRailroadTrack: public Command { @@ -1141,8 +1217,9 @@ public: :Command{tile}, start_tile{start_tile}, track{track} {} ~RemoveRailroadTrack() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildSingleRail: public Command { @@ -1157,8 +1234,9 @@ public: :Command{tile}, railtype{railtype}, track{track}, auto_remove_signals{auto_remove_signals} {} ~BuildSingleRail() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveSingleRail: public Command { @@ -1171,8 +1249,9 @@ public: :Command{tile}, track{track} {} ~RemoveSingleRail() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildTrainDepot: public Command { @@ -1186,8 +1265,9 @@ public: :Command{tile}, railtype{railtype}, dir{dir} {} ~BuildTrainDepot() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildSingleSignal: public Command { @@ -1209,8 +1289,9 @@ public: :Command{tile}, track{track}, sigtype{sigtype}, sigvar{sigvar}, convert_signal{convert_signal}, skip_existing_signals{skip_existing_signals}, ctrl_pressed{ctrl_pressed}, cycle_start{cycle_start}, cycle_stop{cycle_stop}, num_dir_cycle{num_dir_cycle}, signals_copy{signals_copy} {} ~BuildSingleSignal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveSingleSignal: public Command { @@ -1223,8 +1304,9 @@ public: :Command{tile}, track{track} {} ~RemoveSingleSignal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ConvertRail: public Command { @@ -1239,8 +1321,9 @@ public: :Command{tile}, area_start{area_start}, totype{totype}, diagonal{diagonal} {} ~ConvertRail() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildSignalTrack: public Command { @@ -1260,8 +1343,9 @@ public: :Command{tile}, end_tile{end_tile}, track{track}, sigtype{sigtype}, sigvar{sigvar}, mode{mode}, autofill{autofill}, minimise_gaps{minimise_gaps}, signal_density{signal_density} {} ~BuildSignalTrack() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveSignalTrack: public Command { @@ -1276,8 +1360,9 @@ public: :Command{tile}, end_tile{end_tile}, track{track}, autofill{autofill} {} ~RemoveSignalTrack() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildIndustry: public Command { @@ -1293,8 +1378,9 @@ public: :Command{tile}, it{it}, first_layout{first_layout}, fund{fund}, seed{seed} {} ~BuildIndustry() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class IndustryCtrl: public Command { @@ -1309,8 +1395,9 @@ public: :ind_id{ind_id}, action{action}, ctlflags{ctlflags}, company_id{company_id}, text{text} {} ~IndustryCtrl() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildRailWaypoint: public Command { @@ -1329,8 +1416,9 @@ public: :Command{tile}, axis{axis}, width{width}, height{height}, spec_class{spec_class}, spec_index{spec_index}, station_to_join{station_to_join}, adjacent{adjacent} {} ~BuildRailWaypoint() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RemoveFromRailWaypoint: public Command { @@ -1344,8 +1432,9 @@ public: :Command{tile}, end{end}, keep_rail{keep_rail} {} ~RemoveFromRailWaypoint() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildBuoy: public Command { @@ -1356,8 +1445,9 @@ public: :Command{tile} {} ~BuildBuoy() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameWaypoint: public Command { @@ -1369,8 +1459,9 @@ public: :waypoint_id{waypoint_id}, text{text} {} ~RenameWaypoint() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class FoundTown: public Command { @@ -1388,8 +1479,9 @@ public: :Command{tile}, size{size}, city{city}, layout{layout}, random_location{random_location}, townnameparts{townnameparts}, text{text} {} ~FoundTown() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameTown: public Command { @@ -1401,8 +1493,9 @@ public: :town_id{town_id}, text{text} {} ~RenameTown() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DoTownAction: public Command { @@ -1414,8 +1507,9 @@ public: :town_id{town_id}, action{action} {} ~DoTownAction() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TownGrowthRate: public Command { @@ -1427,8 +1521,9 @@ public: :town_id{town_id}, growth_rate{growth_rate} {} ~TownGrowthRate() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TownRating: public Command { @@ -1441,8 +1536,9 @@ public: :town_id{town_id}, company_id{company_id}, rating{rating} {} ~TownRating() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TownCargoGoal: public Command { @@ -1455,8 +1551,9 @@ public: :town_id{town_id}, te{te}, goal{goal} {} ~TownCargoGoal() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TownSetText: public Command { @@ -1468,8 +1565,9 @@ public: :town_id{town_id}, text{text} {} ~TownSetText() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ExpandTown: public Command { @@ -1481,8 +1579,9 @@ public: :town_id{town_id}, grow_amount{grow_amount} {} ~ExpandTown() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DeleteTown: public Command { @@ -1493,8 +1592,9 @@ public: :town_id{town_id} {} ~DeleteTown() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildObject: public Command { @@ -1508,8 +1608,9 @@ public: :Command{tile}, type{type}, view{view} {} ~BuildObject() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildObjectArea: public Command { @@ -1525,8 +1626,9 @@ public: :Command{tile}, start_tile{start_tile}, type{type}, view{view}, diagonal{diagonal} {} ~BuildObjectArea() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class MoveRailVehicle: public Command { @@ -1539,8 +1641,9 @@ public: :src_veh{src_veh}, dest_veh{dest_veh}, move_chain{move_chain} {} ~MoveRailVehicle() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ForceTrainProceed: public Command { @@ -1551,8 +1654,9 @@ public: :veh_id{veh_id} {} ~ForceTrainProceed() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ReverseTrainDirection: public Command { @@ -1564,8 +1668,9 @@ public: :veh_id{veh_id}, reverse_single_veh{reverse_single_veh} {} ~ReverseTrainDirection() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class PlaceSign: public Command { @@ -1578,8 +1683,9 @@ public: :Command{tile}, text{text} {} ~PlaceSign() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class RenameSign: public Command { @@ -1591,8 +1697,9 @@ public: :sign_id{sign_id}, text{text} {} ~RenameSign() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildBridge: public Command { @@ -1608,8 +1715,9 @@ public: :Command{tile}, tile_start{tile_start}, transport_type{transport_type}, bridge_type{bridge_type}, road_rail_type{road_rail_type} {} ~BuildBridge() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuildTunnel: public Command { @@ -1623,8 +1731,9 @@ public: :Command{tile}, transport_type{transport_type}, road_rail_type{road_rail_type} {} ~BuildTunnel() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class TerraformLand: public Command { @@ -1638,8 +1747,9 @@ public: :Command{tile}, slope{slope}, dir_up{dir_up} {} ~TerraformLand() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class LevelLand: public Command { @@ -1654,8 +1764,9 @@ public: :Command{tile}, start_tile{start_tile}, diagonal{diagonal}, lm{lm} {} ~LevelLand() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class MoneyCheat: public Command { @@ -1666,8 +1777,9 @@ public: :amount{amount} {} ~MoneyCheat() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ChangeBankBalance: public Command { @@ -1682,8 +1794,9 @@ public: :Command{tile}, delta{delta}, company{company}, expenses_type{expenses_type} {} ~ChangeBankBalance() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class IncreaseLoan: public Command { @@ -1695,8 +1808,9 @@ public: :cmd{cmd}, amount{amount} {} ~IncreaseLoan() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DecreaseLoan: public Command { @@ -1708,8 +1822,9 @@ public: :cmd{cmd}, amount{amount} {} ~DecreaseLoan() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class Pause: public Command { @@ -1721,8 +1836,9 @@ public: :mode{mode}, pause{pause} {} ~Pause() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ModifyOrder: public Command { @@ -1736,8 +1852,9 @@ public: :veh{veh}, sel_ord{sel_ord}, mof{mof}, data{data} {} ~ModifyOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SkipToOrder: public Command { @@ -1749,8 +1866,9 @@ public: :veh_id{veh_id}, sel_ord{sel_ord} {} ~SkipToOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class DeleteOrder: public Command { @@ -1762,8 +1880,9 @@ public: :veh_id{veh_id}, sel_ord{sel_ord} {} ~DeleteOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class InsertOrder: public Command { @@ -1776,8 +1895,9 @@ public: :veh{veh}, sel_ord{sel_ord}, new_order{new_order} {} ~InsertOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class OrderRefit: public Command { @@ -1790,8 +1910,9 @@ public: :veh{veh}, order_number{order_number}, cargo{cargo} {} ~OrderRefit() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CloneOrder: public Command { @@ -1804,8 +1925,9 @@ public: :action{action}, veh_dst{veh_dst}, veh_src{veh_src} {} ~CloneOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class MoveOrder: public Command { @@ -1818,8 +1940,9 @@ public: :veh{veh}, moving_order{moving_order}, target_order{target_order} {} ~MoveOrder() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ClearOrderBackup: public Command { @@ -1832,8 +1955,9 @@ public: :Command{tile}, user_id{user_id} {} ~ClearOrderBackup() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class CreateSubsidy: public Command { @@ -1848,8 +1972,9 @@ public: :cid{cid}, src_type{src_type}, src{src}, dst_type{dst_type}, dst{dst} {} ~CreateSubsidy() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class ScrollViewport: public Command { @@ -1863,8 +1988,9 @@ public: :Command{tile}, target{target}, ref{ref} {} ~ScrollViewport() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuyShareInCompany: public Command { @@ -1875,8 +2001,9 @@ public: :target_company{target_company} {} ~BuyShareInCompany() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class SellShareInCompany: public Command { @@ -1887,8 +2014,9 @@ public: :target_company{target_company} {} ~SellShareInCompany() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; class BuyCompany: public Command { @@ -1899,8 +2027,9 @@ public: :target_company{target_company} {} ~BuyCompany() override {} - bool do_post(CommandCallback * callback) override; - bool do_test() override; + bool _post(::CommandCallback * callback) override; + CommandCost _do(DoCommandFlag flags) override; + Commands get_command() override; }; } // namespace cmd diff --git a/src/command.cpp b/src/command.cpp index 358c7be501..e75b29f8b2 100644 --- a/src/command.cpp +++ b/src/command.cpp @@ -233,7 +233,7 @@ std::tuple CommandHelperBase::InternalPostBefore(Commands cmd, * However, in case of incoming network commands, * map generation or the pause button we do want * to execute. */ - bool estimate_only = citymania::_estimate_mod && IsLocalCompany() && !_generating_world && !network_command && !(flags & CMD_NO_EST); + bool estimate_only = citymania::_estimate_mod && IsLocalCompany() && !_generating_world && !network_command && !(flags & CMD_NO_EST) && !citymania::_auto_command; /* We're only sending the command, so don't do * fancy things for 'success'. */ diff --git a/src/command_func.h b/src/command_func.h index d78c8229a4..67367feef6 100644 --- a/src/command_func.h +++ b/src/command_func.h @@ -18,6 +18,9 @@ #include "misc/endian_buffer.hpp" #include "tile_map.h" +struct CommandPacket; +namespace citymania { extern void ExecuteCurrentCallback(const CommandCost &cost); } + /** * Define a default return value for a failed command. * @@ -338,6 +341,7 @@ protected: std::apply(callback, std::tuple_cat(std::make_tuple(Tcmd), res, args)); } } + citymania::ExecuteCurrentCallback(ExtractCommandCost(res)); } return ExtractCommandCost(res).Succeeded(); diff --git a/src/network/network_command.cpp b/src/network/network_command.cpp index 55dcd8eb25..67117cd642 100644 --- a/src/network/network_command.cpp +++ b/src/network/network_command.cpp @@ -286,14 +286,15 @@ void NetworkSendCommand(Commands cmd, StringID err_message, CommandCallback *cal c.my_cmd = true; _local_wait_queue.Append(&c); + citymania::AddCommandCallback(&c); return; } c.frame = 0; // The client can't tell which frame, so just make it 0 /* Clients send their command to the server and forget all about the packet */ - MyClient::SendCommand(&c); - // FIXME citymania::SendClientCommand(&c); + // MyClient::SendCommand(&c); + citymania::SendClientCommand(&c); } /** @@ -542,6 +543,8 @@ CommandDataBuffer SanitizeCmdStrings(const CommandDataBuffer &data) template void UnpackNetworkCommand(const CommandPacket* cp) { + citymania::BeforeNetworkCommandExecution(cp); auto args = EndianBufferReader::ToValue::Args>(cp->data); Command::PostFromNet(cp->err_msg, std::get(_callback_tuple), cp->my_cmd, cp->tile, args); + citymania::AfterNetworkCommandExecution(cp); } diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index f45c86e836..7bdf26b5bd 100644 --- a/src/rail_gui.cpp +++ b/src/rail_gui.cpp @@ -52,6 +52,7 @@ #include "citymania/cm_hotkeys.hpp" #include "citymania/cm_highlight.hpp" #include "citymania/cm_station_gui.hpp" +#include "citymania/cm_rail_gui.hpp" #include "safeguards.h" @@ -66,8 +67,6 @@ static bool _convert_signal_button; ///< convert signal button in the s static SignalVariant _cur_signal_variant; ///< set the signal variant (for signal GUI) static SignalType _cur_signal_type; ///< set the signal type (for signal GUI) -extern TileIndex _rail_track_endtile; // CM rail_cmd.cpp - static const int HOTKEY_MASK = 0x1000; static const int HOTKEY_POLYRAIL = 0x1000; static const int HOTKEY_NEW_POLYRAIL = 0x1001; @@ -111,17 +110,6 @@ void CcPlaySound_CONSTRUCTION_RAIL(Commands cmd, const CommandCost &result, Tile if (result.Succeeded() && _settings_client.sound.confirm) SndPlayTileFx(SND_20_CONSTRUCTION_RAIL, tile); } -static void GenericPlaceRail(TileIndex tile, Track track) -{ - if (_remove_button_clicked) { - Command::Post(STR_ERROR_CAN_T_REMOVE_RAILROAD_TRACK, CcPlaySound_CONSTRUCTION_RAIL, - tile, track); - } else { - Command::Post(STR_ERROR_CAN_T_BUILD_RAILROAD_TRACK, CcPlaySound_CONSTRUCTION_RAIL, - tile, _cur_railtype, track, _settings_client.gui.auto_remove_signals); - } -} - /** * Try to add an additional rail-track at the entrance of a depot * @param tile Tile to use for adding the rail-track @@ -373,185 +361,6 @@ static void BuildRailClick_Remove(Window *w) } } -/* FIXME static CommandContainer DoRailroadTrackCmd(TileIndex start_tile, TileIndex end_tile, Track track) -{ - CommandContainer ret = { - start_tile, // tile - end_tile, // p1 - ((uint32)_cur_railtype | ((uint32)track << 6) | ((uint32)_settings_client.gui.auto_remove_signals << 11)), // p2 - _remove_button_clicked ? - CMD_REMOVE_RAILROAD_TRACK | CMD_MSG(STR_ERROR_CAN_T_REMOVE_RAILROAD_TRACK) : - CMD_BUILD_RAILROAD_TRACK | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_TRACK), // cmd - CcPlaySound_CONSTRUCTION_RAIL, // callback - "" // text - }; - - return ret; -} -*/ -namespace citymania { -/* -static bool DoAutodirTerraform(bool diagonal, TileIndex start_tile, TileIndex end_tile, Track track, CommandContainer &rail_cmd, TileIndex s1, TileIndex e1, TileIndex s2, TileIndex e2) { - auto rail_callback = [rail_cmd, start_tile, end_tile, track, estimate=citymania::_estimate_mod](bool res) -> bool { - if (DoCommand(&rail_cmd, DC_AUTO | DC_NO_WATER).GetErrorMessage() != STR_ERROR_ALREADY_BUILT || - _rail_track_endtile == INVALID_TILE) { - if (!DoCommandP(&rail_cmd)) return false; - } - if (!estimate && _rail_track_endtile != INVALID_TILE) - StoreRailPlacementEndpoints(start_tile, _rail_track_endtile, track, true); - return res; - }; - - auto h1 = TileHeight(s1); - auto h2 = TileHeight(s2); - uint32 diag_flag = diagonal ? 1 : 0; - uint32 p2_1 = ((h1 < h2 ? LM_RAISE : LM_LEVEL) << 1) | diag_flag; - uint32 p2_2 = ((h2 < h1 ? LM_RAISE : LM_LEVEL) << 1) | diag_flag; - auto l1_fail = (!DoCommand(e1, s1, p2_1, DC_AUTO | DC_NO_WATER, CMD_LEVEL_LAND).Succeeded()); - auto l2_fail = (!DoCommand(e2, s2, p2_2, DC_AUTO | DC_NO_WATER, CMD_LEVEL_LAND).Succeeded()); - if (l1_fail && l2_fail) return rail_callback(true); - if (l2_fail) return citymania::DoCommandWithCallback(e1, s1, p2_1, CMD_LEVEL_LAND, CcTerraform, "", rail_callback); - if (!l1_fail) DoCommandP(e1, s1, p2_1, CMD_LEVEL_LAND, CcTerraform); - return citymania::DoCommandWithCallback(e2, s2, p2_2, CMD_LEVEL_LAND, CcTerraform, "", rail_callback); -} - -static bool HandleAutodirTerraform(TileIndex start_tile, TileIndex end_tile, Track track, CommandContainer &rail_cmd) { - bool eq = (TileX(end_tile) - TileY(end_tile) == TileX(start_tile) - TileY(start_tile)); - bool ez = (TileX(end_tile) + TileY(end_tile) == TileX(start_tile) + TileY(start_tile)); - // StoreRailPlacementEndpoints(start_tile, end_tile, track, true); - switch (_thd.cm_poly_dir) { - case TRACKDIR_X_NE: - return DoAutodirTerraform(false, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 1, 0), end_tile, - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, 0, 1)); - break; - case TRACKDIR_X_SW: - return DoAutodirTerraform(false, start_tile, end_tile, track, rail_cmd, - start_tile, TILE_ADDXY(end_tile, 1, 0), - TILE_ADDXY(start_tile, 0, 1), TILE_ADDXY(end_tile, 1, 1)); - break; - case TRACKDIR_Y_SE: - return DoAutodirTerraform(false, start_tile, end_tile, track, rail_cmd, - start_tile, TILE_ADDXY(end_tile, 0, 1), - TILE_ADDXY(start_tile, 1, 0), TILE_ADDXY(end_tile, 1, 1)); - break; - case TRACKDIR_Y_NW: - return DoAutodirTerraform(false, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 0, 1), end_tile, - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, 1, 0)); - break; - case TRACKDIR_LEFT_N: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 1, 0), TILE_ADDXY(end_tile, eq, 0), - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, 0, !eq)); - break; - } - case TRACKDIR_RIGHT_N: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 0, 1), TILE_ADDXY(end_tile, 0, eq), - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, !eq, 0)); - break; - } - case TRACKDIR_LEFT_S: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 1, 0), TILE_ADDXY(end_tile, 1, !eq), - start_tile, TILE_ADDXY(end_tile, eq, 1)); - break; - } - case TRACKDIR_RIGHT_S: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 0, 1), TILE_ADDXY(end_tile, !eq, 1), - start_tile, TILE_ADDXY(end_tile, 1, eq)); - break; - } - case TRACKDIR_UPPER_E: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - start_tile, TILE_ADDXY(end_tile, 0, !ez), - TILE_ADDXY(start_tile, 1, 0), TILE_ADDXY(end_tile, !ez, 1)); - break; - } - case TRACKDIR_LOWER_E: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, ez, 1), - TILE_ADDXY(start_tile, 1, 0), TILE_ADDXY(end_tile, 0, ez)); - break; - } - case TRACKDIR_UPPER_W: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - start_tile, TILE_ADDXY(end_tile, !ez, 0), - TILE_ADDXY(start_tile, 0, 1), TILE_ADDXY(end_tile, 1, !ez)); - break; - } - case TRACKDIR_LOWER_W: { - return DoAutodirTerraform(true, start_tile, end_tile, track, rail_cmd, - TILE_ADDXY(start_tile, 1, 1), TILE_ADDXY(end_tile, 1, ez), - TILE_ADDXY(start_tile, 0, 1), TILE_ADDXY(end_tile, ez, 0)); - break; - } - default: - break; - } - return true; -}*/ - -} // namespace citymania - -//FIXME -static void DoRailroadTrack(Track track) -{ - if (_remove_button_clicked) { - Command::Post(STR_ERROR_CAN_T_REMOVE_RAILROAD_TRACK, CcPlaySound_CONSTRUCTION_RAIL, - TileVirtXY(_thd.selend.x, _thd.selend.y), TileVirtXY(_thd.selstart.x, _thd.selstart.y), track); - } else { - Command::Post(STR_ERROR_CAN_T_BUILD_RAILROAD_TRACK, CcPlaySound_CONSTRUCTION_RAIL, - TileVirtXY(_thd.selend.x, _thd.selend.y), TileVirtXY(_thd.selstart.x, _thd.selstart.y), _cur_railtype, track, _settings_client.gui.auto_remove_signals, false); - } -} - -static void HandleAutodirPlacement() -{ - Track trackstat = static_cast( _thd.drawstyle & HT_DIR_MASK); // 0..5 - - if (_thd.drawstyle & HT_RAIL) { // one tile case - GenericPlaceRail(TileVirtXY(_thd.selend.x, _thd.selend.y), trackstat); - return; - } - - DoRailroadTrack(trackstat); -} -// end FIXME - -/* -static void HandleAutodirPlacement() -{ - Track track = (Track)(_thd.drawstyle & HT_DIR_MASK); // 0..5 - TileIndex start_tile = TileVirtXY(_thd.selstart.x, _thd.selstart.y); - TileIndex end_tile = TileVirtXY(_thd.selend.x, _thd.selend.y); - /* FIXME - CommandContainer cmd = (_thd.drawstyle & HT_RAIL) ? - GenericPlaceRailCmd(end_tile, track) : // one tile case - DoRailroadTrackCmd(start_tile, end_tile, track); // multitile selection - - /* When overbuilding existing tracks in polyline mode we want to move the - * snap point over the last overbuilt track piece. In such case we don't - * wan't to show any errors to the user. Don't execute the command right - * away, first check if overbuilding. */ - /* if (citymania::_estimate_mod || !(_thd.place_mode & HT_POLY) || _remove_button_clicked) { - if (!DoCommandP(&cmd)) return; - } else if (_thd.cm_poly_terra) { - citymania::HandleAutodirTerraform(start_tile, end_tile, track, cmd); - return; - } else if (DoCommand(&cmd, DC_AUTO | DC_NO_WATER).GetErrorMessage() != STR_ERROR_ALREADY_BUILT || - _rail_track_endtile == INVALID_TILE) { - if (!DoCommandP(&cmd)) return; - } */ - /* Save new snap points for the polyline tool, no matter if the command - * succeeded, the snapping will be extended over overbuilt track pieces. */ - /*if (!citymania::_estimate_mod && _rail_track_endtile != INVALID_TILE) { - StoreRailPlacementEndpoints(start_tile, _rail_track_endtile, track, true); - } -}*/ - /** * Build new signals or remove signals or (if only one tile marked) edit a signal. * @@ -1002,7 +811,7 @@ struct BuildRailToolbarWindow : Window { break; case DDSP_PLACE_RAIL: - HandleAutodirPlacement(); + citymania::HandleAutodirPlacement(_cur_railtype, _remove_button_clicked); break; case DDSP_BUILD_SIGNALS: