390 lines
16 KiB
Text
390 lines
16 KiB
Text
#include "Peril_Constants.lsl"
|
|
|
|
// =============================================================================
|
|
// PERIL WORLD RANKING - Leaderboard Manager
|
|
// =============================================================================
|
|
// Handles sharded KVP storage (up to 10 keys) and sorted ranking.
|
|
// Capacity: 500+ Players (Max 10 keys x 50 entries)
|
|
// =============================================================================
|
|
|
|
list leaderboardData = []; // Stride 3: [Name, Wins, Losses]
|
|
integer currentLoadPage = 1;
|
|
key kvpReadReq;
|
|
key kvpWriteReq;
|
|
key kvpLockReq; // Request for claiming leaderboard lock
|
|
list writeQueue = []; // Pairs of [KeyName, DataString]
|
|
integer isSaving = FALSE;
|
|
integer isBusy = FALSE; // Read lock
|
|
integer displayOffset = 0; // Current ranking page offset (0, 10, 20...)
|
|
integer retryCount = 0; // Track number of timeouts
|
|
string currentWriteKey;
|
|
string currentWriteVal;
|
|
|
|
// --- Lock & Sync State ---
|
|
string pendingPlayer = "";
|
|
string pendingResult = "";
|
|
integer isLocking = FALSE;
|
|
string myLockVal = "";
|
|
|
|
// Helper: Process the next KVP write in the queue
|
|
processWriteQueue() {
|
|
if (llGetListLength(writeQueue) == 0) {
|
|
isSaving = FALSE;
|
|
dbg("🏆 [Leaderboard] Save sequence complete. Releasing lock...");
|
|
// releaseLock();
|
|
kvpLockReq = llUpdateKeyValue(LB_LOCK_KEY, "", TRUE, myLockVal);
|
|
return;
|
|
}
|
|
isSaving = TRUE;
|
|
currentWriteKey = llList2String(writeQueue, 0);
|
|
currentWriteVal = llList2String(writeQueue, 1);
|
|
writeQueue = llDeleteSubList(writeQueue, 0, 1);
|
|
kvpWriteReq = llUpdateKeyValue(currentWriteKey, currentWriteVal, FALSE, "");
|
|
}
|
|
|
|
// Convert the whole list into sharded strings and start saving
|
|
generateShardedData() {
|
|
integer _shardI;
|
|
integer _totalCount = llGetListLength(leaderboardData) / 3;
|
|
writeQueue = [];
|
|
|
|
for (_shardI = 0; _shardI < MAX_LB_PAGES; _shardI++) {
|
|
integer _start = _shardI * MAX_ENTRIES_PER_PAGE;
|
|
if (_start >= _totalCount) jump shard_exit;
|
|
|
|
string _serialized = "";
|
|
integer _j;
|
|
for (_j = 0; _j < MAX_ENTRIES_PER_PAGE && (_start + _j) < _totalCount; _j++) {
|
|
integer _base = (_start + _j) * 3;
|
|
// NEW FORMAT: Wins,Losses,Name (CSV-like within colon segments)
|
|
string _entry = (string)llList2Integer(leaderboardData, _base) + "," +
|
|
(string)llList2Integer(leaderboardData, _base + 1) + "," +
|
|
llList2String(leaderboardData, _base + 2);
|
|
if (_serialized != "") _serialized += "|";
|
|
_serialized += _entry;
|
|
}
|
|
writeQueue += ["Peril_LB_" + (string)(_shardI + 1), _serialized];
|
|
}
|
|
@shard_exit;
|
|
|
|
// If no data to write (reset case), release lock now
|
|
if (llGetListLength(writeQueue) == 0) {
|
|
kvpLockReq = llUpdateKeyValue(LB_LOCK_KEY, "", TRUE, myLockVal);
|
|
} else {
|
|
processWriteQueue();
|
|
}
|
|
}
|
|
|
|
loadLBPage(integer pageNum) {
|
|
if (isBusy && pageNum == 1) return; // Prevent double loads on reset
|
|
if (pageNum > 1) llSleep(1.0); // Anti-Throttle Delay
|
|
|
|
isBusy = TRUE;
|
|
llSetTimerEvent(30.0); // 30 second watchdog (Lag Resistant)
|
|
currentLoadPage = pageNum;
|
|
string keyName = LB_KEY_PREFIX + (string)pageNum;
|
|
kvpReadReq = llReadKeyValue(keyName);
|
|
if (kvpReadReq == NULL_KEY) {
|
|
dbg("❌ [Leaderboard] KVP Read FAILED: Not authorized for " + keyName);
|
|
llSetTimerEvent(0.0);
|
|
} else {
|
|
dbg("📡 [Leaderboard] Loading " + keyName + "...");
|
|
}
|
|
}
|
|
|
|
list getSortedSlice(integer offset) {
|
|
if (llGetListLength(leaderboardData) == 0) return [];
|
|
|
|
// In LSL, llListSort sorts by the FIRST element of each stride.
|
|
// Our data format is [Wins, Losses, Name].
|
|
// Sort by Wins (descending).
|
|
list sorted = llListSort(leaderboardData, 3, FALSE);
|
|
|
|
integer start = offset * 3;
|
|
return llList2List(sorted, start, start + 29);
|
|
}
|
|
|
|
updatePlayerRecord(string pName, string pResult) {
|
|
// Search for Name (index 2 of each 3-stride entry)
|
|
integer _idx = -1;
|
|
integer _it;
|
|
for (_it = 2; _it < llGetListLength(leaderboardData); _it += 3) {
|
|
if (llList2String(leaderboardData, _it) == pName) { _idx = _it; jump found; }
|
|
}
|
|
@found;
|
|
|
|
if (_idx == -1) {
|
|
if (llGetListLength(leaderboardData) / 3 >= MAX_WORLD_RANKING) return;
|
|
if (pResult == "WIN") leaderboardData += [1, 0, pName];
|
|
else leaderboardData += [0, 1, pName];
|
|
} else {
|
|
integer _base = _idx - 2;
|
|
integer _v;
|
|
if (pResult == "WIN") {
|
|
_v = llList2Integer(leaderboardData, _base);
|
|
leaderboardData = llListReplaceList(leaderboardData, [_v + 1], _base, _base);
|
|
} else {
|
|
_v = llList2Integer(leaderboardData, _base + 1);
|
|
leaderboardData = llListReplaceList(leaderboardData, [_v + 1], _base+1, _base+1);
|
|
}
|
|
}
|
|
|
|
// SORT before saving
|
|
leaderboardData = llListSort(leaderboardData, 3, FALSE);
|
|
generateShardedData();
|
|
}
|
|
|
|
startUpdateSequence(string pName, string pResult) {
|
|
if (isLocking || isSaving) {
|
|
dbg("⚠️ [Leaderboard] Update already in progress. Retrying in 2s...");
|
|
llSleep(2.0);
|
|
}
|
|
|
|
pendingPlayer = pName;
|
|
pendingResult = pResult;
|
|
isLocking = TRUE;
|
|
|
|
dbg("🔐 [Leaderboard] Checking global lock for update...");
|
|
kvpLockReq = llReadKeyValue(LB_LOCK_KEY);
|
|
}
|
|
|
|
default {
|
|
on_rez(integer _p) { llResetScript(); }
|
|
|
|
state_entry() {
|
|
REPORT_MEMORY();
|
|
dbg("⏳ [Leaderboard] Startup: Handshake link active.");
|
|
}
|
|
|
|
dataserver(key _qid, string _qd) {
|
|
if (_qid == kvpReadReq) {
|
|
llSetTimerEvent(0.0); // Reset watchdog
|
|
integer _c = llSubStringIndex(_qd, ",");
|
|
string _st = _qd; string _vl = "";
|
|
if (_c != -1) {
|
|
_st = llGetSubString(_qd, 0, _c - 1);
|
|
_vl = llGetSubString(_qd, _c + 1, -1);
|
|
}
|
|
|
|
if (_st == "1") { // SUCCESS: Data found
|
|
if (_vl != "" && llSubStringIndex(_vl, "Error") == -1) {
|
|
list _ent = llParseString2List(_vl, ["|"], []);
|
|
integer _ei;
|
|
for (_ei = 0; _ei < llGetListLength(_ent); _ei++) {
|
|
string _rawEntry = llList2String(_ent, _ei);
|
|
if (llSubStringIndex(_rawEntry, ",") != -1) {
|
|
// NEW FORMAT: Wins,Losses,Name
|
|
list _it = llParseString2List(_rawEntry, [","], []);
|
|
if (llGetListLength(_it) >= 3) {
|
|
leaderboardData += [(integer)llList2String(_it, 0), (integer)llList2String(_it, 1), llList2String(_it, 2)];
|
|
}
|
|
} else {
|
|
// OLD LEGACY FORMAT: Name:Wins:Losses
|
|
list _it = llParseString2List(_rawEntry, [":"], []);
|
|
if (llGetListLength(_it) >= 3) {
|
|
// Translate to new stride structure in memory
|
|
leaderboardData += [(integer)llList2String(_it, 1), (integer)llList2String(_it, 2), llList2String(_it, 0)];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentLoadPage < 10) {
|
|
retryCount = 0; // Reset retries for next page
|
|
loadLBPage(currentLoadPage + 1);
|
|
} else {
|
|
isBusy = FALSE;
|
|
llSetTimerEvent(0);
|
|
dbg("🏆 [Leaderboard] SYNC COMPLETE - " + (string)(llGetListLength(leaderboardData)/3) + " players.");
|
|
llMessageLinked(LINK_SET, MSG_LB_LOAD_COMPLETE, "", NULL_KEY);
|
|
llMessageLinked(LINK_SET, MSG_LB_REQUEST_DISPLAY, "0", NULL_KEY); // Show page 1
|
|
|
|
// IF WE WERE SYNCING FOR AN UPDATE, APPLY IT NOW
|
|
if (isLocking) {
|
|
isLocking = FALSE;
|
|
updatePlayerRecord(pendingPlayer, pendingResult);
|
|
}
|
|
}
|
|
} else if (_st == "0" && _vl == "1") {
|
|
// XP_ERROR_THROTTLED
|
|
dbg("⚠️ [Leaderboard] Read throttled. Retrying Shard " + (string)currentLoadPage + " in 2s...");
|
|
llSleep(2.0);
|
|
isBusy = FALSE;
|
|
loadLBPage(currentLoadPage);
|
|
} else { // Empty or Error
|
|
isBusy = FALSE;
|
|
llSetTimerEvent(0);
|
|
if (_st == "0") { dbg("❌ [Leaderboard] KVP Error on Shard " + (string)currentLoadPage + ": " + _vl); }
|
|
dbg("🏆 [Leaderboard] SYNC COMPLETE - " + (string)(llGetListLength(leaderboardData)/3) + " players total.");
|
|
llMessageLinked(LINK_SET, MSG_LB_LOAD_COMPLETE, "", NULL_KEY);
|
|
llMessageLinked(LINK_SET, MSG_LB_REQUEST_DISPLAY, "0", NULL_KEY);
|
|
}
|
|
}
|
|
else if (_qid == kvpWriteReq) {
|
|
integer _c = llSubStringIndex(_qd, ",");
|
|
string _st = _qd; string _vl = "";
|
|
if (_c != -1) {
|
|
_st = llGetSubString(_qd, 0, _c - 1);
|
|
_vl = llGetSubString(_qd, _c + 1, -1);
|
|
}
|
|
|
|
if (_st == "0" && _vl == "1") {
|
|
// XP_ERROR_THROTTLED
|
|
dbg("⚠️ [Leaderboard] Write throttled. Retrying " + currentWriteKey + " in 2s...");
|
|
llSleep(2.0);
|
|
kvpWriteReq = llUpdateKeyValue(currentWriteKey, currentWriteVal, FALSE, "");
|
|
} else {
|
|
if (_st == "0") { dbg("❌ [Leaderboard] Write Error (" + _vl + ") on " + currentWriteKey); }
|
|
processWriteQueue();
|
|
}
|
|
}
|
|
else if (_qid == kvpLockReq) {
|
|
integer _c = llSubStringIndex(_qd, ",");
|
|
string _st = _qd; string _vl = "";
|
|
if (_c != -1) {
|
|
_st = llGetSubString(_qd, 0, _c - 1);
|
|
_vl = llGetSubString(_qd, _c + 1, -1);
|
|
}
|
|
|
|
if (isLocking) {
|
|
// STAGE 1: Current Lock Read Result
|
|
if (_st == "1") { // Success read
|
|
string _curVal = _vl;
|
|
integer _isStale = FALSE;
|
|
if (_curVal != "") {
|
|
list _p = llParseString2List(_curVal, [":"], []);
|
|
integer _ts = (integer)llList2String(_p, 1);
|
|
if (llGetUnixTime() - _ts > LB_LOCK_TIMEOUT) _isStale = TRUE;
|
|
}
|
|
|
|
if (_curVal == "" || _isStale) {
|
|
dbg("🔐 [Leaderboard] Lock available. Claiming...");
|
|
myLockVal = (string)llGetKey() + ":" + (string)llGetUnixTime();
|
|
// ATOMIC UPDATE: Only write if value is still what we just read
|
|
kvpLockReq = llUpdateKeyValue(LB_LOCK_KEY, myLockVal, TRUE, _curVal);
|
|
} else {
|
|
dbg("⏳ [Leaderboard] Lock held by another board. Retrying in 5s...");
|
|
llSetTimerEvent(5.0);
|
|
}
|
|
} else if (_st == "0" && _vl == "1") { // Throttled
|
|
dbg("⚠️ [Leaderboard] Lock check throttled. Retrying...");
|
|
llSleep(2.0);
|
|
kvpLockReq = llReadKeyValue(LB_LOCK_KEY);
|
|
} else if (_st == "14") { // SUCCESSFUL CLAIM (Atomic check passed)
|
|
dbg("🔐 [Leaderboard] LOCK ACQUIRED. Starting fresh sync...");
|
|
leaderboardData = []; // PURGE STALE MEMORY
|
|
loadLBPage(1);
|
|
} else if (_st == "0" && _vl == "15") { // ATOMIC CHECK FAILED (Someone else grabbed it)
|
|
dbg("⏳ [Leaderboard] Lock race lost. Retrying...");
|
|
llSleep(1.0);
|
|
kvpLockReq = llReadKeyValue(LB_LOCK_KEY);
|
|
} else {
|
|
dbg("❌ [Leaderboard] Lock Error: (" + _st + ") " + _vl);
|
|
isLocking = FALSE;
|
|
}
|
|
} else {
|
|
// RELEASE RESULT
|
|
if (_st == "14") { dbg("🔓 [Leaderboard] Lock released."); }
|
|
else { dbg("⚠️ [Leaderboard] Lock release issues: " + _vl); }
|
|
}
|
|
}
|
|
}
|
|
|
|
timer() {
|
|
if (isLocking) {
|
|
llSetTimerEvent(0);
|
|
kvpLockReq = llReadKeyValue(LB_LOCK_KEY);
|
|
return;
|
|
}
|
|
|
|
if (isBusy) {
|
|
if (retryCount < 3) {
|
|
retryCount++;
|
|
dbg("⚠️ [Leaderboard] Shard " + (string)currentLoadPage + " timed out. Retrying (" + (string)retryCount + "/3)...");
|
|
isBusy = FALSE; // Unlock so loadLBPage can run
|
|
loadLBPage(currentLoadPage);
|
|
} else {
|
|
isBusy = FALSE;
|
|
llSetTimerEvent(0);
|
|
dbg("🏆 [Leaderboard] SYNC GAVE UP (Persistent timeout on Shard " + (string)currentLoadPage + ")");
|
|
llMessageLinked(LINK_SET, MSG_LB_REQUEST_DISPLAY, "0", NULL_KEY);
|
|
}
|
|
} else {
|
|
llSetTimerEvent(0);
|
|
}
|
|
}
|
|
|
|
link_message(integer sender, integer num, string str, key id) {
|
|
if (num == MSG_LB_RECORD_PLAYER) {
|
|
startUpdateSequence(str, (string)id);
|
|
}
|
|
else if (num == MSG_DISPLAY_LEADERBOARD) {
|
|
if (str == "REFRESH_STARTUP") loadLBPage(1);
|
|
}
|
|
else if (num == MSG_LB_REQUEST_DISPLAY) {
|
|
integer _offset = (integer)str;
|
|
displayOffset = _offset; // SYNC GLOBAL VARIABLE
|
|
list _sorted = getSortedSlice(_offset);
|
|
string _rankCol = ""; string _nameCol = ""; string _statsCol = "";
|
|
integer _i; integer _total = llGetListLength(_sorted) / 3;
|
|
integer _globalTotal = llGetListLength(leaderboardData) / 3;
|
|
|
|
for (_i = 0; _i < 10; _i++) {
|
|
integer _rn = _offset + _i + 1;
|
|
string _rank = (string)_rn + "."; if (_rn < 10) _rank = "0" + _rank;
|
|
_rankCol += _rank + "\n";
|
|
if (_i < _total) {
|
|
integer _b = _i * 3;
|
|
_statsCol += "W:" + (string)llList2Integer(_sorted, _b) + "/L:" + (string)llList2Integer(_sorted, _b+1) + "\n";
|
|
string _n = llList2String(_sorted, _b+2);
|
|
if (llStringLength(_n) > 16) _n = llGetSubString(_n, 0, 13) + "...";
|
|
_nameCol += _n + "\n";
|
|
} else {
|
|
_nameCol += "----------\n"; _statsCol += "W:0/L:0\n";
|
|
}
|
|
}
|
|
string _p = " "; if (_offset > 0) _p = "[ < PREV ]";
|
|
string _n = " "; if (_offset + 10 < _globalTotal) _n = "[ NEXT > ]";
|
|
llMessageLinked(LINK_SET, MSG_DISPLAY_LEADERBOARD, "COLUMNS|" + _rankCol + "|" + _nameCol + "|" + _statsCol + "|" + _p + "|" + _n + "|" + (string)_offset, NULL_KEY);
|
|
}
|
|
else if (num == MSG_LB_PAGE_NEXT) {
|
|
integer _maxEntries = llGetListLength(leaderboardData) / 3;
|
|
if (displayOffset + 10 < _maxEntries) {
|
|
displayOffset += 10;
|
|
llMessageLinked(LINK_SET, MSG_LB_REQUEST_DISPLAY, (string)displayOffset, NULL_KEY);
|
|
}
|
|
}
|
|
else if (num == MSG_LB_PAGE_PREV) {
|
|
if (displayOffset >= 10) {
|
|
displayOffset -= 10;
|
|
llMessageLinked(LINK_SET, MSG_LB_REQUEST_DISPLAY, (string)displayOffset, NULL_KEY);
|
|
}
|
|
}
|
|
else if (num == MSG_RESET_LEADERBOARD) {
|
|
leaderboardData = [];
|
|
currentLoadPage = 1;
|
|
isBusy = FALSE;
|
|
displayOffset = 0;
|
|
|
|
if (str == "START_SYNC") {
|
|
loadLBPage(1);
|
|
}
|
|
else if (str == "WIPE" || str == "HARD_RESET") {
|
|
if (id != (key)GLOBAL_ADMIN) {
|
|
llOwnerSay("🚫 [Security] Unauthorized WIPE attempt blocked from: " + (string)id);
|
|
return;
|
|
}
|
|
// Soft Wipe: Clear all shards to empty in world datastore
|
|
integer _i;
|
|
for (_i = 1; _i <= MAX_LB_PAGES; _i++) {
|
|
llUpdateKeyValue(LB_KEY_PREFIX + (string)_i, "", FALSE, "");
|
|
}
|
|
dbg("🚫 [Leaderboard Manager] GLOBAL WIPE: All 10 datastore shards have been set to empty.");
|
|
}
|
|
else if (str == "DEBUG_GENERATE" && llGetOwner() == llGetCreator()) {
|
|
generateShardedData();
|
|
}
|
|
}
|
|
else if (num == MSG_RESET_ALL) { llResetScript(); }
|
|
}
|
|
}
|