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

game: make the terrain cache size a user option (including disabled)

Browse Source
This commit is contained in:
Crypto City 2021-09-06 13:37:55 +00:00
parent fd90c0ca84
commit a079220af6
8 changed files with 105 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,6 +12,7 @@ TBTabContainer
TBButton: text: "Audio"
TBButton: text: "UI"
TBButton: text: "Node"
TBButton: text: "Disk cache"
TBButton: text: "Tutorial"
TBLayout: axis: y, distribution-position: "left top", distribution: "gravity"
@ -196,6 +197,14 @@ TBTabContainer
TBSeparator
TBButton: id: "restart-daemon", text: "Set daemon configuration"
TBLayout: axis: y, distribution-position: "center", distribution: "gravity"
TBTextField: text: "Terrain cache size:"
TBLayout: axis: x, gravity: "left right", size: "available", distribution: "available"
TBTextField: gravity: "left"
TBSlider: id: "terrain-cache-size", min: 0, max: 146, step: 1, gravity: "left right"
TBTextField: id: "terrain-cache-size-text"
TBTextField: gravity: "right"
TBLayout: axis: y, distribution-position: "center", distribution: "gravity"
TBClickLabel: text: "Enable tutorial"
TBCheckBox: id: "enable-tutorial"

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

@ -156,6 +156,7 @@ const float TOUCH_SENSITIVITY = 2.0f;
#define CONFIG_AUDIO_SECTION "audio"
#define CONFIG_UI_SECTION "ui"
#define CONFIG_NODE_SECTION "node"
#define CONFIG_DISK_CACHE_SECTION "disk-cache"
#define CONFIG_TUTORIAL_SECTION "tutorial"
#define CONFIG_TUTORIAL_STATE_SECTION "tutorial-state"
@ -219,6 +220,8 @@ const float TOUCH_SENSITIVITY = 2.0f;
#define DEFAULT_DAEMON_DATA_DIR String("")
#define CONFIG_DAEMON_LOG "daemon-log"
#define DEFAULT_DAEMON_LOG String("")
#define CONFIG_TERRAIN_CACHE_SIZE "terrain-cache-size"
#define DEFAULT_TERRAIN_CACHE_SIZE 256
#define CONFIG_ENABLE_TUTORIAL "enable-tutorial"
#define DEFAULT_ENABLE_TUTORIAL true
@ -408,6 +411,7 @@ public:
void HandleAudioPlayingTrack(StringHash eventType, VariantMap& eventData);
void HandleControlDaemon(StringHash eventType, VariantMap& eventData);
void HandleRestartDaemon(StringHash eventType, VariantMap& eventData);
void HandleTerrainCacheSize(StringHash eventType, VariantMap& eventData);
void HandleEnableTutorial(StringHash eventType, VariantMap& eventData);
void HandleResetTutorial(StringHash eventType, VariantMap& eventData);
void HandleGetTutorials(StringHash eventType, VariantMap& eventData);
@ -566,6 +570,7 @@ private:
template<typename T> T GetPotential(const std::shared_ptr<cc::cc_potential_state_t> &state, uint32_t cached_index, const std::function<T(uint32_t, uint32_t)> &f, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1);
uint8_t GetPotential(const std::shared_ptr<cc::cc_potential_state_t> &state, uint8_t potential, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1);
void SetSnowfallStrength(float s);
void SetTerrainCacheSize(uint64_t bytes);
template<typename T> T GetConfigValue(const String &filename, SharedPtr<JSONFile> &config, const char *section, const char *key, const T &default_value);
template<typename T> T GetConfigValue(const char *section, const char *key, const T &default_value);
@ -994,6 +999,7 @@ void CryptoCityUrho3D::Start()
if (!terrain_dir.Empty())
{
SetTerrainCacheDirectory(terrain_dir.CString());
SetTerrainCacheSize(GetConfigValue(CONFIG_DISK_CACHE_SECTION, CONFIG_TERRAIN_CACHE_SIZE, DEFAULT_TERRAIN_CACHE_SIZE));
cc::set_terrain_cache_funcs(&SetCachedTerrain, &GetCachedTerrain);
}
@ -1412,6 +1418,7 @@ void CryptoCityUrho3D::SetupUI()
SubscribeToEvent(ui, E_CRYPTOCITY_ALLOW_STYLING, URHO3D_HANDLER(CryptoCityUrho3D, HandleAllowStyling));
SubscribeToEvent(ui, E_CRYPTOCITY_CONTROL_DAEMON, URHO3D_HANDLER(CryptoCityUrho3D, HandleControlDaemon));
SubscribeToEvent(ui, E_CRYPTOCITY_RESTART_DAEMON, URHO3D_HANDLER(CryptoCityUrho3D, HandleRestartDaemon));
SubscribeToEvent(ui, E_CRYPTOCITY_TERRAIN_CACHE_SIZE, URHO3D_HANDLER(CryptoCityUrho3D, HandleTerrainCacheSize));
SubscribeToEvent(ui, E_CRYPTOCITY_ENABLE_TUTORIAL, URHO3D_HANDLER(CryptoCityUrho3D, HandleEnableTutorial));
SubscribeToEvent(ui, E_CRYPTOCITY_RESET_TUTORIAL, URHO3D_HANDLER(CryptoCityUrho3D, HandleResetTutorial));
SubscribeToEvent(ui, E_CRYPTOCITY_GET_TUTORIALS, URHO3D_HANDLER(CryptoCityUrho3D, HandleGetTutorials));
@ -2038,6 +2045,11 @@ void CryptoCityUrho3D::ShowFlags(bool enable)
cityMesh->setDisplayMode(enable ? DisplayModeShowFlags : DisplayModeNormal);
}
void CryptoCityUrho3D::SetTerrainCacheSize(uint64_t megabytes)
{
::SetTerrainCacheSize(megabytes * 1024 * 1024);
}
bool CryptoCityUrho3D::SetGraphicsMode(int monitor, int width, int height, int refresh_rate)
{
Graphics *graphics = GetSubsystem<Graphics>();
@ -5914,6 +5926,14 @@ void CryptoCityUrho3D::HandleRestartDaemon(StringHash eventType, VariantMap& eve
daemon_controller->Configure(data_dir, log);
}
void CryptoCityUrho3D::HandleTerrainCacheSize(StringHash eventType, VariantMap& eventData)
{
if (eventData.Contains(TerrainCacheSize::P_SIZE))
SetTerrainCacheSize(SetConfigValue(CONFIG_DISK_CACHE_SECTION, CONFIG_TERRAIN_CACHE_SIZE, eventData[TerrainCacheSize::P_SIZE].GetUInt()));
else
eventData[TerrainCacheSize::P_SIZE] = GetConfigValue(CONFIG_DISK_CACHE_SECTION, CONFIG_TERRAIN_CACHE_SIZE, DEFAULT_TERRAIN_CACHE_SIZE);
}
void CryptoCityUrho3D::HandleEnableTutorial(StringHash eventType, VariantMap& eventData)
{
if (eventData.Contains(EnableTutorial::P_ENABLE))

25
src/game/terrain-cache.cc
View File

@ -8,9 +8,9 @@
#include "terrain-cache.h"
#define COMPRESSION_RATIO 4
#define MAX_TERRAIN_CACHE_SIZE 256
static std::string cache_dir;
static uint64_t terrain_cache_size = 0;
static std::string get_filename_for_tag(const std::string &tag)
{
@ -18,13 +18,20 @@ static std::string get_filename_for_tag(const std::string &tag)
return filename;
}
void SetTerrainCacheSize(uint64_t bytes)
{
terrain_cache_size = bytes;
}
static void prune_terrain_files()
{
std::vector<std::pair<boost::filesystem::path, uint64_t>> found_files;
typedef std::tuple<boost::filesystem::path, uint64_t, uint64_t> record_t;
std::vector<record_t> found_files;
boost::system::error_code ec;
const boost::filesystem::directory_iterator end_itr;
const boost::filesystem::path parent_path = cache_dir;
const boost::filesystem::path extension(".tfterrain");
uint64_t total_size = 0;
for (boost::filesystem::directory_iterator iter(parent_path); iter != end_itr; ++iter)
{
if (iter->path().extension() != extension)
@ -34,13 +41,16 @@ static void prune_terrain_files()
if (stat(iter->path().string().c_str(), &statbuf) < 0)
continue;
const uint64_t timestamp = statbuf.st_atim.tv_sec;
const uint64_t bytes = statbuf.st_size;
#else
const uint64_t timestamp = boost::filesystem::last_write_time(iter->path(), ec);
const uint64_t bytes = boost::filesystem::file_size(iter->path(), ec);
#endif
found_files.push_back(std::make_pair(iter->path(), timestamp));
found_files.push_back(std::make_tuple(iter->path(), bytes, timestamp));
total_size += bytes;
}
std::sort(found_files.begin(), found_files.end(), [](const std::pair<boost::filesystem::path, uint64_t> &e0, const std::pair<boost::filesystem::path, uint64_t> &e1){
return e0.second > e1.second;
std::sort(found_files.begin(), found_files.end(), [](const record_t &e0, const record_t &e1){
return std::get<2>(e0) > std::get<2>(e1);
});
while (1)
@ -48,9 +58,10 @@ static void prune_terrain_files()
if (found_files.empty())
break;
const boost::filesystem::space_info si = boost::filesystem::space(cache_dir, ec);
if (si.available > 2ull * 1024 * 1024 * 1024 && found_files.size() <= MAX_TERRAIN_CACHE_SIZE)
if (si.available > 2ull * 1024 * 1024 * 1024 && total_size <= terrain_cache_size)
break;
boost::filesystem::remove(found_files.back().first, ec);
boost::filesystem::remove(std::get<0>(found_files.back()), ec);
total_size -= std::get<1>(found_files.back());
found_files.pop_back();
}

1
src/game/terrain-cache.h
View File

@ -8,3 +8,4 @@
void SetTerrainCacheDirectory(const std::string &dir);
void SetCachedTerrain(const std::string&, const std::shared_ptr<uint16_t[]>&, size_t);
std::shared_ptr<uint16_t[]> GetCachedTerrain(const std::string&, size_t);
void SetTerrainCacheSize(uint64_t bytes);

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

@ -14,6 +14,7 @@
#include <tb/tb_toggle_container.h>
#include <tb/tb_widgets_reader.h>
#include "misc_language.h"
#include "common/util.h"
#include "cc/cc_config.h"
#include "cc/cc.h"
#include "controls.h"
@ -23,6 +24,24 @@
using namespace Urho3D;
using namespace tb;
static uint32_t get_terrain_cache_size_from_value(uint32_t value, uint32_t max_value)
{
if (value == 0)
return 0;
uint32_t size = (value + 8) * (value + 8) / 8;
if (value == max_value)
size = 3072;
return size;
}
static uint32_t get_terrain_cache_size_from_megabytes(uint32_t megabytes, uint32_t max_value)
{
uint32_t value = 0;
while (value < max_value && megabytes > get_terrain_cache_size_from_value(value, max_value))
++value;
return value;
}
UIOptionsDialog::ControlsWidget::ControlsWidget(UIOptionsDialog::ControlsItem *item, ControlsSource *source, tb::TBSelectItemViewer *source_viewer, int index):
m_source(source),
m_source_viewer(source_viewer),
@ -224,6 +243,8 @@ UIOptionsDialog::UIOptionsDialog(Context *ctx):
enableTutorialWidget = GetWidgetByIDAndType<TBCheckBox>(TBIDC("enable-tutorial"));
notificationLifetimeWidget = GetWidgetByIDAndType<TBInlineSelect>(TBIDC("notification-lifetime"));
selectionInfoListWidget = GetWidgetByIDAndType<TBSelectDropdown>(TBIDC("selection-info"));
terrainCacheSizeWidget = GetWidgetByIDAndType<TBSlider>(TBIDC("terrain-cache-size"));
terrainCacheSizeTextWidget = GetWidgetByIDAndType<TBTextField>(TBIDC("terrain-cache-size-text"));
controlsListWidget = GetWidgetByIDAndType<TBSelectList>(TBIDC("controls"));
tutorialListWidget = GetWidgetByIDAndType<TBSelectList>(TBIDC("tutorials"));
@ -553,9 +574,18 @@ void UIOptionsDialog::Configure()
newEventData = {};
SendEvent(E_OPTIONS_SET_SELECTION_INFO, newEventData);
ConfigureSelectionInfo(newEventData[OptionsSetSelectionInfo::P_ENABLED].GetString());
newEventData = {};
SendEvent(E_OPTIONS_TERRAIN_CACHE_SIZE, newEventData);
const uint32_t megabytes = newEventData[OptionsTerrainCacheSize::P_SIZE].GetUInt();
terrainCacheSizeWidget->SetValue(get_terrain_cache_size_from_megabytes(megabytes, terrainCacheSizeWidget->GetMaxValue()));
if (megabytes > 0)
terrainCacheSizeTextWidget->SetText(tools::get_human_readable_bytes(megabytes * 1024 * 1024).c_str());
else
terrainCacheSizeTextWidget->SetText("disabled");
FillTutorials();
ConfigureSelectionInfo(newEventData[OptionsSetSelectionInfo::P_ENABLED].GetString());
configuring = false;
@ -1016,6 +1046,21 @@ void UIOptionsDialog::HandleSelectionInfoChanged(StringHash eventType, VariantMa
SendEvent(E_OPTIONS_SET_SELECTION_INFO, newEventData);
}
void UIOptionsDialog::HandleTerrainCacheSize(StringHash eventType, VariantMap& eventData)
{
TBWidgetEvent *ev = (TBWidgetEvent*)eventData[TBWidgetEventNamespace::P_WIDGET_EVENT].GetVoidPtr();
TBSlider *slider = TBSafeCast<TBSlider>(ev->target);
VariantMap newEventData;
uint32_t megabytes = get_terrain_cache_size_from_value(slider->GetValue(), slider->GetMaxValue());
if (megabytes > 0)
terrainCacheSizeTextWidget->SetText(tools::get_human_readable_bytes(megabytes * 1024 * 1024).c_str());
else
terrainCacheSizeTextWidget->SetText("disabled");
newEventData[OptionsTerrainCacheSize::P_SIZE] = megabytes;
SendEvent(E_OPTIONS_TERRAIN_CACHE_SIZE, newEventData);
}
void UIOptionsDialog::HandleClose(StringHash eventType, VariantMap& eventData)
{
VariantMap& newEventData = GetEventDataMap();
@ -1079,6 +1124,8 @@ void UIOptionsDialog::HandleTBMessage(StringHash eventType, VariantMap& eventDat
CONNECT("control-daemon", HandleControlDaemon);
CONNECT("terrain-cache-size", HandleTerrainCacheSize);
CONNECT("enable-tutorial", HandleEnableTutorial);
}

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

@ -7,6 +7,7 @@
#include <Urho3D/Container/Ptr.h>
#include <Urho3D/Math/StringHash.h>
#include <tb/tb_select_item.h>
#include <tb/tb_widgets_common.h>
#include "cc/cc_config.h"
#include "controls.h"
#include "selection-info.h"
@ -63,6 +64,7 @@ URHO3D_EVENT(E_OPTIONS_SHOW_TUTORIAL, OptionsShowTutorial) { URHO3D_PARAM(P_TAG,
URHO3D_EVENT(E_OPTIONS_NOTIFICATION_LIFETIME, OptionsNotificationLifetime) { URHO3D_PARAM(P_LIFETIME, Lifetime); }
URHO3D_EVENT(E_OPTIONS_SHOW_NOTIFICATION_HISTORY, OptionsShowNotificationHistory) { }
URHO3D_EVENT(E_OPTIONS_SET_SELECTION_INFO, OptionsSetSelectionInfo) { URHO3D_PARAM(P_ENABLED, Enabled); }
URHO3D_EVENT(E_OPTIONS_TERRAIN_CACHE_SIZE, OptionsTerrainCacheSize) { URHO3D_PARAM(P_SIZE, Size); }
class UIOptionsDialog: public UITBWindow
{
@ -116,6 +118,7 @@ private:
void HandleNotificationLifetimeChanged(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleShowNotificationHistory(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleSelectionInfoChanged(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleTerrainCacheSize(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
void HandleTBMessage(Urho3D::StringHash eventType, Urho3D::VariantMap& eventData);
private:
@ -161,6 +164,8 @@ private:
tb::TBSelectList *tutorialListWidget;
tb::TBInlineSelect *notificationLifetimeWidget;
tb::TBSelectDropdown *selectionInfoListWidget;
tb::TBSlider *terrainCacheSizeWidget;
tb::TBTextField *terrainCacheSizeTextWidget;
tb::TBGenericStringItemSource monitor_source;
tb::TBGenericStringItemSource resolution_source;

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

@ -2073,6 +2073,9 @@ void UIUrho3D::ShowOptions()
SubscribeToEvent(optionsDialog, E_OPTIONS_SET_SELECTION_INFO, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_SET_SELECTION_INFO, eventData);
});
SubscribeToEvent(optionsDialog, E_OPTIONS_TERRAIN_CACHE_SIZE, [this](StringHash eventType, VariantMap& eventData) {
SendEvent(E_CRYPTOCITY_TERRAIN_CACHE_SIZE, eventData);
});
optionsDialog->Configure();
SendTutorialTrigger("screen-options");
}

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

@ -227,6 +227,7 @@ URHO3D_EVENT(E_CRYPTOCITY_RESET_TUTORIAL, ResetTutorial) { }
URHO3D_EVENT(E_CRYPTOCITY_GET_TUTORIALS, GetTutorials) { URHO3D_PARAM(P_TUTORIALS, Tutorials); }
URHO3D_EVENT(E_CRYPTOCITY_NOTIFICATION_LIFETIME, NotificationLifetime) { URHO3D_PARAM(P_LIFETIME, Lifetime); }
URHO3D_EVENT(E_CRYPTOCITY_SET_SELECTION_INFO, SetSelectionInfo) { URHO3D_PARAM(P_ENABLED, Enabled); }
URHO3D_EVENT(E_CRYPTOCITY_TERRAIN_CACHE_SIZE, TerrainCacheSize) { URHO3D_PARAM(P_SIZE, Size); }
class UIUrho3D: public Urho3D::UIElement
{