From c97f85950d39501fbb8fbf4391b1f635622aff36 Mon Sep 17 00:00:00 2001 From: Igor Kolchinskii <33728971+leosnake2208@users.noreply.github.com> Date: Sun, 19 Jul 2026 01:43:45 +0200 Subject: [PATCH 1/2] Add modern control scheme (right-click to command) Optional control scheme matching modern RTS games: the right mouse button issues orders to the current selection, while the left mouse button only selects/deploys and deselects on empty ground. Reuses the game's own command dispatch (and network path) by redirecting the RMB-up handler into the shared LMB-up command dispatch. Special left-click modes (repair/sell/place/beacon/ superweapon/planning) keep their vanilla behaviour. Gated behind [Phobos] ModernControls (default off). --- CREDITS.md | 2 + Phobos.vcxproj | 1 + docs/User-Interface.md | 16 ++++ docs/Whats-New.md | 2 + src/Misc/ModernControls.cpp | 151 ++++++++++++++++++++++++++++++++++++ src/Phobos.INI.cpp | 2 + src/Phobos.h | 1 + 7 files changed, 175 insertions(+) create mode 100644 src/Misc/ModernControls.cpp diff --git a/CREDITS.md b/CREDITS.md index 731ccc454c..3b4e3a74f4 100644 --- a/CREDITS.md +++ b/CREDITS.md @@ -888,3 +888,5 @@ This page lists all the individual contributions to the project by their author. - **Chang_zhi**: - Interop export interface for accessing scenario local/global variables - Add `ClampToScreen` tag for `BannerType` to control whether banner position is clamped to the visible area +- **Igor Kolchinskii (leosnake2208)**: + - Modern control scheme (right-click to command) diff --git a/Phobos.vcxproj b/Phobos.vcxproj index cea5e31f02..f2179f303a 100644 --- a/Phobos.vcxproj +++ b/Phobos.vcxproj @@ -263,6 +263,7 @@ + diff --git a/docs/User-Interface.md b/docs/User-Interface.md index 26fc2b8418..67ab642e53 100644 --- a/docs/User-Interface.md +++ b/docs/User-Interface.md @@ -262,6 +262,22 @@ In `RA2MD.INI`: PrioritySelectionFiltering=true ; boolean ``` +### Modern control scheme + +- An optional control scheme matching modern RTS games: the **right mouse button** issues orders to the current selection (move, attack, enter, capture, etc.), while the **left mouse button** only selects, box-selects and self-deploys, and deselects when clicking empty ground. It reuses the game's own command dispatch, so all order and network logic is unchanged. + - Special left-click modes are preserved on both buttons: while placing a building, repairing, selling, toggling power, planting a beacon, planning a path or targeting a superweapon, the left button performs that action and the right button cancels it, exactly as in vanilla. +- Enable it with `ModernControls=true`. + +```{note} +This only changes mouse behaviour; keyboard hotkeys are unaffected. It does not rebind any keys. +``` + +In `RA2MD.INI`: +```ini +[Phobos] +ModernControls=false ; boolean +``` + ### Placement preview ![placepreview](_static/images/placepreview.png) diff --git a/docs/Whats-New.md b/docs/Whats-New.md index 1befcdb9ae..505261d045 100644 --- a/docs/Whats-New.md +++ b/docs/Whats-New.md @@ -140,6 +140,7 @@ ShowBriefing=true ; boolean DigitalDisplay.Enable=false ; boolean ShowDesignatorRange=false ; boolean PrioritySelectionFiltering=true ; boolean +ModernControls=false ; boolean PriorityDeployFiltering=true ; boolean ShowPlacementPreview=yes ; boolean RealTimeTimers=false ; boolean @@ -386,6 +387,7 @@ HideShakeEffects=false ; boolean :open: #### New: +- [Modern control scheme (right-click to command)](User-Interface.md#modern-control-scheme) (by leosnake2208) - [Allow using waypoints, area guard and attack move with aircraft](Fixed-or-Improved-Logics.md#extended-aircraft-missions) (by CrimRecya) - [Enhanced Straight trajectory](New-or-Enhanced-Logics.md#straight-trajectory) (by CrimRecya) - [Enable building production queue](User-Interface.md#building-production-queue) (by CrimRecya) diff --git a/src/Misc/ModernControls.cpp b/src/Misc/ModernControls.cpp new file mode 100644 index 0000000000..ef43427e8c --- /dev/null +++ b/src/Misc/ModernControls.cpp @@ -0,0 +1,151 @@ +#include + +#include +#include +#include +#include +#include // pulls in the complete FootClass/TechnoClass definitions that + // MapClass/DisplayClass inline abstract_casts require + +// Modern control scheme: the right mouse button issues orders, the left mouse button only +// selects / deploys (and deselects when clicking empty ground), matching the control style +// of modern RTS games. Off by default; enable with [Phobos] -> ModernControls. +// +// The tactical mouse message handler is MouseClass method 0x6930A0, which dispatches Windows +// mouse messages through a jump table (0x693410). Relevant cases (reverse-engineered): +// LBUTTONDOWN 0x201 -> 0x693126 (begin select/action; sets the drag flag [this+0x555A]=1) +// LBUTTONUP 0x202 -> 0x6931F9 (command dispatch: ProcessClickCoords -> DecideAction +// -> apply 0x4AB9B0, from 0x69323E onward) +// RBUTTONUP 0x205 -> 0x693366 (vanilla: cancel current mode, then deselect) +// +// RBUTTONUP and LBUTTONUP are two cases of the SAME function, sharing one stack frame and +// the same `this`; both prologues turn [esp+0x34] from a message-point pointer into an inline +// Point2D. So the RMB-up handler can jump straight into the LMB-up command dispatch at +// 0x69323E, reusing 100% of the game's command (and network) logic - no argument +// reconstruction is needed. + +namespace ModernControls +{ + // A special LEFT-click mode is active - RMB must keep its vanilla "cancel" behaviour + // (cancel building placement, leave repair/sell/power/beacon/superweapon targeting) and + // LMB must keep its vanilla behaviour (repair/sell/place/target). + static bool InSpecialLeftClickMode() + { + auto& d = DisplayClass::Instance; + return d.RepairMode + || d.SellMode + || d.PowerToggleMode + || d.PlaceBeaconMode + || d.PlanningMode + || d.CurrentSWTypeIndex >= 0 // superweapon targeting + || d.CurrentBuilding != nullptr; // building placement + } + + // Set by the RBUTTONUP command hook right before it jumps into the shared LMB-up command + // dispatch (0x69323E), which flows through the LBUTTONUP neutralise hook at 0x693276. + // Without this flag that hook would downgrade the RMB-issued order to None; the LBUTTONUP + // hook consumes (clears) it. + static bool RmbCommandInProgress = false; + + // Actions the LEFT button may still perform: selection and self-deploy only. Everything + // else (Move/Attack/Enter/Harvest/Capture/Guard/...) is a command and belongs to the + // RIGHT button now. + static bool IsLeftClickAllowed(Action action) + { + switch (action) + { + case Action::None: + case Action::Select: + case Action::ToggleSelect: + case Action::Self_Deploy: + return true; + default: + return false; + } + } + + // If modern controls are on and no special left-click mode is active, downgrade the + // command action (in EAX, freshly returned by DecideAction) to None so the left button + // only selects/deploys. Returns true if a command was actually neutralised (the click + // landed on empty ground / an enemy - a command target, not a selectable own unit). + static bool NeutraliseLeftCommand(REGISTERS* R) + { + if (Phobos::Config::ModernControls && !InSpecialLeftClickMode()) + { + if (!IsLeftClickAllowed(static_cast(R->EAX()))) + { + R->EAX(static_cast(Action::None)); + return true; + } + } + return false; + } +} + +// RBUTTONUP handler, just past its "press/drag in progress" gate (cmp [this+0x555A],bl / +// je 0x693408 at 0x69338F), so it inherits the same gate the vanilla deselect uses. Stolen +// bytes: cmp byte ptr [0x884D40], bl (absolute operand, safe to relocate). +// +// The LMB-up dispatch we jump into (0x69323E) reads the click point as &[esp+0x10], i.e. the +// view-relative coords (raw window xy minus the tactical view origin at 0x886FA0/0x886FA4). +// The LMB prologue stores those at [esp+0x10]/[esp+0x14]; the RMB prologue computes the same +// values but only passes them to 0x63AB00 without storing them, so we populate the slots +// ourselves before jumping (otherwise ProcessClickCoords reads stale stack and the order +// lands on the wrong cell). +DEFINE_HOOK(0x693397, TacticalMsgHandler_RButtonUp_ModernCommand, 0x6) +{ + if (Phobos::Config::ModernControls + && ObjectClass::CurrentObjects.Count > 0 + && !ModernControls::InSpecialLeftClickMode()) + { + // Raw packed window xy stashed by the RMB prologue at [esp+0x34]. + const int packed = R->Stack(0x34); + const int rawX = static_cast(packed & 0xFFFF); + const int rawY = static_cast((packed >> 16) & 0xFFFF); + + const int originX = *reinterpret_cast(0x886FA0); + const int originY = *reinterpret_cast(0x886FA4); + + // Feed the LMB-up command dispatch the view-relative click point. + R->Stack(0x10, rawX - originX); + R->Stack(0x14, rawY - originY); + + // Tell the LBUTTONUP neutralise hook to leave this (RMB-issued) command alone. + ModernControls::RmbCommandInProgress = true; + + // Issue the order to the current selection instead of deselecting. + return 0x69323E; + } + + // Vanilla: run the stolen compare and fall through to the cancel/deselect path. + return 0; +} + +// LBUTTONDOWN: neutralise a command action right after DecideAction so button-down does not +// preview/issue a command. Stolen bytes: mov reg,[esp+..] + push eax (the possibly-modified +// EAX is what the following push forwards to the applier). +DEFINE_HOOK(0x6931B4, TacticalMsgHandler_LButtonDown_ModernSelectOnly, 0x5) +{ + ModernControls::NeutraliseLeftCommand(R); + return 0; +} + +// LBUTTONUP: same neutralise, and turn a would-be command on empty ground / an enemy into a +// deselect (MapClass::UnselectAll). Clicking own units (Select/ToggleSelect) or deploying +// (Self_Deploy) is not neutralised, so it selects/deploys as normal - no deselect there. +// Completed band-selects never reach here (0x63A8E0 consumes them and early-exits at +// 0x693408), so deselecting on a neutralised command is always correct. +DEFINE_HOOK(0x693276, TacticalMsgHandler_LButtonUp_ModernSelectOnly, 0x5) +{ + // If we arrived here via the RMB command redirect (0x69323E), let the order stand. + if (ModernControls::RmbCommandInProgress) + { + ModernControls::RmbCommandInProgress = false; + return 0; + } + + if (ModernControls::NeutraliseLeftCommand(R)) + MapClass::UnselectAll(); + + return 0; +} diff --git a/src/Phobos.INI.cpp b/src/Phobos.INI.cpp index ac9f7649b2..9582205194 100644 --- a/src/Phobos.INI.cpp +++ b/src/Phobos.INI.cpp @@ -49,6 +49,7 @@ bool Phobos::Config::ToolTipDescriptions = true; bool Phobos::Config::ToolTipBlur = false; bool Phobos::Config::PrioritySelectionFiltering = true; bool Phobos::Config::PriorityDeployFiltering = true; +bool Phobos::Config::ModernControls = false; bool Phobos::Config::TypeSelectUseIFVMode = true; bool Phobos::Config::DevelopmentCommands = true; bool Phobos::Config::SuperWeaponSidebarCommands = false; @@ -94,6 +95,7 @@ DEFINE_HOOK(0x5FACDF, OptionsClass_LoadSettings_LoadPhobosSettings, 0x5) Phobos::Config::ToolTipBlur = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ToolTipBlur", false); Phobos::Config::PrioritySelectionFiltering = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "PrioritySelectionFiltering", true); Phobos::Config::PriorityDeployFiltering = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "PriorityDeployFiltering", true); + Phobos::Config::ModernControls = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ModernControls", false); Phobos::Config::TypeSelectUseIFVMode = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "TypeSelectUseIFVMode", true); Phobos::Config::ShowPlacementPreview = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ShowPlacementPreview", true); Phobos::Config::MessageApplyHoverState = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "MessageApplyHoverState", false); diff --git a/src/Phobos.h b/src/Phobos.h index 6bdb4073ec..75b171be39 100644 --- a/src/Phobos.h +++ b/src/Phobos.h @@ -84,6 +84,7 @@ class Phobos static bool ToolTipBlur; static bool PrioritySelectionFiltering; static bool PriorityDeployFiltering; + static bool ModernControls; static bool TypeSelectUseIFVMode; static bool DevelopmentCommands; static bool SuperWeaponSidebarCommands; From f0bf76304a18a51279f774df74718aa3ad565038 Mon Sep 17 00:00:00 2001 From: Igor Kolchinskii <33728971+leosnake2208@users.noreply.github.com> Date: Sun, 19 Jul 2026 13:08:22 +0200 Subject: [PATCH 2/2] Rename ModernControls to RightClickCommand Address review feedback (Coronia): "ModernControls" is an ambiguous name. Rename the INI tag, config field, source file, namespace and hook names to the clearer "RightClickCommand"; update docs and CREDITS. Co-Authored-By: Claude Opus 4.8 --- CREDITS.md | 2 +- Phobos.vcxproj | 2 +- docs/User-Interface.md | 32 +++++++++---------- docs/Whats-New.md | 4 +-- ...dernControls.cpp => RightClickCommand.cpp} | 30 ++++++++--------- src/Phobos.INI.cpp | 4 +-- src/Phobos.h | 2 +- 7 files changed, 38 insertions(+), 38 deletions(-) rename src/Misc/{ModernControls.cpp => RightClickCommand.cpp} (86%) diff --git a/CREDITS.md b/CREDITS.md index 3b4e3a74f4..90d1db280d 100644 --- a/CREDITS.md +++ b/CREDITS.md @@ -889,4 +889,4 @@ This page lists all the individual contributions to the project by their author. - Interop export interface for accessing scenario local/global variables - Add `ClampToScreen` tag for `BannerType` to control whether banner position is clamped to the visible area - **Igor Kolchinskii (leosnake2208)**: - - Modern control scheme (right-click to command) + - Right-click to command diff --git a/Phobos.vcxproj b/Phobos.vcxproj index f2179f303a..9b93cd331e 100644 --- a/Phobos.vcxproj +++ b/Phobos.vcxproj @@ -263,9 +263,9 @@ - + diff --git a/docs/User-Interface.md b/docs/User-Interface.md index 67ab642e53..010b44ed49 100644 --- a/docs/User-Interface.md +++ b/docs/User-Interface.md @@ -262,22 +262,6 @@ In `RA2MD.INI`: PrioritySelectionFiltering=true ; boolean ``` -### Modern control scheme - -- An optional control scheme matching modern RTS games: the **right mouse button** issues orders to the current selection (move, attack, enter, capture, etc.), while the **left mouse button** only selects, box-selects and self-deploys, and deselects when clicking empty ground. It reuses the game's own command dispatch, so all order and network logic is unchanged. - - Special left-click modes are preserved on both buttons: while placing a building, repairing, selling, toggling power, planting a beacon, planning a path or targeting a superweapon, the left button performs that action and the right button cancels it, exactly as in vanilla. -- Enable it with `ModernControls=true`. - -```{note} -This only changes mouse behaviour; keyboard hotkeys are unaffected. It does not rebind any keys. -``` - -In `RA2MD.INI`: -```ini -[Phobos] -ModernControls=false ; boolean -``` - ### Placement preview ![placepreview](_static/images/placepreview.png) @@ -335,6 +319,22 @@ RealTimeTimers=false ; boolean RealTimeTimers.Adaptive=false ; boolean ``` +### Right-click to command + +- An optional control scheme matching modern RTS games: the **right mouse button** issues orders to the current selection (move, attack, enter, capture, etc.), while the **left mouse button** only selects, box-selects and self-deploys, and deselects when clicking empty ground. It reuses the game's own command dispatch, so all order and network logic is unchanged. + - Special left-click modes are preserved on both buttons: while placing a building, repairing, selling, toggling power, planting a beacon, planning a path or targeting a superweapon, the left button performs that action and the right button cancels it, exactly as in vanilla. +- Enable it with `RightClickCommand=true`. + +```{note} +This only changes mouse behaviour; keyboard hotkeys are unaffected. It does not rebind any keys. +``` + +In `RA2MD.INI`: +```ini +[Phobos] +RightClickCommand=false ; boolean +``` + ### Select Box ![selectbox](_static/images/selectbox.png) diff --git a/docs/Whats-New.md b/docs/Whats-New.md index 505261d045..fd00bae3b0 100644 --- a/docs/Whats-New.md +++ b/docs/Whats-New.md @@ -140,7 +140,7 @@ ShowBriefing=true ; boolean DigitalDisplay.Enable=false ; boolean ShowDesignatorRange=false ; boolean PrioritySelectionFiltering=true ; boolean -ModernControls=false ; boolean +RightClickCommand=false ; boolean PriorityDeployFiltering=true ; boolean ShowPlacementPreview=yes ; boolean RealTimeTimers=false ; boolean @@ -387,7 +387,7 @@ HideShakeEffects=false ; boolean :open: #### New: -- [Modern control scheme (right-click to command)](User-Interface.md#modern-control-scheme) (by leosnake2208) +- [Right-click to command](User-Interface.md#right-click-to-command) (by leosnake2208) - [Allow using waypoints, area guard and attack move with aircraft](Fixed-or-Improved-Logics.md#extended-aircraft-missions) (by CrimRecya) - [Enhanced Straight trajectory](New-or-Enhanced-Logics.md#straight-trajectory) (by CrimRecya) - [Enable building production queue](User-Interface.md#building-production-queue) (by CrimRecya) diff --git a/src/Misc/ModernControls.cpp b/src/Misc/RightClickCommand.cpp similarity index 86% rename from src/Misc/ModernControls.cpp rename to src/Misc/RightClickCommand.cpp index ef43427e8c..98abe783ec 100644 --- a/src/Misc/ModernControls.cpp +++ b/src/Misc/RightClickCommand.cpp @@ -7,9 +7,9 @@ #include // pulls in the complete FootClass/TechnoClass definitions that // MapClass/DisplayClass inline abstract_casts require -// Modern control scheme: the right mouse button issues orders, the left mouse button only +// Right-click to command: the right mouse button issues orders, the left mouse button only // selects / deploys (and deselects when clicking empty ground), matching the control style -// of modern RTS games. Off by default; enable with [Phobos] -> ModernControls. +// of modern RTS games. Off by default; enable with [Phobos] -> RightClickCommand. // // The tactical mouse message handler is MouseClass method 0x6930A0, which dispatches Windows // mouse messages through a jump table (0x693410). Relevant cases (reverse-engineered): @@ -24,7 +24,7 @@ // 0x69323E, reusing 100% of the game's command (and network) logic - no argument // reconstruction is needed. -namespace ModernControls +namespace RightClickCommand { // A special LEFT-click mode is active - RMB must keep its vanilla "cancel" behaviour // (cancel building placement, leave repair/sell/power/beacon/superweapon targeting) and @@ -64,13 +64,13 @@ namespace ModernControls } } - // If modern controls are on and no special left-click mode is active, downgrade the + // If right-click-to-command is on and no special left-click mode is active, downgrade the // command action (in EAX, freshly returned by DecideAction) to None so the left button // only selects/deploys. Returns true if a command was actually neutralised (the click // landed on empty ground / an enemy - a command target, not a selectable own unit). static bool NeutraliseLeftCommand(REGISTERS* R) { - if (Phobos::Config::ModernControls && !InSpecialLeftClickMode()) + if (Phobos::Config::RightClickCommand && !InSpecialLeftClickMode()) { if (!IsLeftClickAllowed(static_cast(R->EAX()))) { @@ -92,11 +92,11 @@ namespace ModernControls // values but only passes them to 0x63AB00 without storing them, so we populate the slots // ourselves before jumping (otherwise ProcessClickCoords reads stale stack and the order // lands on the wrong cell). -DEFINE_HOOK(0x693397, TacticalMsgHandler_RButtonUp_ModernCommand, 0x6) +DEFINE_HOOK(0x693397, TacticalMsgHandler_RButtonUp_RightClickCommand, 0x6) { - if (Phobos::Config::ModernControls + if (Phobos::Config::RightClickCommand && ObjectClass::CurrentObjects.Count > 0 - && !ModernControls::InSpecialLeftClickMode()) + && !RightClickCommand::InSpecialLeftClickMode()) { // Raw packed window xy stashed by the RMB prologue at [esp+0x34]. const int packed = R->Stack(0x34); @@ -111,7 +111,7 @@ DEFINE_HOOK(0x693397, TacticalMsgHandler_RButtonUp_ModernCommand, 0x6) R->Stack(0x14, rawY - originY); // Tell the LBUTTONUP neutralise hook to leave this (RMB-issued) command alone. - ModernControls::RmbCommandInProgress = true; + RightClickCommand::RmbCommandInProgress = true; // Issue the order to the current selection instead of deselecting. return 0x69323E; @@ -124,9 +124,9 @@ DEFINE_HOOK(0x693397, TacticalMsgHandler_RButtonUp_ModernCommand, 0x6) // LBUTTONDOWN: neutralise a command action right after DecideAction so button-down does not // preview/issue a command. Stolen bytes: mov reg,[esp+..] + push eax (the possibly-modified // EAX is what the following push forwards to the applier). -DEFINE_HOOK(0x6931B4, TacticalMsgHandler_LButtonDown_ModernSelectOnly, 0x5) +DEFINE_HOOK(0x6931B4, TacticalMsgHandler_LButtonDown_RightClickSelectOnly, 0x5) { - ModernControls::NeutraliseLeftCommand(R); + RightClickCommand::NeutraliseLeftCommand(R); return 0; } @@ -135,16 +135,16 @@ DEFINE_HOOK(0x6931B4, TacticalMsgHandler_LButtonDown_ModernSelectOnly, 0x5) // (Self_Deploy) is not neutralised, so it selects/deploys as normal - no deselect there. // Completed band-selects never reach here (0x63A8E0 consumes them and early-exits at // 0x693408), so deselecting on a neutralised command is always correct. -DEFINE_HOOK(0x693276, TacticalMsgHandler_LButtonUp_ModernSelectOnly, 0x5) +DEFINE_HOOK(0x693276, TacticalMsgHandler_LButtonUp_RightClickSelectOnly, 0x5) { // If we arrived here via the RMB command redirect (0x69323E), let the order stand. - if (ModernControls::RmbCommandInProgress) + if (RightClickCommand::RmbCommandInProgress) { - ModernControls::RmbCommandInProgress = false; + RightClickCommand::RmbCommandInProgress = false; return 0; } - if (ModernControls::NeutraliseLeftCommand(R)) + if (RightClickCommand::NeutraliseLeftCommand(R)) MapClass::UnselectAll(); return 0; diff --git a/src/Phobos.INI.cpp b/src/Phobos.INI.cpp index 9582205194..498f58eb75 100644 --- a/src/Phobos.INI.cpp +++ b/src/Phobos.INI.cpp @@ -49,7 +49,7 @@ bool Phobos::Config::ToolTipDescriptions = true; bool Phobos::Config::ToolTipBlur = false; bool Phobos::Config::PrioritySelectionFiltering = true; bool Phobos::Config::PriorityDeployFiltering = true; -bool Phobos::Config::ModernControls = false; +bool Phobos::Config::RightClickCommand = false; bool Phobos::Config::TypeSelectUseIFVMode = true; bool Phobos::Config::DevelopmentCommands = true; bool Phobos::Config::SuperWeaponSidebarCommands = false; @@ -95,7 +95,7 @@ DEFINE_HOOK(0x5FACDF, OptionsClass_LoadSettings_LoadPhobosSettings, 0x5) Phobos::Config::ToolTipBlur = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ToolTipBlur", false); Phobos::Config::PrioritySelectionFiltering = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "PrioritySelectionFiltering", true); Phobos::Config::PriorityDeployFiltering = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "PriorityDeployFiltering", true); - Phobos::Config::ModernControls = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ModernControls", false); + Phobos::Config::RightClickCommand = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "RightClickCommand", false); Phobos::Config::TypeSelectUseIFVMode = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "TypeSelectUseIFVMode", true); Phobos::Config::ShowPlacementPreview = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "ShowPlacementPreview", true); Phobos::Config::MessageApplyHoverState = CCINIClass::INI_RA2MD.ReadBool(phobosSection, "MessageApplyHoverState", false); diff --git a/src/Phobos.h b/src/Phobos.h index 75b171be39..1dd2e5def3 100644 --- a/src/Phobos.h +++ b/src/Phobos.h @@ -84,7 +84,7 @@ class Phobos static bool ToolTipBlur; static bool PrioritySelectionFiltering; static bool PriorityDeployFiltering; - static bool ModernControls; + static bool RightClickCommand; static bool TypeSelectUseIFVMode; static bool DevelopmentCommands; static bool SuperWeaponSidebarCommands;