From 4e047eec9b7f6c06a9cdbc9522adff4a9f45ebae Mon Sep 17 00:00:00 2001 From: Pavel Stupnikov Date: Fri, 2 Dec 2022 19:55:21 +0400 Subject: [PATCH] Fix compilation errors --- gen_commands.py | 62 ++- src/bridge_gui.cpp | 2 +- src/citymania/cm_blueprint.cpp | 138 +++--- src/citymania/cm_command_type.hpp | 19 + src/citymania/cm_commands.cpp | 25 +- src/citymania/cm_highlight.cpp | 78 ++- src/citymania/cm_highlight.hpp | 3 - src/citymania/cm_highlight_type.hpp | 2 +- src/citymania/cm_minimap.cpp | 2 +- src/citymania/cm_misc_gui.cpp | 3 +- src/citymania/cm_station_gui.cpp | 40 +- src/citymania/generated/cm_gen_commands.cpp | 251 ++++++++++ src/citymania/generated/cm_gen_commands.hpp | 498 +++++++++++++++++++- src/command.cpp | 4 +- src/main_gui.cpp | 2 + src/misc_cmd.cpp | 2 +- src/network/network.cpp | 2 +- src/network/network_command.cpp | 7 +- src/object_gui.cpp | 2 +- src/order_gui.cpp | 8 +- src/rail_gui.cpp | 21 +- src/road_gui.cpp | 4 +- src/station_cmd.cpp | 8 +- src/terraform_gui.cpp | 3 +- src/toolbar_gui.cpp | 5 +- src/town_cmd.cpp | 2 +- src/town_gui.cpp | 1 + src/vehicle_gui.cpp | 4 +- src/viewport.cpp | 4 +- 29 files changed, 981 insertions(+), 221 deletions(-) diff --git a/gen_commands.py b/gen_commands.py index c82d20418a..50295eba95 100644 --- a/gen_commands.py +++ b/gen_commands.py @@ -3,6 +3,7 @@ from pathlib import Path from pprint import pprint RX_COMMAND = re.compile(r'(?PCommandCost|std::tuple]*>) (?PCmd\w*)\((?P[^)]*)\);') +RX_DEF_TRAIT = re.compile(r'DEF_CMD_TRAIT\((?P\w+),\s+(?P\w+),\s+[^,]*,\s+(?P\w+)\)') RX_ARG = re.compile(r'(?P(:?const |)[\w:]* &?)(?P\w*)') RX_CAMEL_TO_SNAKE = re.compile(r'(?{an}' for _, an in args) + for cmd in commands: + name = cmd['name'] + constant = cmd['constant'] + # constant = 'CMD_' + RX_CAMEL_TO_SNAKE.sub('_', name).upper() + args_list = ', '.join(f'this->{an}' for _, an in cmd['args']) + test_args_list = args_list + if cmd.get('first_tile_arg'): + test_args_list = f'this->tile, ' + args_list + + cost_getter = '' if cmd['returns'] is None else 'std::get<0>' + f.write( f'bool {name}::DoPost() {{\n' f' return ::Command<{constant}>::Post(this->error, this->tile, {args_list});\n' '}\n' ) + f.write( + f'bool {name}::DoTest() {{\n' + f' return {cost_getter}(::Command<{constant}>::Do(DC_NONE, {test_args_list})).Succeeded();\n' + '}\n' + ) f.write('\n') f.write( '} // namespace cmd\n' diff --git a/src/bridge_gui.cpp b/src/bridge_gui.cpp index 9b6d16e2ab..043eacbf2b 100644 --- a/src/bridge_gui.cpp +++ b/src/bridge_gui.cpp @@ -71,7 +71,7 @@ void CcBuildBridge(Commands cmd, const CommandCost &result, TileIndex end_tile, ConnectRoadToStructure(tile_start, start_direction); } - StoreRailPlacementEndpoints(p1, end_tile, (TileX(p1) == TileX(end_tile)) ? TRACK_Y : TRACK_X, false); + StoreRailPlacementEndpoints(tile_start, end_tile, (TileX(tile_start) == TileX(end_tile)) ? TRACK_Y : TRACK_X, false); } /** Window class for handling the bridge-build GUI. */ diff --git a/src/citymania/cm_blueprint.cpp b/src/citymania/cm_blueprint.cpp index 64b53b75e3..ade545292c 100644 --- a/src/citymania/cm_blueprint.cpp +++ b/src/citymania/cm_blueprint.cpp @@ -9,6 +9,7 @@ #include "../debug.h" #include "../direction_type.h" #include "../rail_map.h" +#include "../station_cmd.h" #include "../station_map.h" #include "../station_base.h" #include "../tilearea_type.h" @@ -21,6 +22,17 @@ extern TileHighlightData _thd; extern RailType _cur_railtype; extern void GetStationLayout(byte *layout, uint numtracks, uint plat_len, const StationSpec *statspec); +// from rail_gui.cpp +struct RailStationGUISettings { + Axis orientation; ///< Currently selected rail station orientation + + bool newstations; ///< Are custom station definitions available? + StationClassID station_class; ///< Currently selected custom station class (if newstations is \c true ) + byte station_type; ///< %Station type within the currently selected custom station class (if newstations is \c true ) + byte station_count; ///< Number of custom stations (if newstations is \c true ) +}; +extern RailStationGUISettings _railstation; ///< Settings of the station builder GUI + namespace citymania { @@ -92,7 +104,7 @@ void Blueprint::Add(TileIndex source_tile, Blueprint::Item item) { } } -CommandContainer GetBlueprintCommand(TileIndex start, const Blueprint::Item &item) { +up GetBlueprintCommand(TileIndex start, const Blueprint::Item &item) { static const Track SIGNAL_POS_TRACK[] = { TRACK_LEFT, TRACK_LEFT, TRACK_RIGHT, TRACK_RIGHT, TRACK_UPPER, TRACK_UPPER, TRACK_LOWER, TRACK_LOWER, @@ -116,71 +128,76 @@ CommandContainer GetBlueprintCommand(TileIndex start, const Blueprint::Item &ite end_tile = new_tile; tdir = NextTrackdir(tdir); } - return CommandContainer { - start_tile, + return make_up( end_tile, - (uint32)(_cur_railtype) | ((uint32)TrackdirToTrack(item.u.rail.track.start_dir) << 6), - CMD_BUILD_RAILROAD_TRACK, - nullptr, "" - }; + start_tile, + _cur_railtype, + TrackdirToTrack(item.u.rail.track.start_dir), + true, // auto_remove_signals + false // fail_on_obastacle + ); } case Blueprint::Item::Type::RAIL_DEPOT: - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.tdiff), _cur_railtype, - item.u.rail.depot.ddir, - CMD_BUILD_TRAIN_DEPOT, - nullptr, "" - }; + item.u.rail.depot.ddir + ); case Blueprint::Item::Type::RAIL_TUNNEL: // TODO check that other end is where it should be - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.tdiff), - (uint32)_cur_railtype | ((uint32)TRANSPORT_RAIL << 8), - 0, - CMD_BUILD_TUNNEL, - nullptr, "" - }; + TRANSPORT_RAIL, + _cur_railtype + ); case Blueprint::Item::Type::RAIL_BRIDGE: - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.u.rail.bridge.other_end), AddTileIndexDiffCWrap(start, item.tdiff), - item.u.rail.bridge.type | (_cur_railtype << 8) | (TRANSPORT_RAIL << 15), - CMD_BUILD_BRIDGE, - nullptr, "" - }; + TRANSPORT_RAIL, + item.u.rail.bridge.type, + _cur_railtype + ); case Blueprint::Item::Type::RAIL_STATION_PART: - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.tdiff), - (uint32)_cur_railtype - | ((uint32)item.u.rail.station_part.axis << 6) - | ((uint32)item.u.rail.station_part.numtracks << 8) - | ((uint32)item.u.rail.station_part.plat_len << 16), - (uint32)NEW_STATION << 16, - CMD_BUILD_RAIL_STATION, - nullptr, "" - }; + _cur_railtype, + item.u.rail.station_part.axis, + item.u.rail.station_part.numtracks, + item.u.rail.station_part.plat_len, + _railstation.station_class, + _railstation.station_type, + NEW_STATION, + true + ); case Blueprint::Item::Type::RAIL_STATION: // TODO station types - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.tdiff), - (uint32)_cur_railtype | ((uint32)1 << 8) | ((uint32)1 << 16) | ((uint32)1 << 24), - (uint32)NEW_STATION << 16, - CMD_BUILD_RAIL_STATION, - nullptr, "" - }; + _cur_railtype, + AXIS_X, + 1, + 1, + _railstation.station_class, + _railstation.station_type, + NEW_STATION, + true + ); case Blueprint::Item::Type::RAIL_SIGNAL: - return CommandContainer { + return make_up( AddTileIndexDiffCWrap(start, item.tdiff), - SIGNAL_POS_TRACK[item.u.rail.signal.pos] - | (item.u.rail.signal.variant << 4) - | (item.u.rail.signal.type << 5) - | (SIGNAL_POS_NUM[item.u.rail.signal.pos] + (item.u.rail.signal.type <= SIGTYPE_LAST_NOPBS && !item.u.rail.signal.twoway ? 1 : 0)) << 15 - | 1 << 17, - 0, - CMD_BUILD_SIGNALS, - nullptr, "" - }; + SIGNAL_POS_TRACK[item.u.rail.signal.pos], + item.u.rail.signal.type, + item.u.rail.signal.variant, + false, // convert_signal + true, // skip_existing_signals + false, // ctrl_pressed + SIGTYPE_NORMAL, // cycle_start + SIGTYPE_NORMAL, // cycle_stop + SIGNAL_POS_NUM[item.u.rail.signal.pos] + + (item.u.rail.signal.type <= SIGTYPE_LAST_NOPBS && !item.u.rail.signal.twoway ? 1 : 0), + false // signals_copy + ); default: NOT_REACHED(); } @@ -198,14 +215,14 @@ std::multimap Blueprint::GetTiles(TileIndex tile std::set can_build_station_sign; for (auto &item: this->items) { if (item.type != Item::Type::RAIL_STATION) continue; - if (CanBuild(GetBlueprintCommand(tile, item))) + if (GetBlueprintCommand(tile, item)->Test()) can_build_station_sign.insert(item.u.rail.station.id); } for (auto &o: this->items) { auto otile = AddTileIndexDiffCWrap(tile, o.tdiff); auto palette = CM_PALETTE_TINT_WHITE; - if (o.type != Item::Type::RAIL_SIGNAL && !CanBuild(GetBlueprintCommand(tile, o))) + if (o.type != Item::Type::RAIL_SIGNAL && !GetBlueprintCommand(tile, o)->Test()) palette = CM_PALETTE_TINT_RED_DEEP; switch(o.type) { @@ -575,7 +592,7 @@ void SetBlueprintHighlight(const TileInfo *ti, TileHighlight &th) { } void BuildBlueprint(sp &blueprint, TileIndex start) { - CommandContainer last_rail = {INVALID_TILE, 0, 0, CMD_END, nullptr, ""}; + up last_rail = nullptr; for (auto &item : blueprint->items) { switch (item.type) { case Blueprint::Item::Type::RAIL_TRACK: @@ -583,15 +600,16 @@ void BuildBlueprint(sp &blueprint, TileIndex start) { case Blueprint::Item::Type::RAIL_TUNNEL: case Blueprint::Item::Type::RAIL_BRIDGE: { auto cc = GetBlueprintCommand(start, item); - if (item.type == Blueprint::Item::Type::RAIL_TRACK) last_rail = cc; - DoCommandP(&cc); + cc->Post(); + if (item.type == Blueprint::Item::Type::RAIL_TRACK) last_rail = std::move(cc); break; } case Blueprint::Item::Type::RAIL_STATION: { // TODO station types TileIndex tile = AddTileIndexDiffCWrap(start, item.tdiff); auto cc = GetBlueprintCommand(start, item); - DoCommandWithCallback(cc, + // FIXME + /* DoCommandWithCallback(cc, [blueprint, tile, start, sign_part=item.u.rail.station.has_part, sid=item.u.rail.station.id] (bool res)->bool { if (!res) return false; StationID station_id = GetStationIndex(tile); @@ -599,12 +617,12 @@ void BuildBlueprint(sp &blueprint, TileIndex start) { if (item.type != Blueprint::Item::Type::RAIL_STATION_PART) continue; if (item.u.rail.station_part.id != sid) continue; auto cc = GetBlueprintCommand(start, item); - DoCommandP(cc.tile, cc.p1 | (1 << 24), station_id << 16, cc.cmd); + // FIXME DoCommandP(cc.tile, cc.p1 | (1 << 24), station_id << 16, cc.cmd); } - if (!sign_part) DoCommandP(tile, 0, 0, CMD_REMOVE_FROM_RAIL_STATION); + if (!sign_part) ::Command::Post(tile, 0, false); return true; } - ); + );*/ break; } default: @@ -616,12 +634,12 @@ void BuildBlueprint(sp &blueprint, TileIndex start) { for (auto &item : blueprint->items) { if (item.type != Blueprint::Item::Type::RAIL_SIGNAL) continue; auto cc = GetBlueprintCommand(start, item); - DoCommandP(&cc); + cc->Post(); } return true; }; - if (last_rail.cmd != CMD_END) { // there can't be any signals if there are no rails - AddCommandCallback(last_rail.tile, last_rail.p1, last_rail.p2, last_rail.cmd, "", signal_callback); + if (last_rail != nullptr) { // there can't be any signals if there are no rails +// FIXME AddCommandCallback(last_rail.tile, last_rail.p1, last_rail.p2, last_rail.cmd, "", signal_callback); } } diff --git a/src/citymania/cm_command_type.hpp b/src/citymania/cm_command_type.hpp index cdabe884fa..1aa344daea 100644 --- a/src/citymania/cm_command_type.hpp +++ b/src/citymania/cm_command_type.hpp @@ -1,10 +1,17 @@ #ifndef CM_COMMAND_TYPE_HPP #define CM_COMMAND_TYPE_HPP +#include "../bridge.h" #include "../command_func.h" #include "../misc_cmd.h" #include "../object_type.h" #include "../order_type.h" +#include "../road_type.h" +#include "../road_type.h" +#include "../station_type.h" +#include "../track_type.h" + +enum StationClassID : byte; namespace citymania { @@ -15,8 +22,11 @@ public: CompanyID as_company = INVALID_COMPANY; StringID error = (StringID)0; + Command() {} + Command(TileIndex tile) :tile{tile} {} virtual ~Command() {} virtual bool DoPost()=0; + virtual bool DoTest()=0; bool Post() { CompanyID old = _current_company; @@ -27,6 +37,15 @@ public: return res; } + bool Test() { + CompanyID old = _current_company; + if (this->as_company != INVALID_COMPANY) + _current_company = as_company; + bool res = this->DoTest(); + _current_company = old; + return res; + } + Command &WithTile(TileIndex tile) { this->tile = tile; return *this; diff --git a/src/citymania/cm_commands.cpp b/src/citymania/cm_commands.cpp index 4baad0176c..875afff464 100644 --- a/src/citymania/cm_commands.cpp +++ b/src/citymania/cm_commands.cpp @@ -26,7 +26,7 @@ void hash_combine(std::size_t& seed, const T& v, const Rest&... rest) size_t GetCommandHash(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, const std::string &text) { size_t res = 0; - hash_combine(res, tile, p1, p2, cmd, text); + // hash_combine(res, tile, p1, p2, cmd, text); return res; } /* @@ -58,13 +58,14 @@ bool DoCommandWithCallback(const CommandContainer &cc, CommandCallback callback) } */ 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); // fprintf(stderr, "EXECUTED %lu (%u %u %u %u %s) %u\n", hash, tile, p1, p2, (uint)(cmd & CMD_ID_MASK), text.c_str(), (int)(p == _command_callbacks.end())); if (p == _command_callbacks.end()) return; for (auto &cb : p->second.second) cb(res); - _command_callbacks.erase(p); + _command_callbacks.erase(p); */ } void ClearOldCallbacks() { @@ -118,24 +119,4 @@ void HandleNextClientFrame() { _outgoing_queue.push(*cp); }*/ - -namespace cmd { - -bool Pause::Post(bool automati) { - return ::Command::Post(this->mode, this->pause); -} - -bool DoTownAction::Post(bool automatic) { - return ::Command::Post(this->town_id, this->town_action); -} - -bool SkipToOrder::Post(bool automatic) { - return ::Command::Post( - this->veh_id, this->sel_ord - _ctrl_pressed ? STR_ERROR_CAN_T_SKIP_TO_ORDER : STR_ERROR_CAN_T_SKIP_ORDER, - this->vehicle->tile, this->vehicle->index, citymania::_fn_mod ? this->OrderGetSel() : ((this->vehicle->cur_implicit_order_index + 1) % this->vehicle->GetNumOrders())); -} - -} // namespace cmd - } // namespace citymania diff --git a/src/citymania/cm_highlight.cpp b/src/citymania/cm_highlight.cpp index e6cafbf1d7..df7944e425 100644 --- a/src/citymania/cm_highlight.cpp +++ b/src/citymania/cm_highlight.cpp @@ -3,6 +3,7 @@ #include "cm_highlight.hpp" #include "cm_blueprint.hpp" +#include "cm_commands.hpp" #include "cm_main.hpp" #include "cm_station_gui.hpp" #include "cm_zoning.hpp" @@ -309,23 +310,6 @@ static const DiagDirection _place_depot_extra_dir[12] = { DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_NW, DIAGDIR_NE, }; -bool CanBuild(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd) { - return DoCommandPInternal( - tile, - p1, - p2, - cmd, - nullptr, // callback - "", // text - true, // my_cmd - true // estimate_only - ).Succeeded(); -} - -bool CanBuild(const CommandContainer &cc) { - return CanBuild(cc.tile, cc.p1, cc.p2, cc.cmd); -} - void ObjectHighlight::AddTile(TileIndex tile, ObjectTileHighlight &&oh) { if (tile >= MapSize()) return; this->tiles.insert(std::make_pair(tile, std::move(oh))); @@ -341,12 +325,11 @@ void ObjectHighlight::UpdateTiles() { case Type::RAIL_DEPOT: { auto dir = this->ddir; - auto palette = (CanBuild( + auto palette = (cmd::BuildTrainDepot( this->tile, _cur_railtype, - dir, - CMD_BUILD_TRAIN_DEPOT - ) ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); + dir + ).Test() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); this->tiles.insert(std::make_pair(this->tile, ObjectTileHighlight::make_rail_depot(palette, dir))); auto tile = this->tile + TileOffsByDiagDir(dir); @@ -363,15 +346,17 @@ void ObjectHighlight::UpdateTiles() { auto plat_len = ta.h; if (this->axis == AXIS_X) Swap(numtracks, plat_len); - auto palette = (CanBuild( + auto palette = (cmd::BuildRailStation( this->tile, - _cur_railtype - | (this->axis << 6) - | ((uint32)numtracks << 8) - | ((uint32)plat_len << 16), - NEW_STATION << 16, - CMD_BUILD_RAIL_STATION - ) ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); + _cur_railtype, + this->axis, + numtracks, + plat_len, + _railstation.station_class, + _railstation.station_type, + NEW_STATION, + true + ).Test() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); auto layout_ptr = AllocaM(byte, (int)numtracks * plat_len); GetStationLayout(layout_ptr, numtracks, plat_len, nullptr); // TODO statspec @@ -393,12 +378,17 @@ void ObjectHighlight::UpdateTiles() { } case Type::ROAD_STOP: { auto ta = OrthogonalTileArea(this->tile, this->end_tile); - auto palette = (CanBuild( + auto palette = (cmd::BuildRoadStop( this->tile, - (uint32)(ta.w | ta.h << 8), - (this->is_truck ? 1 : 0) | (this->ddir >= DIAGDIR_END ? 2 : 0) | (((uint)this->ddir % 4) << 3) | (NEW_STATION << 16), - CMD_BUILD_ROAD_STOP - ) ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); + ta.w, + ta.h, + (this->is_truck ? ROADSTOP_TRUCK : ROADSTOP_BUS), + (this->ddir >= DIAGDIR_END), // is_drive_through + (DiagDirection)(this->ddir % 4), + this->roadtype, + NEW_STATION, + true + ).Test() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); for (TileIndex tile : ta) { this->AddTile(tile, ObjectTileHighlight::make_road_stop(palette, this->roadtype, this->ddir, this->is_truck)); } @@ -406,23 +396,23 @@ void ObjectHighlight::UpdateTiles() { } case Type::ROAD_DEPOT: { - auto palette = (CanBuild( + auto palette = (cmd::BuildRoadDepot( this->tile, - this->roadtype << 2 | this->ddir, - 0, - CMD_BUILD_ROAD_DEPOT - ) ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); + this->roadtype, + this->ddir + ).Test() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); this->AddTile(this->tile, ObjectTileHighlight::make_road_depot(palette, this->roadtype, this->ddir)); break; } case Type::AIRPORT: { - auto palette = (CanBuild( + auto palette = (cmd::BuildAirport( this->tile, - this->airport_type | ((uint)this->airport_layout << 8), - 1 | (NEW_STATION << 16), - CMD_BUILD_AIRPORT - ) ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); + this->airport_type, + this->airport_layout, + NEW_STATION, + true + ).Test() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP); const AirportSpec *as = AirportSpec::Get(this->airport_type); if (!as->IsAvailable() || this->airport_layout >= as->num_table) break; diff --git a/src/citymania/cm_highlight.hpp b/src/citymania/cm_highlight.hpp index 95cb05a731..209c67f107 100644 --- a/src/citymania/cm_highlight.hpp +++ b/src/citymania/cm_highlight.hpp @@ -72,9 +72,6 @@ DECLARE_ENUM_AS_BIT_SET(ZoningBorder); // SMALL = 3, // }; -bool CanBuild(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd); -bool CanBuild(const CommandContainer &cc); - TileHighlight GetTileHighlight(const TileInfo *ti, TileType tile_type); void DrawTileZoning(const TileInfo *ti, const TileHighlight &th, TileType tile_type); bool DrawTileSelection(const TileInfo *ti, const TileHighlightType &tht); diff --git a/src/citymania/cm_highlight_type.hpp b/src/citymania/cm_highlight_type.hpp index bd6e84b6bb..0d605e52fb 100644 --- a/src/citymania/cm_highlight_type.hpp +++ b/src/citymania/cm_highlight_type.hpp @@ -71,7 +71,7 @@ public: } signal; struct { DiagDirection ddir; - TileIndexWrapper other_end; + uint32 other_end; BridgeType type; } bridge_head; struct { diff --git a/src/citymania/cm_minimap.cpp b/src/citymania/cm_minimap.cpp index dbe3e5f1b2..30ca167089 100644 --- a/src/citymania/cm_minimap.cpp +++ b/src/citymania/cm_minimap.cpp @@ -226,7 +226,7 @@ void BuildLinkStatsLegend() for (; i < _smallmap_cargo_count + lengthof(_linkstat_colours_in_legenda); ++i) { _legend_linkstats[i].legend = STR_EMPTY; - _legend_linkstats[i].colour = LinkGraphOverlay::LINK_COLOURS[_linkstat_colours_in_legenda[i - _smallmap_cargo_count]]; + _legend_linkstats[i].colour = LinkGraphOverlay::LINK_COLOURS[_settings_client.gui.linkgraph_colours][_linkstat_colours_in_legenda[i - _smallmap_cargo_count]]; _legend_linkstats[i].show_on_map = true; } diff --git a/src/citymania/cm_misc_gui.cpp b/src/citymania/cm_misc_gui.cpp index 3c1cde2563..ec3dd45aff 100644 --- a/src/citymania/cm_misc_gui.cpp +++ b/src/citymania/cm_misc_gui.cpp @@ -2,6 +2,7 @@ #include "cm_misc_gui.hpp" +#include "../landscape_cmd.h" #include "../command_func.h" #include "../company_base.h" #include "../debug.h" @@ -189,7 +190,7 @@ public: Company *c = Company::GetIfValid(_local_company); if (c != nullptr) { assert(_current_company == _local_company); - CommandCost costclear = DoCommand(tile, 0, 0, DC_QUERY_COST, CMD_LANDSCAPE_CLEAR); + CommandCost costclear = ::Command::Do(DC_QUERY_COST, tile); if (costclear.Succeeded()) { Money cost = costclear.GetCost(); if (cost < 0) { diff --git a/src/citymania/cm_station_gui.cpp b/src/citymania/cm_station_gui.cpp index c765a7a165..fc1049a7b4 100644 --- a/src/citymania/cm_station_gui.cpp +++ b/src/citymania/cm_station_gui.cpp @@ -17,6 +17,7 @@ #include "../object_type.h" #include "../object_map.h" #include "../station_base.h" +#include "../station_cmd.h" #include "../strings_func.h" // GetString, SetDParam #include "../tilehighlight_type.h" #include "../town_map.h" @@ -42,7 +43,7 @@ extern ViewportSignKdtree _viewport_sign_kdtree; extern AirportClassID _selected_airport_class; extern int _selected_airport_index; extern byte _selected_airport_layout; - +extern void CcBuildAirport(Commands cmd, const CommandCost &result, TileIndex tile); extern RailType _cur_railtype; // rail_gui.cpp struct RailStationGUISettings { @@ -148,13 +149,14 @@ void OnStationTileSetChange(const Station *station, bool adding, StationType typ if (station == _viewport_highlight_station) MarkCoverageAreaDirty(_viewport_highlight_station); } -CommandContainer _last_station_bulid_cmd; +// CommandContainer _last_station_bulid_cmd; void OnStationPartBuilt(const Station *station, TileIndex tile, uint32 p1, uint32 p2) { if (_current_company != _local_company) return; - if (tile != _last_station_bulid_cmd.tile || - p1 != _last_station_bulid_cmd.p1 || - p2 != _last_station_bulid_cmd.p2) return; + // FIXME + // if (tile != _last_station_bulid_cmd.tile || + // p1 != _last_station_bulid_cmd.p1 || + // p2 != _last_station_bulid_cmd.p2) return; _station_to_join = station; CheckRedrawStationCoverage(); } @@ -212,7 +214,7 @@ void JoinAndBuild(JoinAndBuildCmdProc proc) { if (citymania::_fn_mod) to_join = NEW_STATION; else if (join_to) to_join = join_to->index; - FIXME _last_station_bulid_cmd = cmdcont; + //FIXME _last_station_bulid_cmd = cmdcont; proc(false, to_join, adjacent); } @@ -354,8 +356,9 @@ void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, uint32 p2, uint32 c } p2 |= ddir << 3; // Set the DiagDirecion into p2 bits 3 and 4. - CommandContainer cmdcont = { ta.tile, (uint32)(ta.w | ta.h << 8), p2, cmd, CcRoadStop, "" }; - JoinAndBuild(cmdcont); + // FIXME + // CommandContainer cmdcont = { ta.tile, (uint32)(ta.w | ta.h << 8), p2, cmd, CcRoadStop, "" }; + // JoinAndBuild(cmdcont); } void HandleStationPlacement(TileIndex start, TileIndex end) @@ -371,8 +374,9 @@ void HandleStationPlacement(TileIndex start, TileIndex end) uint32 p1 = _cur_railtype | _railstation.orientation << 6 | numtracks << 8 | platlength << 16 | (citymania::_fn_mod ? 1 << 24 : 0); uint32 p2 = _railstation.station_class | _railstation.station_type << 8 | INVALID_STATION << 16; - CommandContainer cmdcont = { ta.tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" }; - JoinAndBuild(cmdcont); + // FIXME + // CommandContainer cmdcont = { ta.tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" }; + // JoinAndBuild(cmdcont); } void PlaceRail_Station(TileIndex tile) { @@ -385,8 +389,9 @@ void PlaceRail_Station(TileIndex tile) { int h = _settings_client.gui.station_platlength; if (!_railstation.orientation) Swap(w, h); - CommandContainer cmdcont = { tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" }; - JoinAndBuild(cmdcont); + // FIXME + // CommandContainer cmdcont = { tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" }; + // JoinAndBuild(cmdcont); } void PlaceDock(TileIndex tile) { @@ -395,17 +400,18 @@ void PlaceDock(TileIndex tile) { uint32 p2 = (uint32)INVALID_STATION << 16; // no station to join /* tile is always the land tile, so need to evaluate _thd.pos */ - CommandContainer cmdcont = { tile, citymania::_fn_mod, p2, CMD_BUILD_DOCK | CMD_MSG(STR_ERROR_CAN_T_BUILD_DOCK_HERE), CcBuildDocks, "" }; + // CommandContainer cmdcont = { tile, citymania::_fn_mod, p2, CMD_BUILD_DOCK | CMD_MSG(STR_ERROR_CAN_T_BUILD_DOCK_HERE), CcBuildDocks, "" }; /* Determine the watery part of the dock. */ // DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile)); // TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile); - JoinAndBuild(cmdcont); + // FIXME + // JoinAndBuild(cmdcont); } void PlaceAirport(TileIndex tile) { - FIXME + // FIXME if (CheckStationJoin(tile, tile)) return; if (_selected_airport_index == -1) return; @@ -421,7 +427,7 @@ void PlaceAirport(TileIndex tile) { } }; - JoinAndBuild(cmdcont); + // FIXME JoinAndBuild(cmdcont); } static void FindStationsAroundSelection(const TileArea &location) @@ -605,7 +611,7 @@ CargoArray GetProductionAroundTiles(TileIndex tile, int w, int h, int rad) } std::string GetStationCoverageProductionText(TileIndex tile, int w, int h, int rad, StationCoverageType sct) { - auto production = GetProductionAroundTiles(tile, w, h, rad); + auto production = citymania::GetProductionAroundTiles(tile, w, h, rad); std::ostringstream s; char buffer[DRAW_STRING_BUFFER]; diff --git a/src/citymania/generated/cm_gen_commands.cpp b/src/citymania/generated/cm_gen_commands.cpp index 7b09faf0ca..de5b43d69e 100644 --- a/src/citymania/generated/cm_gen_commands.cpp +++ b/src/citymania/generated/cm_gen_commands.cpp @@ -5,105 +5,356 @@ #include "../../src/misc_cmd.h" #include "../../src/object_cmd.h" #include "../../src/order_cmd.h" +#include "../../src/rail_cmd.h" +#include "../../src/road_cmd.h" +#include "../../src/station_cmd.h" #include "../../src/town_cmd.h" +#include "../../src/tunnelbridge_cmd.h" namespace citymania { namespace cmd { bool MoneyCheat::DoPost() { return ::Command::Post(this->error, this->tile, this->amount); } +bool MoneyCheat::DoTest() { + return (::Command::Do(DC_NONE, this->amount)).Succeeded(); +} bool ChangeBankBalance::DoPost() { return ::Command::Post(this->error, this->tile, this->delta, this->company, this->expenses_type); } +bool ChangeBankBalance::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->delta, this->company, this->expenses_type)).Succeeded(); +} bool IncreaseLoan::DoPost() { return ::Command::Post(this->error, this->tile, this->cmd, this->amount); } +bool IncreaseLoan::DoTest() { + return (::Command::Do(DC_NONE, this->cmd, this->amount)).Succeeded(); +} bool DecreaseLoan::DoPost() { return ::Command::Post(this->error, this->tile, this->cmd, this->amount); } +bool DecreaseLoan::DoTest() { + return (::Command::Do(DC_NONE, this->cmd, this->amount)).Succeeded(); +} bool Pause::DoPost() { return ::Command::Post(this->error, this->tile, this->mode, this->pause); } +bool Pause::DoTest() { + return (::Command::Do(DC_NONE, this->mode, this->pause)).Succeeded(); +} bool BuildObject::DoPost() { return ::Command::Post(this->error, this->tile, this->type, this->view); } +bool BuildObject::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->type, this->view)).Succeeded(); +} bool BuildObjectArea::DoPost() { return ::Command::Post(this->error, this->tile, this->start_tile, this->type, this->view, this->diagonal); } +bool BuildObjectArea::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->start_tile, this->type, this->view, this->diagonal)).Succeeded(); +} bool ModifyOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->veh, this->sel_ord, this->mof, this->data); } +bool ModifyOrder::DoTest() { + return (::Command::Do(DC_NONE, this->veh, this->sel_ord, this->mof, this->data)).Succeeded(); +} bool SkipToOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->veh_id, this->sel_ord); } +bool SkipToOrder::DoTest() { + return (::Command::Do(DC_NONE, this->veh_id, this->sel_ord)).Succeeded(); +} bool DeleteOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->veh_id, this->sel_ord); } +bool DeleteOrder::DoTest() { + return (::Command::Do(DC_NONE, this->veh_id, this->sel_ord)).Succeeded(); +} bool InsertOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->veh, this->sel_ord, this->new_order); } +bool InsertOrder::DoTest() { + return (::Command::Do(DC_NONE, this->veh, this->sel_ord, this->new_order)).Succeeded(); +} bool OrderRefit::DoPost() { return ::Command::Post(this->error, this->tile, this->veh, this->order_number, this->cargo); } +bool OrderRefit::DoTest() { + return (::Command::Do(DC_NONE, this->veh, this->order_number, this->cargo)).Succeeded(); +} bool CloneOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->action, this->veh_dst, this->veh_src); } +bool CloneOrder::DoTest() { + return (::Command::Do(DC_NONE, this->action, this->veh_dst, this->veh_src)).Succeeded(); +} bool MoveOrder::DoPost() { return ::Command::Post(this->error, this->tile, this->veh, this->moving_order, this->target_order); } +bool MoveOrder::DoTest() { + return (::Command::Do(DC_NONE, this->veh, this->moving_order, this->target_order)).Succeeded(); +} bool ClearOrderBackup::DoPost() { return ::Command::Post(this->error, this->tile, this->user_id); } +bool ClearOrderBackup::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->user_id)).Succeeded(); +} + +bool BuildRailroadTrack::DoPost() { + return ::Command::Post(this->error, this->tile, this->start_tile, this->railtype, this->track, this->auto_remove_signals, this->fail_on_obstacle); +} +bool BuildRailroadTrack::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->start_tile, this->railtype, this->track, this->auto_remove_signals, this->fail_on_obstacle)).Succeeded(); +} + +bool RemoveRailroadTrack::DoPost() { + return ::Command::Post(this->error, this->tile, this->start_tile, this->track); +} +bool RemoveRailroadTrack::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->start_tile, this->track)).Succeeded(); +} + +bool BuildSingleRail::DoPost() { + return ::Command::Post(this->error, this->tile, this->railtype, this->track, this->auto_remove_signals); +} +bool BuildSingleRail::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->railtype, this->track, this->auto_remove_signals)).Succeeded(); +} + +bool RemoveSingleRail::DoPost() { + return ::Command::Post(this->error, this->tile, this->track); +} +bool RemoveSingleRail::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->track)).Succeeded(); +} + +bool BuildTrainDepot::DoPost() { + return ::Command::Post(this->error, this->tile, this->railtype, this->dir); +} +bool BuildTrainDepot::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->railtype, this->dir)).Succeeded(); +} + +bool BuildSingleSignal::DoPost() { + return ::Command::Post(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::DoTest() { + return (::Command::Do(DC_NONE, 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)).Succeeded(); +} + +bool RemoveSingleSignal::DoPost() { + return ::Command::Post(this->error, this->tile, this->track); +} +bool RemoveSingleSignal::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->track)).Succeeded(); +} + +bool ConvertRail::DoPost() { + return ::Command::Post(this->error, this->tile, this->area_start, this->totype, this->diagonal); +} +bool ConvertRail::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->area_start, this->totype, this->diagonal)).Succeeded(); +} + +bool BuildSignalTrack::DoPost() { + return ::Command::Post(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::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->end_tile, this->track, this->sigtype, this->sigvar, this->mode, this->autofill, this->minimise_gaps, this->signal_density)).Succeeded(); +} + +bool RemoveSignalTrack::DoPost() { + return ::Command::Post(this->error, this->tile, this->end_tile, this->track, this->autofill); +} +bool RemoveSignalTrack::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->end_tile, this->track, this->autofill)).Succeeded(); +} + +bool BuildLongRoad::DoPost() { + return ::Command::Post(this->error, this->tile, this->start_tile, this->rt, this->axis, this->drd, this->start_half, this->end_half, this->is_ai); +} +bool BuildLongRoad::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->start_tile, this->rt, this->axis, this->drd, this->start_half, this->end_half, this->is_ai)).Succeeded(); +} + +bool RemoveLongRoad::DoPost() { + return ::Command::Post(this->error, this->tile, this->start_tile, this->rt, this->axis, this->start_half, this->end_half); +} +bool RemoveLongRoad::DoTest() { + return std::get<0>(::Command::Do(DC_NONE, this->tile, this->start_tile, this->rt, this->axis, this->start_half, this->end_half)).Succeeded(); +} + +bool BuildRoad::DoPost() { + return ::Command::Post(this->error, this->tile, this->pieces, this->rt, this->toggle_drd, this->town_id); +} +bool BuildRoad::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->pieces, this->rt, this->toggle_drd, this->town_id)).Succeeded(); +} + +bool BuildRoadDepot::DoPost() { + return ::Command::Post(this->error, this->tile, this->rt, this->dir); +} +bool BuildRoadDepot::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->rt, this->dir)).Succeeded(); +} + +bool ConvertRoad::DoPost() { + return ::Command::Post(this->error, this->tile, this->area_start, this->to_type); +} +bool ConvertRoad::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->area_start, this->to_type)).Succeeded(); +} + +bool BuildAirport::DoPost() { + return ::Command::Post(this->error, this->tile, this->airport_type, this->layout, this->station_to_join, this->allow_adjacent); +} +bool BuildAirport::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->airport_type, this->layout, this->station_to_join, this->allow_adjacent)).Succeeded(); +} + +bool BuildDock::DoPost() { + return ::Command::Post(this->error, this->tile, this->station_to_join, this->adjacent); +} +bool BuildDock::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->station_to_join, this->adjacent)).Succeeded(); +} + +bool BuildRailStation::DoPost() { + return ::Command::Post(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::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->rt, this->axis, this->numtracks, this->plat_len, this->spec_class, this->spec_index, this->station_to_join, this->adjacent)).Succeeded(); +} + +bool RemoveFromRailStation::DoPost() { + return ::Command::Post(this->error, this->tile, this->end, this->keep_rail); +} +bool RemoveFromRailStation::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->end, this->keep_rail)).Succeeded(); +} + +bool BuildRoadStop::DoPost() { + return ::Command::Post(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::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->width, this->length, this->stop_type, this->is_drive_through, this->ddir, this->rt, this->station_to_join, this->adjacent)).Succeeded(); +} + +bool RemoveRoadStop::DoPost() { + return ::Command::Post(this->error, this->tile, this->width, this->height, this->stop_type, this->remove_road); +} +bool RemoveRoadStop::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->width, this->height, this->stop_type, this->remove_road)).Succeeded(); +} + +bool RenameStation::DoPost() { + return ::Command::Post(this->error, this->tile, this->station_id, this->text); +} +bool RenameStation::DoTest() { + return (::Command::Do(DC_NONE, this->station_id, this->text)).Succeeded(); +} + +bool OpenCloseAirport::DoPost() { + return ::Command::Post(this->error, this->tile, this->station_id); +} +bool OpenCloseAirport::DoTest() { + return (::Command::Do(DC_NONE, this->station_id)).Succeeded(); +} bool FoundTown::DoPost() { return ::Command::Post(this->error, this->tile, this->size, this->city, this->layout, this->random_location, this->townnameparts, this->text); } +bool FoundTown::DoTest() { + return std::get<0>(::Command::Do(DC_NONE, this->tile, this->size, this->city, this->layout, this->random_location, this->townnameparts, this->text)).Succeeded(); +} bool RenameTown::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->text); } +bool RenameTown::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->text)).Succeeded(); +} bool DoTownAction::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->action); } +bool DoTownAction::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->action)).Succeeded(); +} bool TownGrowthRate::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->growth_rate); } +bool TownGrowthRate::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->growth_rate)).Succeeded(); +} bool TownRating::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->company_id, this->rating); } +bool TownRating::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->company_id, this->rating)).Succeeded(); +} bool TownCargoGoal::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->te, this->goal); } +bool TownCargoGoal::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->te, this->goal)).Succeeded(); +} bool TownSetText::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->text); } +bool TownSetText::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->text)).Succeeded(); +} bool ExpandTown::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id, this->grow_amount); } +bool ExpandTown::DoTest() { + return (::Command::Do(DC_NONE, this->town_id, this->grow_amount)).Succeeded(); +} bool DeleteTown::DoPost() { return ::Command::Post(this->error, this->tile, this->town_id); } +bool DeleteTown::DoTest() { + return (::Command::Do(DC_NONE, this->town_id)).Succeeded(); +} + +bool BuildBridge::DoPost() { + return ::Command::Post(this->error, this->tile, this->tile_start, this->transport_type, this->bridge_type, this->road_rail_type); +} +bool BuildBridge::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->tile_start, this->transport_type, this->bridge_type, this->road_rail_type)).Succeeded(); +} + +bool BuildTunnel::DoPost() { + return ::Command::Post(this->error, this->tile, this->transport_type, this->road_rail_type); +} +bool BuildTunnel::DoTest() { + return (::Command::Do(DC_NONE, this->tile, this->transport_type, this->road_rail_type)).Succeeded(); +} } // namespace cmd } // namespace citymania diff --git a/src/citymania/generated/cm_gen_commands.hpp b/src/citymania/generated/cm_gen_commands.hpp index d28fb6f917..1c60213d8a 100644 --- a/src/citymania/generated/cm_gen_commands.hpp +++ b/src/citymania/generated/cm_gen_commands.hpp @@ -10,11 +10,12 @@ class MoneyCheat: public Command { public: Money amount; - MoneyCheat(Money amount) + MoneyCheat(Money amount) :amount{amount} {} ~MoneyCheat() override {} bool DoPost() override; + bool DoTest() override; }; class ChangeBankBalance: public Command { @@ -23,11 +24,14 @@ public: CompanyID company; ExpensesType expenses_type; - ChangeBankBalance(Money delta, CompanyID company, ExpensesType expenses_type) + ChangeBankBalance(Money delta, CompanyID company, ExpensesType expenses_type) :delta{delta}, company{company}, expenses_type{expenses_type} {} + ChangeBankBalance(TileIndex tile, Money delta, CompanyID company, ExpensesType expenses_type) + :Command{tile}, delta{delta}, company{company}, expenses_type{expenses_type} {} ~ChangeBankBalance() override {} bool DoPost() override; + bool DoTest() override; }; class IncreaseLoan: public Command { @@ -35,11 +39,12 @@ public: LoanCommand cmd; Money amount; - IncreaseLoan(LoanCommand cmd, Money amount) + IncreaseLoan(LoanCommand cmd, Money amount) :cmd{cmd}, amount{amount} {} ~IncreaseLoan() override {} bool DoPost() override; + bool DoTest() override; }; class DecreaseLoan: public Command { @@ -47,11 +52,12 @@ public: LoanCommand cmd; Money amount; - DecreaseLoan(LoanCommand cmd, Money amount) + DecreaseLoan(LoanCommand cmd, Money amount) :cmd{cmd}, amount{amount} {} ~DecreaseLoan() override {} bool DoPost() override; + bool DoTest() override; }; class Pause: public Command { @@ -59,11 +65,12 @@ public: PauseMode mode; bool pause; - Pause(PauseMode mode, bool pause) + Pause(PauseMode mode, bool pause) :mode{mode}, pause{pause} {} ~Pause() override {} bool DoPost() override; + bool DoTest() override; }; class BuildObject: public Command { @@ -71,11 +78,14 @@ public: ObjectType type; uint8 view; - BuildObject(ObjectType type, uint8 view) + BuildObject(ObjectType type, uint8 view) :type{type}, view{view} {} + BuildObject(TileIndex tile, ObjectType type, uint8 view) + :Command{tile}, type{type}, view{view} {} ~BuildObject() override {} bool DoPost() override; + bool DoTest() override; }; class BuildObjectArea: public Command { @@ -85,11 +95,14 @@ public: uint8 view; bool diagonal; - BuildObjectArea(TileIndex start_tile, ObjectType type, uint8 view, bool diagonal) + BuildObjectArea(TileIndex start_tile, ObjectType type, uint8 view, bool diagonal) :start_tile{start_tile}, type{type}, view{view}, diagonal{diagonal} {} + BuildObjectArea(TileIndex tile, TileIndex start_tile, ObjectType type, uint8 view, bool diagonal) + :Command{tile}, start_tile{start_tile}, type{type}, view{view}, diagonal{diagonal} {} ~BuildObjectArea() override {} bool DoPost() override; + bool DoTest() override; }; class ModifyOrder: public Command { @@ -99,11 +112,12 @@ public: ModifyOrderFlags mof; uint16 data; - ModifyOrder(VehicleID veh, VehicleOrderID sel_ord, ModifyOrderFlags mof, uint16 data) + ModifyOrder(VehicleID veh, VehicleOrderID sel_ord, ModifyOrderFlags mof, uint16 data) :veh{veh}, sel_ord{sel_ord}, mof{mof}, data{data} {} ~ModifyOrder() override {} bool DoPost() override; + bool DoTest() override; }; class SkipToOrder: public Command { @@ -111,11 +125,12 @@ public: VehicleID veh_id; VehicleOrderID sel_ord; - SkipToOrder(VehicleID veh_id, VehicleOrderID sel_ord) + SkipToOrder(VehicleID veh_id, VehicleOrderID sel_ord) :veh_id{veh_id}, sel_ord{sel_ord} {} ~SkipToOrder() override {} bool DoPost() override; + bool DoTest() override; }; class DeleteOrder: public Command { @@ -123,11 +138,12 @@ public: VehicleID veh_id; VehicleOrderID sel_ord; - DeleteOrder(VehicleID veh_id, VehicleOrderID sel_ord) + DeleteOrder(VehicleID veh_id, VehicleOrderID sel_ord) :veh_id{veh_id}, sel_ord{sel_ord} {} ~DeleteOrder() override {} bool DoPost() override; + bool DoTest() override; }; class InsertOrder: public Command { @@ -136,11 +152,12 @@ public: VehicleOrderID sel_ord; const Order &new_order; - InsertOrder(VehicleID veh, VehicleOrderID sel_ord, const Order & new_order) + InsertOrder(VehicleID veh, VehicleOrderID sel_ord, const Order &new_order) :veh{veh}, sel_ord{sel_ord}, new_order{new_order} {} ~InsertOrder() override {} bool DoPost() override; + bool DoTest() override; }; class OrderRefit: public Command { @@ -149,11 +166,12 @@ public: VehicleOrderID order_number; CargoID cargo; - OrderRefit(VehicleID veh, VehicleOrderID order_number, CargoID cargo) + OrderRefit(VehicleID veh, VehicleOrderID order_number, CargoID cargo) :veh{veh}, order_number{order_number}, cargo{cargo} {} ~OrderRefit() override {} bool DoPost() override; + bool DoTest() override; }; class CloneOrder: public Command { @@ -162,11 +180,12 @@ public: VehicleID veh_dst; VehicleID veh_src; - CloneOrder(CloneOptions action, VehicleID veh_dst, VehicleID veh_src) + CloneOrder(CloneOptions action, VehicleID veh_dst, VehicleID veh_src) :action{action}, veh_dst{veh_dst}, veh_src{veh_src} {} ~CloneOrder() override {} bool DoPost() override; + bool DoTest() override; }; class MoveOrder: public Command { @@ -175,22 +194,410 @@ public: VehicleOrderID moving_order; VehicleOrderID target_order; - MoveOrder(VehicleID veh, VehicleOrderID moving_order, VehicleOrderID target_order) + MoveOrder(VehicleID veh, VehicleOrderID moving_order, VehicleOrderID target_order) :veh{veh}, moving_order{moving_order}, target_order{target_order} {} ~MoveOrder() override {} bool DoPost() override; + bool DoTest() override; }; class ClearOrderBackup: public Command { public: ClientID user_id; - ClearOrderBackup(ClientID user_id) + ClearOrderBackup(ClientID user_id) :user_id{user_id} {} + ClearOrderBackup(TileIndex tile, ClientID user_id) + :Command{tile}, user_id{user_id} {} ~ClearOrderBackup() override {} bool DoPost() override; + bool DoTest() override; +}; + +class BuildRailroadTrack: public Command { +public: + TileIndex start_tile; + RailType railtype; + Track track; + bool auto_remove_signals; + bool fail_on_obstacle; + + BuildRailroadTrack(TileIndex start_tile, RailType railtype, Track track, bool auto_remove_signals, bool fail_on_obstacle) + :start_tile{start_tile}, railtype{railtype}, track{track}, auto_remove_signals{auto_remove_signals}, fail_on_obstacle{fail_on_obstacle} {} + BuildRailroadTrack(TileIndex tile, TileIndex start_tile, RailType railtype, Track track, bool auto_remove_signals, bool fail_on_obstacle) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveRailroadTrack: public Command { +public: + TileIndex start_tile; + Track track; + + RemoveRailroadTrack(TileIndex start_tile, Track track) + :start_tile{start_tile}, track{track} {} + RemoveRailroadTrack(TileIndex tile, TileIndex start_tile, Track track) + :Command{tile}, start_tile{start_tile}, track{track} {} + ~RemoveRailroadTrack() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildSingleRail: public Command { +public: + RailType railtype; + Track track; + bool auto_remove_signals; + + BuildSingleRail(RailType railtype, Track track, bool auto_remove_signals) + :railtype{railtype}, track{track}, auto_remove_signals{auto_remove_signals} {} + BuildSingleRail(TileIndex tile, RailType railtype, Track track, bool auto_remove_signals) + :Command{tile}, railtype{railtype}, track{track}, auto_remove_signals{auto_remove_signals} {} + ~BuildSingleRail() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class RemoveSingleRail: public Command { +public: + Track track; + + RemoveSingleRail(Track track) + :track{track} {} + RemoveSingleRail(TileIndex tile, Track track) + :Command{tile}, track{track} {} + ~RemoveSingleRail() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildTrainDepot: public Command { +public: + RailType railtype; + DiagDirection dir; + + BuildTrainDepot(RailType railtype, DiagDirection dir) + :railtype{railtype}, dir{dir} {} + BuildTrainDepot(TileIndex tile, RailType railtype, DiagDirection dir) + :Command{tile}, railtype{railtype}, dir{dir} {} + ~BuildTrainDepot() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildSingleSignal: public Command { +public: + Track track; + SignalType sigtype; + SignalVariant sigvar; + bool convert_signal; + bool skip_existing_signals; + bool ctrl_pressed; + SignalType cycle_start; + SignalType cycle_stop; + uint8 num_dir_cycle; + byte signals_copy; + + BuildSingleSignal(Track track, SignalType sigtype, SignalVariant sigvar, bool convert_signal, bool skip_existing_signals, bool ctrl_pressed, SignalType cycle_start, SignalType cycle_stop, uint8 num_dir_cycle, byte signals_copy) + :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(TileIndex tile, Track track, SignalType sigtype, SignalVariant sigvar, bool convert_signal, bool skip_existing_signals, bool ctrl_pressed, SignalType cycle_start, SignalType cycle_stop, uint8 num_dir_cycle, byte signals_copy) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveSingleSignal: public Command { +public: + Track track; + + RemoveSingleSignal(Track track) + :track{track} {} + RemoveSingleSignal(TileIndex tile, Track track) + :Command{tile}, track{track} {} + ~RemoveSingleSignal() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class ConvertRail: public Command { +public: + TileIndex area_start; + RailType totype; + bool diagonal; + + ConvertRail(TileIndex area_start, RailType totype, bool diagonal) + :area_start{area_start}, totype{totype}, diagonal{diagonal} {} + ConvertRail(TileIndex tile, TileIndex area_start, RailType totype, bool diagonal) + :Command{tile}, area_start{area_start}, totype{totype}, diagonal{diagonal} {} + ~ConvertRail() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildSignalTrack: public Command { +public: + TileIndex end_tile; + Track track; + SignalType sigtype; + SignalVariant sigvar; + bool mode; + bool autofill; + bool minimise_gaps; + byte signal_density; + + BuildSignalTrack(TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, byte signal_density) + :end_tile{end_tile}, track{track}, sigtype{sigtype}, sigvar{sigvar}, mode{mode}, autofill{autofill}, minimise_gaps{minimise_gaps}, signal_density{signal_density} {} + BuildSignalTrack(TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, byte signal_density) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveSignalTrack: public Command { +public: + TileIndex end_tile; + Track track; + bool autofill; + + RemoveSignalTrack(TileIndex end_tile, Track track, bool autofill) + :end_tile{end_tile}, track{track}, autofill{autofill} {} + RemoveSignalTrack(TileIndex tile, TileIndex end_tile, Track track, bool autofill) + :Command{tile}, end_tile{end_tile}, track{track}, autofill{autofill} {} + ~RemoveSignalTrack() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildLongRoad: public Command { +public: + TileIndex start_tile; + RoadType rt; + Axis axis; + DisallowedRoadDirections drd; + bool start_half; + bool end_half; + bool is_ai; + + BuildLongRoad(TileIndex start_tile, RoadType rt, Axis axis, DisallowedRoadDirections drd, bool start_half, bool end_half, bool is_ai) + :start_tile{start_tile}, rt{rt}, axis{axis}, drd{drd}, start_half{start_half}, end_half{end_half}, is_ai{is_ai} {} + BuildLongRoad(TileIndex tile, TileIndex start_tile, RoadType rt, Axis axis, DisallowedRoadDirections drd, bool start_half, bool end_half, bool is_ai) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveLongRoad: public Command { +public: + TileIndex start_tile; + RoadType rt; + Axis axis; + bool start_half; + bool end_half; + + RemoveLongRoad(TileIndex start_tile, RoadType rt, Axis axis, bool start_half, bool end_half) + :start_tile{start_tile}, rt{rt}, axis{axis}, start_half{start_half}, end_half{end_half} {} + RemoveLongRoad(TileIndex tile, TileIndex start_tile, RoadType rt, Axis axis, bool start_half, bool end_half) + :Command{tile}, start_tile{start_tile}, rt{rt}, axis{axis}, start_half{start_half}, end_half{end_half} {} + ~RemoveLongRoad() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildRoad: public Command { +public: + RoadBits pieces; + RoadType rt; + DisallowedRoadDirections toggle_drd; + TownID town_id; + + BuildRoad(RoadBits pieces, RoadType rt, DisallowedRoadDirections toggle_drd, TownID town_id) + :pieces{pieces}, rt{rt}, toggle_drd{toggle_drd}, town_id{town_id} {} + BuildRoad(TileIndex tile, RoadBits pieces, RoadType rt, DisallowedRoadDirections toggle_drd, TownID town_id) + :Command{tile}, pieces{pieces}, rt{rt}, toggle_drd{toggle_drd}, town_id{town_id} {} + ~BuildRoad() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildRoadDepot: public Command { +public: + RoadType rt; + DiagDirection dir; + + BuildRoadDepot(RoadType rt, DiagDirection dir) + :rt{rt}, dir{dir} {} + BuildRoadDepot(TileIndex tile, RoadType rt, DiagDirection dir) + :Command{tile}, rt{rt}, dir{dir} {} + ~BuildRoadDepot() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class ConvertRoad: public Command { +public: + TileIndex area_start; + RoadType to_type; + + ConvertRoad(TileIndex area_start, RoadType to_type) + :area_start{area_start}, to_type{to_type} {} + ConvertRoad(TileIndex tile, TileIndex area_start, RoadType to_type) + :Command{tile}, area_start{area_start}, to_type{to_type} {} + ~ConvertRoad() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildAirport: public Command { +public: + byte airport_type; + byte layout; + StationID station_to_join; + bool allow_adjacent; + + BuildAirport(byte airport_type, byte layout, StationID station_to_join, bool allow_adjacent) + :airport_type{airport_type}, layout{layout}, station_to_join{station_to_join}, allow_adjacent{allow_adjacent} {} + BuildAirport(TileIndex tile, byte airport_type, byte layout, StationID station_to_join, bool allow_adjacent) + :Command{tile}, airport_type{airport_type}, layout{layout}, station_to_join{station_to_join}, allow_adjacent{allow_adjacent} {} + ~BuildAirport() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildDock: public Command { +public: + StationID station_to_join; + bool adjacent; + + BuildDock(StationID station_to_join, bool adjacent) + :station_to_join{station_to_join}, adjacent{adjacent} {} + BuildDock(TileIndex tile, StationID station_to_join, bool adjacent) + :Command{tile}, station_to_join{station_to_join}, adjacent{adjacent} {} + ~BuildDock() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildRailStation: public Command { +public: + RailType rt; + Axis axis; + byte numtracks; + byte plat_len; + StationClassID spec_class; + byte spec_index; + StationID station_to_join; + bool adjacent; + + BuildRailStation(RailType rt, Axis axis, byte numtracks, byte plat_len, StationClassID spec_class, byte spec_index, StationID station_to_join, bool adjacent) + :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(TileIndex tile, RailType rt, Axis axis, byte numtracks, byte plat_len, StationClassID spec_class, byte spec_index, StationID station_to_join, bool adjacent) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveFromRailStation: public Command { +public: + TileIndex end; + bool keep_rail; + + RemoveFromRailStation(TileIndex end, bool keep_rail) + :end{end}, keep_rail{keep_rail} {} + RemoveFromRailStation(TileIndex tile, TileIndex end, bool keep_rail) + :Command{tile}, end{end}, keep_rail{keep_rail} {} + ~RemoveFromRailStation() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildRoadStop: public Command { +public: + uint8 width; + uint8 length; + RoadStopType stop_type; + bool is_drive_through; + DiagDirection ddir; + RoadType rt; + StationID station_to_join; + bool adjacent; + + BuildRoadStop(uint8 width, uint8 length, RoadStopType stop_type, bool is_drive_through, DiagDirection ddir, RoadType rt, StationID station_to_join, bool adjacent) + :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(TileIndex tile, uint8 width, uint8 length, RoadStopType stop_type, bool is_drive_through, DiagDirection ddir, RoadType rt, StationID station_to_join, bool adjacent) + :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 DoPost() override; + bool DoTest() override; +}; + +class RemoveRoadStop: public Command { +public: + uint8 width; + uint8 height; + RoadStopType stop_type; + bool remove_road; + + RemoveRoadStop(uint8 width, uint8 height, RoadStopType stop_type, bool remove_road) + :width{width}, height{height}, stop_type{stop_type}, remove_road{remove_road} {} + RemoveRoadStop(TileIndex tile, uint8 width, uint8 height, RoadStopType stop_type, bool remove_road) + :Command{tile}, width{width}, height{height}, stop_type{stop_type}, remove_road{remove_road} {} + ~RemoveRoadStop() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class RenameStation: public Command { +public: + StationID station_id; + const std::string &text; + + RenameStation(StationID station_id, const std::string &text) + :station_id{station_id}, text{text} {} + ~RenameStation() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class OpenCloseAirport: public Command { +public: + StationID station_id; + + OpenCloseAirport(StationID station_id) + :station_id{station_id} {} + ~OpenCloseAirport() override {} + + bool DoPost() override; + bool DoTest() override; }; class FoundTown: public Command { @@ -202,11 +609,14 @@ public: uint32 townnameparts; const std::string &text; - FoundTown(TownSize size, bool city, TownLayout layout, bool random_location, uint32 townnameparts, const std::string & text) + FoundTown(TownSize size, bool city, TownLayout layout, bool random_location, uint32 townnameparts, const std::string &text) :size{size}, city{city}, layout{layout}, random_location{random_location}, townnameparts{townnameparts}, text{text} {} + FoundTown(TileIndex tile, TownSize size, bool city, TownLayout layout, bool random_location, uint32 townnameparts, const std::string &text) + :Command{tile}, size{size}, city{city}, layout{layout}, random_location{random_location}, townnameparts{townnameparts}, text{text} {} ~FoundTown() override {} bool DoPost() override; + bool DoTest() override; }; class RenameTown: public Command { @@ -214,11 +624,12 @@ public: TownID town_id; const std::string &text; - RenameTown(TownID town_id, const std::string & text) + RenameTown(TownID town_id, const std::string &text) :town_id{town_id}, text{text} {} ~RenameTown() override {} bool DoPost() override; + bool DoTest() override; }; class DoTownAction: public Command { @@ -226,11 +637,12 @@ public: TownID town_id; uint8 action; - DoTownAction(TownID town_id, uint8 action) + DoTownAction(TownID town_id, uint8 action) :town_id{town_id}, action{action} {} ~DoTownAction() override {} bool DoPost() override; + bool DoTest() override; }; class TownGrowthRate: public Command { @@ -238,11 +650,12 @@ public: TownID town_id; uint16 growth_rate; - TownGrowthRate(TownID town_id, uint16 growth_rate) + TownGrowthRate(TownID town_id, uint16 growth_rate) :town_id{town_id}, growth_rate{growth_rate} {} ~TownGrowthRate() override {} bool DoPost() override; + bool DoTest() override; }; class TownRating: public Command { @@ -251,11 +664,12 @@ public: CompanyID company_id; int16 rating; - TownRating(TownID town_id, CompanyID company_id, int16 rating) + TownRating(TownID town_id, CompanyID company_id, int16 rating) :town_id{town_id}, company_id{company_id}, rating{rating} {} ~TownRating() override {} bool DoPost() override; + bool DoTest() override; }; class TownCargoGoal: public Command { @@ -264,11 +678,12 @@ public: TownEffect te; uint32 goal; - TownCargoGoal(TownID town_id, TownEffect te, uint32 goal) + TownCargoGoal(TownID town_id, TownEffect te, uint32 goal) :town_id{town_id}, te{te}, goal{goal} {} ~TownCargoGoal() override {} bool DoPost() override; + bool DoTest() override; }; class TownSetText: public Command { @@ -276,11 +691,12 @@ public: TownID town_id; const std::string &text; - TownSetText(TownID town_id, const std::string & text) + TownSetText(TownID town_id, const std::string &text) :town_id{town_id}, text{text} {} ~TownSetText() override {} bool DoPost() override; + bool DoTest() override; }; class ExpandTown: public Command { @@ -288,22 +704,56 @@ public: TownID town_id; uint32 grow_amount; - ExpandTown(TownID town_id, uint32 grow_amount) + ExpandTown(TownID town_id, uint32 grow_amount) :town_id{town_id}, grow_amount{grow_amount} {} ~ExpandTown() override {} bool DoPost() override; + bool DoTest() override; }; class DeleteTown: public Command { public: TownID town_id; - DeleteTown(TownID town_id) + DeleteTown(TownID town_id) :town_id{town_id} {} ~DeleteTown() override {} bool DoPost() override; + bool DoTest() override; +}; + +class BuildBridge: public Command { +public: + TileIndex tile_start; + TransportType transport_type; + BridgeType bridge_type; + byte road_rail_type; + + BuildBridge(TileIndex tile_start, TransportType transport_type, BridgeType bridge_type, byte road_rail_type) + :tile_start{tile_start}, transport_type{transport_type}, bridge_type{bridge_type}, road_rail_type{road_rail_type} {} + BuildBridge(TileIndex tile, TileIndex tile_start, TransportType transport_type, BridgeType bridge_type, byte road_rail_type) + :Command{tile}, tile_start{tile_start}, transport_type{transport_type}, bridge_type{bridge_type}, road_rail_type{road_rail_type} {} + ~BuildBridge() override {} + + bool DoPost() override; + bool DoTest() override; +}; + +class BuildTunnel: public Command { +public: + TransportType transport_type; + byte road_rail_type; + + BuildTunnel(TransportType transport_type, byte road_rail_type) + :transport_type{transport_type}, road_rail_type{road_rail_type} {} + BuildTunnel(TileIndex tile, TransportType transport_type, byte road_rail_type) + :Command{tile}, transport_type{transport_type}, road_rail_type{road_rail_type} {} + ~BuildTunnel() override {} + + bool DoPost() override; + bool DoTest() override; }; } // namespace cmd diff --git a/src/command.cpp b/src/command.cpp index 24fab14367..358c7be501 100644 --- a/src/command.cpp +++ b/src/command.cpp @@ -279,11 +279,11 @@ void CommandHelperBase::InternalPostResult(const CommandCost &res, TileIndex til ShowCostOrIncomeAnimation(x, y, GetSlopePixelZ(x, y), res.GetCost()); } - FIXME mode to callback + /* FIXME mode to callback if (!estimate_only && !only_sending) citymania::HandleCommandExecution(res.Succeeded(), tile, p1, p2, cmd, text); - return res.Succeeded(); + */ } /** Helper to make a desync log for a command. */ diff --git a/src/main_gui.cpp b/src/main_gui.cpp index e902a5fad4..5dc4339698 100644 --- a/src/main_gui.cpp +++ b/src/main_gui.cpp @@ -48,6 +48,8 @@ #include "table/strings.h" #include "debug.h" +#include "citymania/cm_commands.hpp" + #include "safeguards.h" /** diff --git a/src/misc_cmd.cpp b/src/misc_cmd.cpp index ec71a5b7ab..9525cb4d72 100644 --- a/src/misc_cmd.cpp +++ b/src/misc_cmd.cpp @@ -169,7 +169,7 @@ CommandCost CmdPause(DoCommandFlag flags, PauseMode mode, bool pause) if (pause) { _pause_mode |= mode; - FIXME //_pause_countdown = (p2 >> 1); + // FIXME //_pause_countdown = (p2 >> 1); } else { _pause_mode &= ~mode; } diff --git a/src/network/network.cpp b/src/network/network.cpp index 686f1878d7..fbbbcc280a 100644 --- a/src/network/network.cpp +++ b/src/network/network.cpp @@ -1179,7 +1179,7 @@ void NetworkGameLoop() } NetworkExecuteLocalCommandQueue(); - if (_pause_countdown > 0 && --_pause_countdown == 0) DoCommandP(0, PM_PAUSED_NORMAL, 1, CMD_PAUSE); + if (_pause_countdown > 0 && --_pause_countdown == 0) Command::Post(PM_PAUSED_NORMAL, 1); citymania::ExecuteFakeCommands(_date, _date_fract); diff --git a/src/network/network_command.cpp b/src/network/network_command.cpp index dc60e8e6d8..55dcd8eb25 100644 --- a/src/network/network_command.cpp +++ b/src/network/network_command.cpp @@ -292,8 +292,8 @@ void NetworkSendCommand(Commands cmd, StringID err_message, CommandCallback *cal 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); - citymania::SendClientCommand(&c); + MyClient::SendCommand(&c); + // FIXME citymania::SendClientCommand(&c); } /** @@ -332,7 +332,8 @@ void NetworkExecuteLocalCommandQueue() if (_frame_counter > cp->frame) { /* If we reach here, it means for whatever reason, we've already executed * past the command we need to execute. */ - error("[net] Trying to execute a packet in the past! (frame=%u cmd_frame=%u tile=%u p1=%u p2=%u cmd=%u)", (uint)_frame_counter, (uint)cp->frame, (uint)cp->tile, (uint)cp->p1, (uint)cp->p2, (uint)cp->cmd); + error("[net] Trying to execute a packet in the past! (frame=%u cmd_frame=%u)", (uint)_frame_counter, (uint)cp->frame); + // FIXME error("[net] Trying to execute a packet in the past! (frame=%u cmd_frame=%u tile=%u p1=%u p2=%u cmd=%u)", (uint)_frame_counter, (uint)cp->frame, (uint)cp->tile, (uint)cp->p1, (uint)cp->p2, (uint)cp->cmd); } /* We can execute this command */ diff --git a/src/object_gui.cpp b/src/object_gui.cpp index d637b97a05..9134b4e35a 100644 --- a/src/object_gui.cpp +++ b/src/object_gui.cpp @@ -458,7 +458,7 @@ public: } if (_selected_object_index != -1) { - SetObjectToPlaceWnd(SPR_CURSOR_TRANSMITTER, PAL_NONE, HT_RECT | HT_DIAGONAL, this, CM_DDSP_PLACE_OBJECT); + SetObjectToPlaceWnd(SPR_CURSOR_TRANSMITTER, PAL_NONE, HT_RECT | HT_DIAGONAL, this, DDSP_BUILD_OBJECT); } this->UpdateButtons(_selected_object_class, _selected_object_index, _selected_object_view); diff --git a/src/order_gui.cpp b/src/order_gui.cpp index f9844faa5e..ba1c4b3197 100644 --- a/src/order_gui.cpp +++ b/src/order_gui.cpp @@ -1570,18 +1570,20 @@ public: void OnPlaceObject(Point pt, TileIndex tile) override { if (this->goto_type == OPOS_GOTO) { - const Order cmd = GetOrderCmdFromTile(this->vehicle, tile); + auto res = GetOrderCmdFromTile(this->vehicle, tile); + const Order cmd = res.first; + auto feeder_mod = res.second; if (cmd.IsType(OT_NOTHING)) return; if (feeder_mod != FeederOrderMod::NONE) { if (feeder_mod == FeederOrderMod::LOAD) { if (Command::Post(STR_ERROR_CAN_T_INSERT_NEW_ORDER, this->vehicle->tile, this->vehicle->index, 1, cmd)) { - Command::Post(STR_ERROR_CAN_T_DELETE_THIS_ORDER, this->vehicle->tile, this->vehicle->index, 0) + Command::Post(STR_ERROR_CAN_T_DELETE_THIS_ORDER, this->vehicle->tile, this->vehicle->index, 0); } } else if (feeder_mod == FeederOrderMod::UNLOAD) { // still flushes the whole order table if (Command::Post(STR_ERROR_CAN_T_INSERT_NEW_ORDER, this->vehicle->tile, this->vehicle->index, this->vehicle->GetNumOrders(), cmd)) { - Command::Post(STR_ERROR_CAN_T_DELETE_THIS_ORDER, this->vehicle->tile, this->vehicle->index, this->vehicle->GetNumOrders() + (int)_networking - 2) + Command::Post(STR_ERROR_CAN_T_DELETE_THIS_ORDER, this->vehicle->tile, this->vehicle->index, this->vehicle->GetNumOrders() + (int)_networking - 2); } } } else if (Command::Post(STR_ERROR_CAN_T_INSERT_NEW_ORDER, this->vehicle->tile, this->vehicle->index, this->OrderGetSel(), cmd)) { diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index d8c2e914d7..f45c86e836 100644 --- a/src/rail_gui.cpp +++ b/src/rail_gui.cpp @@ -373,7 +373,7 @@ static void BuildRailClick_Remove(Window *w) } } -static CommandContainer DoRailroadTrackCmd(TileIndex start_tile, TileIndex end_tile, Track track) +/* FIXME static CommandContainer DoRailroadTrackCmd(TileIndex start_tile, TileIndex end_tile, Track track) { CommandContainer ret = { start_tile, // tile @@ -388,9 +388,9 @@ static CommandContainer DoRailroadTrackCmd(TileIndex start_tile, TileIndex end_t 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 || @@ -492,11 +492,11 @@ static bool HandleAutodirTerraform(TileIndex start_tile, TileIndex end_tile, Tra break; } return true; -} +}*/ } // namespace citymania -FIXME +//FIXME static void DoRailroadTrack(Track track) { if (_remove_button_clicked) { @@ -521,12 +521,13 @@ static void HandleAutodirPlacement() } // 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 @@ -535,7 +536,7 @@ static void HandleAutodirPlacement() * 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 (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); @@ -543,13 +544,13 @@ static void HandleAutodirPlacement() } 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) { + /*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. diff --git a/src/road_gui.cpp b/src/road_gui.cpp index 333dbfd6cd..480f402b18 100644 --- a/src/road_gui.cpp +++ b/src/road_gui.cpp @@ -9,7 +9,6 @@ #include "stdafx.h" #include "gui.h" -#include "cmd_helper.h" #include "window_gui.h" #include "station_func.h" #include "station_gui.h" @@ -171,7 +170,8 @@ void CcRoadStop(Commands cmd, const CommandCost &result, TileIndex tile, uint8 w static void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, RoadStopType stop_type, bool adjacent, RoadType rt, StringID err_msg) { if (citymania::UseImprovedStationJoin()) { - citymania::PlaceRoadStop(start_tile, end_tile, p2, cmd); + // FIXME +// citymania::PlaceRoadStop(start_tile, end_tile, stop_type, adjacent, rt, err_msg); return; } diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp index 99155b7c07..ccf6f430ae 100644 --- a/src/station_cmd.cpp +++ b/src/station_cmd.cpp @@ -1464,7 +1464,7 @@ CommandCost CmdBuildRailStation(DoCommandFlag flags, TileIndex tile_org, RailTyp st->MarkTilesDirty(false); st->AfterStationTileSetChange(true, STATION_RAIL); - citymania::OnStationPartBuilt(st, tile_org, p1, p2); + // FIXME citymania::OnStationPartBuilt(st, tile_org, p1, p2); } return cost; @@ -1932,7 +1932,7 @@ CommandCost CmdBuildRoadStop(DoCommandFlag flags, TileIndex tile, uint8 width, u } if (st != nullptr) { - FIXME citymania::OnStationPartBuilt(st, tile, p1, p2); + // FIXME citymania::OnStationPartBuilt(st, tile, p1, p2); st->AfterStationTileSetChange(true, is_truck_stop ? STATION_TRUCK: STATION_BUS); } } @@ -2328,7 +2328,7 @@ CommandCost CmdBuildAirport(DoCommandFlag flags, TileIndex tile, byte airport_ty Company::Get(st->owner)->infrastructure.airport++; st->AfterStationTileSetChange(true, STATION_AIRPORT); - citymania::OnStationPartBuilt(st, tile, p1, p2); + // FIXME citymania::OnStationPartBuilt(st, tile, p1, p2); InvalidateWindowData(WC_STATION_VIEW, st->index, -1); if (_settings_game.economy.station_noise_level) { @@ -2558,7 +2558,7 @@ CommandCost CmdBuildDock(DoCommandFlag flags, TileIndex tile, StationID station_ UpdateStationDockingTiles(st); st->AfterStationTileSetChange(true, STATION_DOCK); - citymania::OnStationPartBuilt(st, tile, p1, p2); + // FIXME citymania::OnStationPartBuilt(st, tile, p1, p2); } return cost; diff --git a/src/terraform_gui.cpp b/src/terraform_gui.cpp index 824df7e1a0..aa17e947c6 100644 --- a/src/terraform_gui.cpp +++ b/src/terraform_gui.cpp @@ -123,7 +123,7 @@ bool GUIPlaceProcDragXY(ViewportDragDropSelectionProcess proc, TileIndex start_t case DDSP_DEMOLISH_AREA: Command::Post(STR_ERROR_CAN_T_CLEAR_THIS_AREA, CcPlaySound_EXPLOSION, end_tile, start_tile, citymania::_fn_mod); break; - case DDSP_DEMOLISH_TREES: + case DDSP_DEMOLISH_TREES: { // loop through every tile and send a demolish command for each tree // orthogonal area TileIndex tree_start_tile, tree_recent_tile, prev_tile; @@ -179,6 +179,7 @@ bool GUIPlaceProcDragXY(ViewportDragDropSelectionProcess proc, TileIndex start_t } } break; + } case DDSP_RAISE_AND_LEVEL_AREA: Command::Post(STR_ERROR_CAN_T_RAISE_LAND_HERE, CcTerraform, end_tile, start_tile, citymania::_fn_mod, LM_RAISE); break; diff --git a/src/toolbar_gui.cpp b/src/toolbar_gui.cpp index 49a8eb0210..46c9af5986 100644 --- a/src/toolbar_gui.cpp +++ b/src/toolbar_gui.cpp @@ -58,6 +58,7 @@ #include "network/network_func.h" #include "object_type.h" +#include "company_cmd.h" #include "citymania/cm_cargo_table_gui.hpp" #include "citymania/cm_commands.hpp" #include "citymania/cm_commands_gui.hpp" @@ -2164,7 +2165,7 @@ struct MainToolbarWindow : Window { break; case CBF_PLACE_LANDINFO: - VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_MEASURE); + VpStartPlaceSizing(tile, VPM_X_AND_Y, CM_DDSP_MEASURE); break; case CM_CBF_BUILD_HQ: @@ -2573,7 +2574,7 @@ struct ScenarioEditorToolbarWindow : Window { break; case CBF_PLACE_LANDINFO: - VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_MEASURE); + VpStartPlaceSizing(tile, VPM_X_AND_Y, CM_DDSP_MEASURE); break; default: NOT_REACHED(); diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp index f25be3b87f..5970a6fa9e 100644 --- a/src/town_cmd.cpp +++ b/src/town_cmd.cpp @@ -3198,7 +3198,7 @@ CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16 growth } UpdateTownGrowth(t); InvalidateWindowData(WC_TOWN_VIEW, town_id); - InvalidateWindowData(WC_CB_TOWN, p1); + InvalidateWindowData(WC_CB_TOWN, town_id); } return CommandCost(); diff --git a/src/town_gui.cpp b/src/town_gui.cpp index 88567526d9..0909382c19 100644 --- a/src/town_gui.cpp +++ b/src/town_gui.cpp @@ -45,6 +45,7 @@ #include #include "console_func.h" +#include "citymania/cm_commands.hpp" #include "citymania/cm_hotkeys.hpp" /* CityMania end */ diff --git a/src/vehicle_gui.cpp b/src/vehicle_gui.cpp index 3375bb5387..7e2a278d8a 100644 --- a/src/vehicle_gui.cpp +++ b/src/vehicle_gui.cpp @@ -2640,7 +2640,7 @@ static bool IsVehicleRefitable(const Vehicle *v) return false; } -void CcCloneVehicleWithOrderIndex(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd) +/* FIXME void CcCloneVehicleWithOrderIndex(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2, uint32 cmd) { if (result.Failed()) return; if (p2 != 1) CcCloneVehicle(result, tile, p1, p2, cmd); @@ -2651,7 +2651,7 @@ void CcCloneVehicleWithOrderIndex(const CommandCost &result, TileIndex tile, uin citymania::cmd::SkipToOrder(v->index, cloned->cur_implicit_order_index) .WithTile(v->tile) .Post(); -} +}*/ /** Window manager class for viewing a vehicle. */ struct VehicleViewWindow : Window { diff --git a/src/viewport.cpp b/src/viewport.cpp index be424e06df..832fb89b95 100644 --- a/src/viewport.cpp +++ b/src/viewport.cpp @@ -3642,7 +3642,7 @@ calc_heightdiff_single_direction:; FALLTHROUGH; case VPM_X_AND_Y: // drag an X by Y area - if (_settings_client.gui.measure_tooltip || _thd.select_proc == DDSP_MEASURE) { + if (_settings_client.gui.measure_tooltip || _thd.select_proc == CM_DDSP_MEASURE) { static const StringID measure_strings_area[] = { STR_NULL, STR_NULL, STR_MEASURE_AREA, STR_MEASURE_AREA_HEIGHTDIFF, STR_MEASURE_DIST_HEIGHTDIFF, @@ -3701,7 +3701,7 @@ calc_heightdiff_single_direction:; params[index++] = dx - (style & HT_POINT ? 1 : 0); params[index++] = dy - (style & HT_POINT ? 1 : 0); - if (_thd.select_proc == DDSP_MEASURE) { + if (_thd.select_proc == CM_DDSP_MEASURE) { params[index++] = sqrtl(dx * dx + dy * dy); }