mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2026-10-02 19:03:43 +00:00
1a2758feab
Brighter icons: a world light, a fill from the camera, a highlight, exposure and contrast; with the defaults the icons' mean luminance matches the game's own model icons (118 against 120 on a scratch set). Every icon parameter is listed once (UgcIconParams: key, setting, range, default); the settings, the dashboard's settings entries and the icon editor come from that list. Presets per kind (player models, each car or rocket build type from ModularBuildComponent) and overrides per model or module combination are in ugc_icon_settings. Saved models wait ugc_debounce_seconds (sharedconfig) after the owner's last save before they're made (ugc.process_after); a client asking for one, the owner leaving the world or a reset ends the wait. Cars and rockets: one icon per combination of modules (sorted LOTs), shared by every build of it; builds of a combination made already are marked made right away, the client's per-blueprint downloads serve the shared files. The dashboard can delete one item's files, purge by filter or all, preview icons with any values on the UGC server (/admin routes, master password), save presets and overrides, and draw a kind's icons again (icons only). Migrations dlu/mysql/86 and dlu/sqlite/69. Not done yet: the dashboard editor's lighting controls in the page script (routes are there), docs for it, the empty-model state, /ugc?item= links, the shared fetch helper; the storage size and property loading bugs are next. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
73 lines
2.6 KiB
C++
73 lines
2.6 KiB
C++
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
/**
|
|
* Small pure decisions about UGC shared by the worlds, the UGC server and the dashboard (docs/UgcServer.md).
|
|
*/
|
|
namespace UgcModularKey {
|
|
// The module LOTs of a ugc_modular_build.ldf_config ("1:4713+1:4714+1:4715", also with ';' or ',' between)
|
|
inline std::vector<uint32_t> Lots(std::string_view ldf) {
|
|
std::vector<uint32_t> lots;
|
|
size_t start = 0;
|
|
while (start <= ldf.size()) {
|
|
size_t end = ldf.find_first_of("+;,", start);
|
|
if (end == std::string_view::npos) end = ldf.size();
|
|
auto item = ldf.substr(start, end - start);
|
|
if (const auto colon = item.find(':'); colon != std::string_view::npos) item = item.substr(colon + 1);
|
|
while (!item.empty() && item.front() == ' ') item.remove_prefix(1);
|
|
while (!item.empty() && item.back() == ' ') item.remove_suffix(1);
|
|
uint32_t value = 0;
|
|
bool digits = !item.empty() && item.size() <= 9;
|
|
for (const char c : item) {
|
|
if (c < '0' || c > '9') {
|
|
digits = false;
|
|
break;
|
|
}
|
|
value = value * 10 + static_cast<uint32_t>(c - '0');
|
|
}
|
|
if (digits && value != 0) lots.push_back(value);
|
|
start = end + 1;
|
|
}
|
|
return lots;
|
|
}
|
|
|
|
/**
|
|
* The combination of modules a build is made of, the same however its ldf_config is written: its LOTs sorted
|
|
* and joined by '-' ("4713-4714-4715"). Each module LOT belongs to one slot of one build type, so the set of LOTs
|
|
* says everything about how the build looks. Empty when there are no modules.
|
|
*/
|
|
inline std::string Normalize(std::string_view ldf) {
|
|
auto lots = Lots(ldf);
|
|
std::sort(lots.begin(), lots.end());
|
|
lots.erase(std::unique(lots.begin(), lots.end()), lots.end());
|
|
std::string key;
|
|
for (const auto lot : lots) key += (key.empty() ? "" : "-") + std::to_string(lot);
|
|
return key;
|
|
}
|
|
|
|
// The id a combination's files are stored under (FNV-1a of the key, positive, never 0)
|
|
inline int64_t StorageId(std::string_view key) {
|
|
uint64_t hash = 14695981039346656037ull;
|
|
for (const char c : key) hash = (hash ^ static_cast<uint8_t>(c)) * 1099511628211ull;
|
|
hash &= 0x3FFFFFFFFFFFFFFFull;
|
|
return static_cast<int64_t>(hash == 0 ? 1 : hash);
|
|
}
|
|
}
|
|
|
|
namespace UgcDebounce {
|
|
// When a model saved at `now` may be made: after `quietSeconds` (0 or less: right away, stored as 0)
|
|
inline int64_t ProcessAfter(int64_t now, int64_t quietSeconds) {
|
|
return quietSeconds > 0 ? now + quietSeconds : 0;
|
|
}
|
|
|
|
// Whether a waiting model is due: its quiet period is over, or someone asked for its files
|
|
inline bool Due(int64_t processAfter, int64_t now, bool requested) {
|
|
return requested || processAfter <= now;
|
|
}
|
|
}
|