Thr0lu5/townforge
1
0
Fork 0
forked from townforge/townforge
Code Issues Pull Requests Projects Releases Wiki Activity

game: add compass size option

Browse Source
This commit is contained in:
Crypto City 2020-07-09 13:43:14 +00:00
parent 0bb633c75a
commit eef30b89dd
6 changed files with 95 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
GameData/TB/cc/options.tb.txt
View File

@ -61,10 +61,6 @@ TBTabContainer
TBLayout: axis x, distribution-position: "left top", distribution: "gravity", size: "preferred"
TBClickLabel: text: "Show compass"
lp: min-width: 200
TBCheckBox: id: "compass"
TBLayout: axis: x, distribution: "available"
TBLayout: axis: y, distribution-position: "center top", distribution: "gravity"
TBTextField: text: "Double click on a row, then hit a key or a mouse button to set"
@ -108,3 +104,11 @@ TBTabContainer
TBLayout: axis: x, gravity: "left"
TBTextField: text: "Font size"
TBInlineSelect: id: "font-size", min: 8, max: 100
TBLayout: axis: x
TBTextField: text: "Compass"
TBSelectDropdown: id: "compass"
items
item: id: "compass-off", text: "Off"
item: id: "compass-small", text: "Small"
item: id: "compass-medium", text: "Medium"
item: id: "compass-large", text: "Large"

38
src/game/main-urho3d.cc
View File

@ -95,14 +95,14 @@ const float TOUCH_SENSITIVITY = 2.0f;
#define CONFIG_DEBUG "debug"
#define CONFIG_INVERT_MOUSE_Y "invert-mouse-y"
#define CONFIG_MOUSE_SENSITIVITY "mouse-sensitivity"
#define CONFIG_COMPASS "compass"
#define DEFAULT_COMPASS true
#define CONFIG_MUSIC_TRACK "music-track"
#define DEFAULT_MUSIC_TRACK TBIDC("music-track-random-no-chiptunes")
#define CONFIG_MUSIC_VOLUME "music-volume"
#define DEFAULT_MUSIC_VOLUME 0.7f
#define CONFIG_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS "include-unmatched-trades"
#define DEFAULT_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS false
#define CONFIG_COMPASS "compass"
#define DEFAULT_COMPASS TBIDC("compass-medium")
static const std::map<TBID, std::vector<String>> music_tracks =
{
@ -236,12 +236,12 @@ public:
void HandleEnableHorizon(StringHash eventType, VariantMap& eventData);
void HandleEnableDynamicSky(StringHash eventType, VariantMap& eventData);
void HandleTimeOfDay(StringHash eventType, VariantMap& eventData);
void HandleEnableCompass(StringHash eventType, VariantMap& eventData);
void HandleServicePrice(StringHash eventType, VariantMap& eventData);
void HandleMusicTrack(StringHash eventType, VariantMap& eventData);
void HandleMusicVolume(StringHash eventType, VariantMap& eventData);
void HandleMusicSkipTrack(StringHash eventType, VariantMap& eventData);
void HandleIncludeUnmatchedTradesInQueuedComands(StringHash eventType, VariantMap& eventData);
void HandleCompass(StringHash eventType, VariantMap& eventData);
void HandleLoadingWallet(StringHash eventType, VariantMap& eventData);
void HandleNewWallet(StringHash eventType, VariantMap& eventData);
@ -327,10 +327,10 @@ private:
void EnableHorizon(bool enable);
void EnableDynamicSky(bool enable);
void ShowFlags(bool enable);
void EnableCompass(bool enable);
void SetTimeOfDay(float t);
void SetMusicTrack(TBID track);
void SetMusicVolume(float volume);
void SetCompass(TBID compass);
void UpdateSky();
void LoadControls();
bool GetKeyDown(Urho3D::Key key);
@ -840,7 +840,6 @@ void CryptoCityUrho3D::SetupUI()
SubscribeToEvent(ui, E_CRYPTOCITY_ENABLE_DYNAMIC_SKY, URHO3D_HANDLER(CryptoCityUrho3D, HandleEnableDynamicSky));
SubscribeToEvent(ui, E_CRYPTOCITY_TIME_OF_DAY, URHO3D_HANDLER(CryptoCityUrho3D, HandleTimeOfDay));
SubscribeToEvent(ui, E_CRYPTOCITY_SHOW_FLAGS, URHO3D_HANDLER(CryptoCityUrho3D, HandleShowFlags));
SubscribeToEvent(ui, E_CRYPTOCITY_ENABLE_COMPASS, URHO3D_HANDLER(CryptoCityUrho3D, HandleEnableCompass));
SubscribeToEvent(ui, E_CRYPTOCITY_REQUEST_PLAYER_DATA, URHO3D_HANDLER(CryptoCityUrho3D, HandleRequestPlayerData));
SubscribeToEvent(ui, E_CRYPTOCITY_SET_NODE_CONFIG, URHO3D_HANDLER(CryptoCityUrho3D, HandleSetNodeConfig));
SubscribeToEvent(ui, E_CRYPTOCITY_FOUND_CITY, URHO3D_HANDLER(CryptoCityUrho3D, HandleFoundCity));
@ -871,6 +870,7 @@ void CryptoCityUrho3D::SetupUI()
SubscribeToEvent(ui, E_CRYPTOCITY_MUSIC_VOLUME, URHO3D_HANDLER(CryptoCityUrho3D, HandleMusicVolume));
SubscribeToEvent(ui, E_CRYPTOCITY_MUSIC_SKIP_TRACK, URHO3D_HANDLER(CryptoCityUrho3D, HandleMusicSkipTrack));
SubscribeToEvent(ui, E_CRYPTOCITY_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS, URHO3D_HANDLER(CryptoCityUrho3D, HandleIncludeUnmatchedTradesInQueuedComands));
SubscribeToEvent(ui, E_CRYPTOCITY_COMPASS, URHO3D_HANDLER(CryptoCityUrho3D, HandleCompass));
SubscribeToEvent(&gameState, E_CRYPTOCITY_REQUEST_PLAYER_DATA, URHO3D_HANDLER(CryptoCityUrho3D, HandleRequestPlayerData));
SubscribeToEvent(&gameState, E_CRYPTOCITY_REQUEST_ITEM_DATA, URHO3D_HANDLER(CryptoCityUrho3D, HandleRequestItemData));
SubscribeToEvent(&gameState, E_CRYPTOCITY_REQUEST_BADGE_DATA, URHO3D_HANDLER(CryptoCityUrho3D, HandleRequestBadgeData));
@ -1193,11 +1193,6 @@ void CryptoCityUrho3D::ShowFlags(bool enable)
cityMesh->setDisplayMode(enable ? DisplayModeShowFlags : DisplayModeNormal);
}
void CryptoCityUrho3D::EnableCompass(bool enable)
{
ui->EnableCompass(enable);
}
bool CryptoCityUrho3D::SetGraphicsMode(int monitor, int width, int height, int refresh_rate)
{
Graphics *graphics = GetSubsystem<Graphics>();
@ -1229,6 +1224,11 @@ void CryptoCityUrho3D::SetMusicVolume(float volume)
audio.SetMusicVolume(volume);
}
void CryptoCityUrho3D::SetCompass(TBID compass)
{
ui->SetCompassType(compass);
}
void CryptoCityUrho3D::CreateScene()
{
if (!scene_)
@ -1346,9 +1346,9 @@ printf("%d plots, origin %u %u\n", plots, ox, oy);
EnableDynamicSky(GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_DYNAMIC_SKY, DEFAULT_DYNAMIC_SKY));
SetTimeOfDay(GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_TIME_OF_DAY, DEFAULT_TIME_OF_DAY));
ShowFlags(GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_SHOW_FLAGS, DEFAULT_SHOW_FLAGS));
EnableCompass(GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_COMPASS, DEFAULT_COMPASS));
SetMusicTrack(GetConfigValue(CONFIG_AUDIO_SECTION, CONFIG_MUSIC_TRACK, DEFAULT_MUSIC_TRACK));
SetMusicVolume(GetConfigValue(CONFIG_AUDIO_SECTION, CONFIG_MUSIC_VOLUME, DEFAULT_MUSIC_VOLUME));
SetCompass(GetConfigValue(CONFIG_UI_SECTION, CONFIG_COMPASS, DEFAULT_COMPASS));
}
void CryptoCityUrho3D::MoveCameraToStartPosition()
@ -3484,14 +3484,6 @@ void CryptoCityUrho3D::HandleShowFlags(StringHash eventType, VariantMap& eventDa
eventData[ShowFlags::P_SHOW] = GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_SHOW_FLAGS, DEFAULT_SHOW_FLAGS);
}
void CryptoCityUrho3D::HandleEnableCompass(StringHash eventType, VariantMap& eventData)
{
if (eventData.Contains(EnableCompass::P_ENABLE))
EnableCompass(SetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_COMPASS, eventData[EnableCompass::P_ENABLE].GetBool()));
else
eventData[EnableCompass::P_ENABLE] = GetConfigValue(CONFIG_GRAPHICS_SECTION, CONFIG_COMPASS, DEFAULT_COMPASS);
}
void CryptoCityUrho3D::HandleGraphicsMode(StringHash eventType, VariantMap& eventData)
{
if (eventData.Contains(GraphicsMode::P_MONITOR))
@ -3550,6 +3542,14 @@ void CryptoCityUrho3D::HandleIncludeUnmatchedTradesInQueuedComands(StringHash ev
eventData[IncludeUnmatchedTradesInQueuedCommands::P_INCLUDE] = GetConfigValue(CONFIG_UI_SECTION, CONFIG_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS, DEFAULT_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS);
}
void CryptoCityUrho3D::HandleCompass(StringHash eventType, VariantMap& eventData)
{
if (eventData.Contains(Compass::P_COMPASS))
SetCompass(SetConfigValue(CONFIG_UI_SECTION, CONFIG_COMPASS, eventData[Compass::P_COMPASS].GetInt()));
else
eventData[Compass::P_COMPASS] = GetConfigValue(CONFIG_UI_SECTION, CONFIG_COMPASS, DEFAULT_COMPASS);
}
void CryptoCityUrho3D::HandleResearch(StringHash eventType, VariantMap& eventData)
{
cryptonote::cc_command_research_t cmd;

40
src/game/ui-options.cc
View File

@ -172,9 +172,9 @@ UIOptionsDialog::UIOptionsDialog(Context *ctx):
decTimeOfDayWidget = GetWidgetByIDAndType<TBButton>(TBIDC("dec-time-of-day"));
fontSizeWidget = GetWidgetByIDAndType<TBInlineSelect>(TBIDC("font-size"));
showFlagsWidget = GetWidgetByIDAndType<TBCheckBox>(TBIDC("show-hide-flags"));
compassWidget = GetWidgetByIDAndType<TBCheckBox>(TBIDC("compass"));
musicTrackWidget = GetWidgetByIDAndType<TBSelectDropdown>(TBIDC("music-track"));
musicVolumeWidget = GetWidgetByIDAndType<TBSlider>(TBIDC("music-volume"));
compassWidget = GetWidgetByIDAndType<TBSelectDropdown>(TBIDC("compass"));
controlsListWidget = GetWidgetByIDAndType<TBSelectList>(TBIDC("controls"));
@ -331,10 +331,6 @@ void UIOptionsDialog::Configure()
SendEvent(E_OPTIONS_SHOW_FLAGS, newEventData);
showFlagsWidget->SetValue(newEventData[OptionsShowFlags::P_SHOW].GetBool());
newEventData = {};
SendEvent(E_OPTIONS_ENABLE_COMPASS, newEventData);
compassWidget->SetValue(newEventData[OptionsEnableCompass::P_ENABLE].GetBool());
newEventData = {};
SendEvent(E_OPTIONS_MUSIC_TRACK, newEventData);
musicTrackWidget->SetValue(-1);
@ -351,6 +347,18 @@ void UIOptionsDialog::Configure()
SendEvent(E_OPTIONS_MUSIC_VOLUME, newEventData);
musicVolumeWidget->SetValue(newEventData[OptionsMusicVolume::P_VOLUME].GetFloat() * musicVolumeWidget->GetMaxValue());
newEventData = {};
SendEvent(E_OPTIONS_COMPASS, newEventData);
compassWidget->SetValue(-1);
for (int i = 0; i < compassWidget->GetDefaultSource()->GetNumItems(); ++i)
{
if (compassWidget->GetDefaultSource()->GetItemID(i) == (uint32_t)newEventData[OptionsCompass::P_COMPASS].GetInt())
{
compassWidget->SetValue(i);
break;
}
}
FillControls();
}
@ -515,13 +523,6 @@ void UIOptionsDialog::HandleShowFlagsChanged(StringHash eventType, VariantMap& e
SendEvent(E_OPTIONS_SHOW_FLAGS, newEventData);
}
void UIOptionsDialog::HandleCompassChanged(StringHash eventType, VariantMap& eventData)
{
VariantMap newEventData;
newEventData[OptionsEnableCompass::P_ENABLE] = (bool)compassWidget->GetValue();
SendEvent(E_OPTIONS_ENABLE_COMPASS, newEventData);
}
void UIOptionsDialog::HandleInvertMouseY(StringHash eventType, VariantMap& eventData)
{
TBWidgetEvent *ev = (TBWidgetEvent*)eventData[TBWidgetEventNamespace::P_WIDGET_EVENT].GetVoidPtr();
@ -565,6 +566,18 @@ void UIOptionsDialog::HandleMusicSkipTrack(StringHash eventType, VariantMap& eve
SendEvent(E_OPTIONS_MUSIC_SKIP_TRACK, newEventData);
}
void UIOptionsDialog::HandleCompass(StringHash eventType, VariantMap& eventData)
{
TBWidgetEvent *ev = (TBWidgetEvent*)eventData[TBWidgetEventNamespace::P_WIDGET_EVENT].GetVoidPtr();
TBSelectDropdown *w = TBSafeCast<TBSelectDropdown>(ev->target);
if (w->GetValue() < 0)
return;
const TBID id = w->GetDefaultSource()->GetItem(w->GetValue())->id;
VariantMap newEventData;
newEventData[OptionsCompass::P_COMPASS] = id;
SendEvent(E_OPTIONS_COMPASS, newEventData);
}
void UIOptionsDialog::HandleClose(StringHash eventType, VariantMap& eventData)
{
VariantMap& newEventData = GetEventDataMap();
@ -599,13 +612,14 @@ void UIOptionsDialog::HandleTBMessage(StringHash eventType, VariantMap& eventDat
CONNECT("show-hide-flags", HandleShowFlagsChanged);
CONNECT("monitor", HandleMonitorChanged);
CONNECT("resolution", HandleResolutionChanged);
CONNECT("compass", HandleCompassChanged);
CONNECT("invert-mouse-y", HandleInvertMouseY);
CONNECT("mouse-sensitivity", HandleMouseSensitivity);
CONNECT("music-track", HandleMusicTrack);
CONNECT("music-volume", HandleMusicVolume);
CONNECT("compass", HandleCompass);
}
#undef CONNECT

5
src/game/ui-options.h
View File

@ -39,6 +39,7 @@ URHO3D_EVENT(E_OPTIONS_CONTROLS_CHANGED, OptionsControlsChanged) {}
URHO3D_EVENT(E_OPTIONS_MUSIC_TRACK, OptionsMusicTrack) { URHO3D_PARAM(P_TRACK, Track); }
URHO3D_EVENT(E_OPTIONS_MUSIC_VOLUME, OptionsMusicVolume) { URHO3D_PARAM(P_VOLUME, Volume); }
URHO3D_EVENT(E_OPTIONS_MUSIC_SKIP_TRACK, OptionsMusicSkipTrack) { }
URHO3D_EVENT(E_OPTIONS_COMPASS, OptionsCompass) { URHO3D_PARAM(P_COMPASS, Compass); }
class UIOptionsDialog: public UITBWindow
{
@ -67,12 +68,12 @@ private:
void HandleFontSizeChanged(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleResetControls(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleShowFlagsChanged(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleCompassChanged(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleInvertMouseY(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleMouseSensitivity(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleMusicTrack(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleMusicVolume(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleMusicSkipTrack(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleCompass(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleTBMessage(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
private:
@ -94,9 +95,9 @@ private:
tb::TBButton *decTimeOfDayWidget;
tb::TBInlineSelect *fontSizeWidget;
tb::TBCheckBox *showFlagsWidget;
tb::TBCheckBox *compassWidget;
tb::TBSelectDropdown *musicTrackWidget;
tb::TBSlider *musicVolumeWidget;
tb::TBSelectDropdown *compassWidget;
tb::TBGenericStringItemSource monitor_source;
tb::TBGenericStringItemSource resolution_source;

54
src/game/ui-urho3d.cc
View File

@ -61,8 +61,8 @@
#include "ui-urho3d.h"
#define WALLET_BALANCE_TEXT_SCALE .8f
#define COMPASS_SIZE 140
#define COMPASS_CENTER_OFFSET ((COMPASS_SIZE) * 2 / 3.0f)
#define COMPASS_SIZE(size) ((int)(140 * (size)))
#define COMPASS_CENTER_OFFSET(size) ((COMPASS_SIZE(size)) * 2 / 3.0f)
using namespace Urho3D;
using namespace tb;
@ -303,18 +303,31 @@ void UIUrho3D::CreateCompass()
compass_needle = root->CreateChild<Sprite>();
compass_needle->SetTexture(cache->GetResource<Texture2D>("UI/compass-needle.png"));
compass_frame->SetPosition({COMPASS_CENTER_OFFSET, root->GetHeight() - COMPASS_CENTER_OFFSET});
compass_frame->SetSize({COMPASS_SIZE, COMPASS_SIZE});
compass_frame->SetHotSpot({COMPASS_SIZE / 2, COMPASS_SIZE / 2});
compass_needle->SetPosition({COMPASS_CENTER_OFFSET, root->GetHeight() - COMPASS_CENTER_OFFSET});
compass_needle->SetSize({COMPASS_SIZE, COMPASS_SIZE});
compass_needle->SetHotSpot({COMPASS_SIZE / 2, COMPASS_SIZE / 2});
compass_changed = true;
}
void UIUrho3D::UpdateCompass(float timeStep, const Vector3 &view_direction)
{
compass_needle->SetPriority(-100);
compass_frame->SetPriority(-101);
if (compass_changed)
{
compass_needle->SetPriority(-100);
compass_frame->SetPriority(-101);
// re-position/size compass
float size = 1.0f;
if (compass_type == TBIDC("compass-large")) size = 1.25f; else if (compass_type == TBIDC("compass-small")) size = 0.75f;
auto* graphics = GetSubsystem<Graphics>();
const int width = graphics->GetWidth() * size;
const int height = graphics->GetHeight() * size;
compass_frame->SetPosition({COMPASS_CENTER_OFFSET(size), graphics->GetHeight() - COMPASS_CENTER_OFFSET(size)});
compass_frame->SetSize({COMPASS_SIZE(size), COMPASS_SIZE(size)});
compass_frame->SetHotSpot({COMPASS_SIZE(size) / 2, COMPASS_SIZE(size) / 2});
compass_needle->SetPosition({COMPASS_CENTER_OFFSET(size), graphics->GetHeight() - COMPASS_CENTER_OFFSET(size)});
compass_needle->SetSize({COMPASS_SIZE(size), COMPASS_SIZE(size)});
compass_needle->SetHotSpot({COMPASS_SIZE(size) / 2, COMPASS_SIZE(size) / 2});
compass_frame->SetVisible(compass_type != TBIDC("compass-off"));
compass_needle->SetVisible(compass_type != TBIDC("compass-off"));
}
Vector3 dir = view_direction;
dir.y_ = 0.0f;
@ -422,12 +435,6 @@ void UIUrho3D::RemoveQueuedCommand(const std::string &txid)
queued_commands_except_unmatched_trades.erase(txid);
}
void UIUrho3D::EnableCompass(bool enable)
{
compass_frame->SetVisible(enable);
compass_needle->SetVisible(enable);
}
void UIUrho3D::Update(float timeStep, uint32_t mouse_x, uint32_t mouse_y, uint32_t sx0, uint32_t sy0, uint32_t sx1, uint32_t sy1, bool showingFlags, bool building, unsigned num_unread_chat_lines, bool highlight_chat, const std::shared_ptr<GameWallet> &w, const Vector3 &view_direction, const boost::optional<std::tuple<uint32_t, std::vector<uint16_t>, std::vector<std::vector<uint8_t>>>> &flagUnderConstruction)
{
const Map *map = &gameState->map;
@ -1296,9 +1303,6 @@ void UIUrho3D::ShowOptions()
SubscribeToEvent(optionsDialog, E_OPTIONS_SHOW_FLAGS, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_SHOW_FLAGS, eventData);
});
SubscribeToEvent(optionsDialog, E_OPTIONS_ENABLE_COMPASS, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_ENABLE_COMPASS, eventData);
});
SubscribeToEvent(optionsDialog, E_OPTIONS_CONTROLS_CHANGED, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_CONTROLS_CHANGED, eventData);
});
@ -1311,6 +1315,9 @@ void UIUrho3D::ShowOptions()
SubscribeToEvent(optionsDialog, E_OPTIONS_MUSIC_SKIP_TRACK, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_MUSIC_SKIP_TRACK, eventData);
});
SubscribeToEvent(optionsDialog, E_OPTIONS_COMPASS, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_COMPASS, eventData);
});
optionsDialog->Configure();
}
@ -1969,8 +1976,7 @@ void UIUrho3D::HandleResized(StringHash eventType, VariantMap& eventData)
queuedCommandsNotificationWidget->SetRect(rect);
// re-center compass
compass_frame->SetPosition({COMPASS_CENTER_OFFSET, height - COMPASS_CENTER_OFFSET});
compass_needle->SetPosition({COMPASS_CENTER_OFFSET, height - COMPASS_CENTER_OFFSET});
compass_changed = true;
}
void UIUrho3D::NotifyEditMode(EditMode mode)
@ -2047,6 +2053,12 @@ void UIUrho3D::SetCameraType(TBID type)
}
}
void UIUrho3D::SetCompassType(TBID type)
{
compass_type = type;
compass_changed = true;
}
void UIUrho3D::HandleFlagInfo(StringHash eventType, VariantMap& eventData)
{
if (lastUpdateEventsDialog)

7
src/game/ui-urho3d.h
View File

@ -117,7 +117,6 @@ URHO3D_EVENT(E_CRYPTOCITY_ENABLE_HORIZON, EnableHorizon) { URHO3D_PARAM(P_ENABLE
URHO3D_EVENT(E_CRYPTOCITY_ENABLE_DYNAMIC_SKY, EnableDynamicSky) { URHO3D_PARAM(P_ENABLE, Enable); }
URHO3D_EVENT(E_CRYPTOCITY_TIME_OF_DAY, TimeOfDay) { URHO3D_PARAM(P_TIME_OF_DAY, TimeOfDay); }
URHO3D_EVENT(E_CRYPTOCITY_SHOW_FLAGS, ShowFlags) { URHO3D_PARAM(P_SHOW, Show); /* bool */ }
URHO3D_EVENT(E_CRYPTOCITY_ENABLE_COMPASS, EnableCompass) { URHO3D_PARAM(P_ENABLE, Enable); }
URHO3D_EVENT(E_CRYPTOCITY_SET_NODE_CONFIG, SetNodeConfig) { URHO3D_PARAM(P_ADDRESS, Address); URHO3D_PARAM(P_PORT, Port); URHO3D_PARAM(P_SUCCESS, Success); }
URHO3D_EVENT(E_CRYPTOCITY_FOUND_CITY, FoundCity) { URHO3D_PARAM(P_ORIGIN_X, OriginX); URHO3D_PARAM(P_ORIGIN_Y, OriginY); URHO3D_PARAM(P_NAME, Name); URHO3D_PARAM(P_COST, Cost); }
URHO3D_EVENT(E_CRYPTOCITY_TRAVEL_TO_CITY, TravelToCity) { URHO3D_PARAM(P_CITY, City); }
@ -155,6 +154,7 @@ URHO3D_EVENT(E_CRYPTOCITY_MUSIC_VOLUME, MusicVolume) { URHO3D_PARAM(P_VOLUME, Vo
URHO3D_EVENT(E_CRYPTOCITY_MUSIC_SKIP_TRACK, MusicSkipTrack) { }
URHO3D_EVENT(E_CRYPTOCITY_ADD_CITY_SPECIALIZATION, AddCitySpecialization) { URHO3D_PARAM(P_SPECIALIZATION, Specialization); }
URHO3D_EVENT(E_CRYPTOCITY_INCLUDE_UNMATCHED_TRADES_IN_QUEUED_COMMANDS, IncludeUnmatchedTradesInQueuedCommands) { URHO3D_PARAM(P_INCLUDE, Include); }
URHO3D_EVENT(E_CRYPTOCITY_COMPASS, Compass) { URHO3D_PARAM(P_COMPASS, Compass); }
class UIUrho3D: public Urho3D::UIElement
{
@ -170,13 +170,13 @@ public:
void ShowPlayerInfo(uint32_t player_id);
void AddQueuedCommand(const std::string &txid, const cryptonote::cc_command_t &cmd);
void RemoveQueuedCommand(const std::string &txid);
void EnableCompass(bool enable);
void Configure();
void OpenSelectMaterial(uint16_t variant);
void CloseSelectMaterial(bool send_result);
bool IsSelectMaterialOpen() const;
void SetCameraType(tb::TBID type);
void SetCompassType(tb::TBID type);
private:
void CreatePlayerWindow();
@ -405,6 +405,9 @@ private:
UISelectMaterial *selectMaterial;
epee::math_helper::once_a_time_seconds<2> m_mining_checker;
tb::TBID compass_type;
bool compass_changed;
};
#endif