Files
LonaRPG-Online-Games/ModScripts/_Mods/LonaCraft/Scripts/191_ChestCloud.rb
T

585 lines
19 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
# LonaCraft: personal camp-chest contents in the character cloud profile.
# Shared world furniture sync still omits inventory; this module rides the
# existing bank_blob / cloud_bank_storage channel as bank_json["lc_chests"],
# and mirrors a plain-name snapshot into lonacraft_data["chest_by_net"].
return unless defined?(LonaCraft::Furniture)
module LonaCraft
module ChestCloud
BOX_BASE = LonaCraft::Furniture::BOX_BASE
DATA_KEY = "chest_by_net"
STORY_KEY = "LonaCraftChests"
class << self
def cache
@cache ||= {}
end
def reset_cache
@cache = {}
end
def durable_store
d = LonaCraft::Furniture.data rescue nil
return nil if d.nil?
d[DATA_KEY] = {} unless d[DATA_KEY].is_a?(Hash)
d[DATA_KEY]
rescue
nil
end
def storage_record?(rec)
return false unless rec.is_a?(Hash)
kind = LonaCraft::Furniture.kind_for(rec['item_name'])
kind && kind[:storage]
rescue
false
end
def ensure_net_id(rec)
return nil unless rec.is_a?(Hash)
net_id = rec['lc_net_id']
unless net_id.is_a?(String) && net_id =~ /\A[a-z0-9]{12}\.[0-9]{1,12}\z/
if defined?(LonaCraft::OnlineSync) && LonaCraft::OnlineSync.respond_to?(:furniture_id)
LonaCraft::OnlineSync.furniture_id(rec)
net_id = rec['lc_net_id']
else
pid = 'local'
begin
if defined?(LonaCraft::OnlineSync) && LonaCraft::OnlineSync.respond_to?(:player_id)
pid = LonaCraft::OnlineSync.player_id.to_s
end
rescue
pid = 'local'
end
pid = 'local' if pid.to_s == ''
net_id = "#{pid}.#{rec['uid'].to_i}"
rec['lc_net_id'] = net_id
end
end
net_id.to_s
rescue
nil
end
def box_entries(box_id)
return [] if $game_boxes.nil? || box_id.to_i < BOX_BASE
if defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_collect_storage_box)
payload = WebSocket._live_sync_collect_storage_box(box_id.to_i)
entries = payload.is_a?(Hash) ? payload['entries'] : nil
return entries if entries.is_a?(Array)
end
box = $game_boxes.get_box(box_id.to_i) rescue nil
box = $game_boxes.box(box_id.to_i) if box.nil? && $game_boxes.respond_to?(:box)
return [] unless box.is_a?(Hash)
out = []
box.each do |item, amount|
qty = amount.to_i rescue 0
next if qty <= 0 || item.nil?
kind = 'item'
begin
kind = 'weapon' if defined?(RPG::Weapon) && item.is_a?(RPG::Weapon)
kind = 'armor' if defined?(RPG::Armor) && item.is_a?(RPG::Armor)
rescue
end
item_id = item.respond_to?(:id) ? item.id.to_i : 0
name = ''
begin
name = item.item_name.to_s if item.respond_to?(:item_name)
rescue
name = ''
end
next if item_id <= 0 && name == ''
out << { 'kind' => kind, 'id' => item_id, 'name' => name, 'amount' => qty }
end
out
rescue
[]
end
def row_for(net_id, item_name, entries)
{
'net_id' => net_id.to_s,
'name' => item_name.to_s,
'entries' => Array(entries)
}
end
def entries_nonempty?(entries)
entries.is_a?(Array) && entries.any? { |e| e.is_a?(Hash) && e['amount'].to_i > 0 }
end
def story_raw_get
return nil unless defined?($story_stats) && $story_stats
# Prefer @data — Story_Stats#[] returns 0 for missing keys, which
# breaks "empty?" checks and JSON parse.
if $story_stats.respond_to?(:data) && $story_stats.data.is_a?(Hash)
return $story_stats.data[STORY_KEY]
end
$story_stats[STORY_KEY]
rescue
nil
end
def story_raw_set(text)
return false unless defined?($story_stats) && $story_stats
wrote = false
# Write into @data first — reliable even if []= hooks misbehave.
if $story_stats.respond_to?(:data) && $story_stats.data.is_a?(Hash)
$story_stats.data[STORY_KEY] = text
wrote = true
end
# Also go through []= so autosave / quest-cloud hooks see the change.
if $story_stats.respond_to?(:[]=)
$story_stats[STORY_KEY] = text
wrote = true
end
wrote
rescue
false
end
def encode_story_blob(hash)
return '' unless hash.is_a?(Hash)
begin
if defined?(JSON) && JSON.respond_to?(:generate)
text = JSON.generate(hash)
return text if text.to_s != ''
end
rescue
end
# Fallback: net_id::name::kind|id|name|amt;... per line
parts = []
hash.each do |nid, row|
next unless row.is_a?(Hash)
ents = Array(row['entries']).map { |e|
next unless e.is_a?(Hash)
"#{e['kind']}|#{e['id']}|#{e['name']}|#{e['amount']}"
}.compact.join(';')
parts << "#{nid}::#{row['name']}::#{ents}"
end
parts.join("\n")
rescue
''
end
def decode_story_blob(raw)
return {} if raw.nil? || raw == 0
return raw if raw.is_a?(Hash)
text = raw.to_s
return {} if text.strip == '' || text == '0'
if defined?(JSON) && JSON.respond_to?(:parse)
parsed = JSON.parse(text) rescue nil
return parsed if parsed.is_a?(Hash)
end
# Fallback line format
out = {}
text.split(/\r?\n/).each do |line|
next if line.to_s.strip == ''
nid, name, ents = line.split('::', 3)
next if nid.to_s == ''
entries = []
ents.to_s.split(';').each do |chunk|
kind, id, iname, amt = chunk.split('|', 4)
next if kind.to_s == ''
entries << {
'kind' => kind.to_s,
'id' => id.to_i,
'name' => iname.to_s,
'amount' => amt.to_i
}
end
out[nid.to_s] = row_for(nid, name, entries)
end
out
rescue
{}
end
def story_blob_load
decode_story_blob(story_raw_get)
rescue
{}
end
def story_blob_save(hash)
story_raw_set(encode_story_blob(hash))
rescue
false
end
def persist_story_row(net_id, row)
blob = story_blob_load
if row.nil? || !entries_nonempty?(row['entries'])
# Do not erase a known filled chest from story on empty live reads.
return false if blob[net_id].is_a?(Hash) && entries_nonempty?(blob[net_id]['entries'])
blob.delete(net_id)
else
blob[net_id.to_s] = row
end
story_blob_save(blob)
rescue
false
end
# Pull cloud/story chest snapshots into cache + durable after reconnect.
def rehydrate_from_story!
blob = story_blob_load
n = 0
blob.each do |net_id, row|
next unless row.is_a?(Hash) && entries_nonempty?(row['entries'])
stored = row_for(net_id, row['name'], row['entries'])
cache[net_id.to_s] = stored
store = durable_store
store[net_id.to_s] = stored if store
n += 1
end
n > 0
rescue
false
end
def remember_row(row, allow_empty = false)
return false unless row.is_a?(Hash)
net_id = row['net_id'].to_s
return false if net_id == ''
entries = row['entries']
return false unless entries.is_a?(Array)
existing = cache[net_id]
existing = durable_store && durable_store[net_id] if !existing.is_a?(Hash)
existing = story_blob_load[net_id] if !existing.is_a?(Hash)
filled = entries_nonempty?(entries)
if !allow_empty && !filled &&
existing.is_a?(Hash) && entries_nonempty?(existing['entries'])
return false
end
stored = row_for(net_id, row['name'], entries)
store = durable_store
if filled
cache[net_id] = stored
store[net_id] = stored if store
persist_story_row(net_id, stored)
elsif allow_empty
cache.delete(net_id)
store.delete(net_id) if store
blob = story_blob_load
blob.delete(net_id)
story_blob_save(blob)
else
return false
end
begin
prefix = net_id.split('.', 2)[0]
if defined?(LonaCraft::OnlineSync) &&
LonaCraft::OnlineSync.respond_to?(:remember_identity) &&
LonaCraft::OnlineSync.respond_to?(:valid_player_id?) &&
LonaCraft::OnlineSync.valid_player_id?(prefix)
LonaCraft::OnlineSync.remember_identity(prefix)
story = LonaCraft::OnlineSync.story_get(LonaCraft::OnlineSync::STORY_ID_KEY).to_s rescue ''
unless LonaCraft::OnlineSync.valid_player_id?(story)
LonaCraft::OnlineSync.story_set(LonaCraft::OnlineSync::STORY_ID_KEY, prefix)
d = LonaCraft::OnlineSync.data rescue nil
d['lc_online_identity'] = prefix if d.is_a?(Hash)
end
end
rescue
end
true
rescue
false
end
def snapshot_record(rec, allow_empty = false)
return false unless storage_record?(rec)
net_id = ensure_net_id(rec)
return false if net_id.nil? || net_id == ''
box_id = rec['box'].to_i
return false if box_id < BOX_BASE
remember_row(row_for(net_id, rec['item_name'], box_entries(box_id)), allow_empty)
rescue
false
end
def forget_record(rec)
return false unless rec.is_a?(Hash)
net_id = ensure_net_id(rec)
return false if net_id.nil? || net_id == ''
cache.delete(net_id)
store = durable_store
store.delete(net_id) if store
blob = story_blob_load
blob.delete(net_id)
story_blob_save(blob)
true
rescue
false
end
def cached_row(net_id)
key = net_id.to_s
return nil if key == ''
row = cache[key]
return row if row.is_a?(Hash) && entries_nonempty?(row['entries'])
store = durable_store
stored = store && store[key]
if stored.is_a?(Hash) && entries_nonempty?(stored['entries'])
cache[key] = stored
return stored
end
blob = story_blob_load
story_row = blob[key]
if story_row.is_a?(Hash) && entries_nonempty?(story_row['entries'])
cache[key] = story_row
if store
store[key] = story_row
end
return story_row
end
row.is_a?(Hash) ? row : nil
rescue
nil
end
def snapshot_live(include_empty = false)
out = []
return out unless defined?(LonaCraft::Furniture)
furn = LonaCraft::Furniture
records = furn.records rescue nil
return out unless records.is_a?(Array)
records.each do |rec|
next unless storage_record?(rec)
next unless furn.local_owner?(rec)
net_id = ensure_net_id(rec)
next if net_id.nil? || net_id == ''
box_id = rec['box'].to_i
next if box_id < BOX_BASE
entries = box_entries(box_id)
next if entries.empty? && !include_empty
row = row_for(net_id, rec['item_name'], entries)
# Never let a transient empty live box erase filled durable/story rows.
remember_row(row) if entries_nonempty?(entries)
out << row
end
begin
out.sort_by! { |row| [row['net_id'].to_s, row['name'].to_s] }
rescue
end
out
rescue
[]
end
# Filled live boxes win. Cache / durable / story fill gaps (other maps,
# wiped $game_boxes, cloud restore). Empty live never erases filled rows.
def collect_for_bank
by_id = {}
[cache, durable_store, story_blob_load].each do |src|
next unless src.is_a?(Hash)
src.each do |net_id, row|
key = net_id.to_s
next if key == ''
next unless row.is_a?(Hash)
entries = row['entries']
next unless entries_nonempty?(entries)
by_id[key] = row_for(key, row['name'], entries)
end
end
snapshot_live(false).each do |row|
next unless row.is_a?(Hash)
key = row['net_id'].to_s
next if key == ''
next unless entries_nonempty?(row['entries'])
by_id[key] = row
end
rows = by_id.values
begin
rows.sort_by! { |row| [row['net_id'].to_s, row['name'].to_s] }
rescue
end
rows
rescue
[]
end
def remember_rows(rows)
return false unless rows.is_a?(Array)
rows.each { |row| remember_row(row) }
true
rescue
false
end
def remember_from_bank_json(bank_json)
return false unless bank_json.is_a?(Hash)
remember_rows(bank_json['lc_chests'])
rescue
false
end
def resolve_entry_item(entry)
return nil unless entry.is_a?(Hash)
if defined?(WebSocket) && WebSocket.respond_to?(:_bootstrap_bank_entry_item)
return WebSocket._bootstrap_bank_entry_item(entry)
end
name = entry['name'].to_s.strip
if name != '' && defined?($data_ItemName) && $data_ItemName.is_a?(Hash)
obj = $data_ItemName[name]
return obj if obj
end
kind = entry['kind'].to_s.downcase
item_id = entry['id'].to_i
return nil if item_id <= 0
case kind
when 'weapon'
$data_weapons && $data_weapons[item_id]
when 'armor'
$data_armors && $data_armors[item_id]
else
$data_items && $data_items[item_id]
end
rescue
nil
end
def write_entries_to_box(box_id, entries)
return false if $game_boxes.nil? || box_id.to_i < BOX_BASE
return false unless $game_boxes.respond_to?(:write_box)
rebuilt = {}
Array(entries).each do |entry|
next unless entry.is_a?(Hash)
qty = entry['amount'].to_i
next if qty <= 0
item = resolve_entry_item(entry)
next if item.nil?
rebuilt[item] ||= 0
rebuilt[item] += qty
end
$game_boxes.write_box(box_id.to_i, rebuilt)
true
rescue
false
end
def apply_to_record(rec)
return false unless storage_record?(rec)
return false unless LonaCraft::Furniture.local_owner?(rec)
net_id = ensure_net_id(rec)
return false if net_id.nil? || net_id == ''
row = cached_row(net_id)
return false unless row.is_a?(Hash)
entries = row['entries']
return false unless entries.is_a?(Array) && !entries.empty?
box_id = rec['box'].to_i
if box_id < BOX_BASE
box_id = LonaCraft::Furniture.next_box_id
rec['box'] = box_id
end
# Do not clobber a non-empty live box with an older snapshot.
unless LonaCraft::Furniture.box_empty?(box_id)
snapshot_record(rec)
return true
end
write_entries_to_box(box_id, entries)
rescue
false
end
def apply_all_cached!
return false unless defined?(LonaCraft::Furniture)
records = LonaCraft::Furniture.records rescue nil
return false unless records.is_a?(Array)
records.each { |rec| apply_to_record(rec) }
true
rescue
false
end
def refresh_cache_from_live!
snapshot_live(false)
true
rescue
false
end
def lonacraft_storage_box?(box_id)
box_id.to_i >= BOX_BASE
rescue
false
end
def record_for_box(box_id)
bid = box_id.to_i
return nil if bid < BOX_BASE
records = LonaCraft::Furniture.records rescue nil
return nil unless records.is_a?(Array)
records.find { |rec| storage_record?(rec) && rec['box'].to_i == bid }
rescue
nil
end
def snapshot_box(box_id)
rec = record_for_box(box_id)
# allow_empty: player closed/moved items — intentional empty must persist.
return snapshot_record(rec, true) if rec
false
rescue
false
end
def request_cloud_save(box_id = nil)
snapshot_box(box_id) if box_id
refresh_cache_from_live!
collect_for_bank
if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_remember_current_bank)
WebSocket.bootstrap_remember_current_bank
end
if defined?(MPCloudOnlySave)
ok = MPCloudOnlySave.send_tracked_now('cloud_bank_storage', true)
MPCloudOnlySave.request('cloud_bank_storage', 1) unless ok
return true
elsif defined?(MPImmediateLiveSync)
MPImmediateLiveSync.trigger('bank_storage', true, false)
return true
end
false
rescue
false
end
end
end
end
# Persist camp chests when the player moves items / closes storage.
if defined?(Scene_ItemStorage)
class Scene_ItemStorage
unless method_defined?(:lc_chest_cloud_move_item)
alias_method :lc_chest_cloud_move_item, :move_item
def move_item(val = nil)
result = lc_chest_cloud_move_item(val)
begin
if defined?(LonaCraft::ChestCloud) &&
LonaCraft::ChestCloud.lonacraft_storage_box?(@box_id)
LonaCraft::ChestCloud.request_cloud_save(@box_id)
end
rescue
end
result
end
end
unless method_defined?(:lc_chest_cloud_terminate)
alias_method :lc_chest_cloud_terminate, :terminate
def terminate(*args, &block)
begin
if defined?(LonaCraft::ChestCloud) &&
LonaCraft::ChestCloud.lonacraft_storage_box?(@box_id)
LonaCraft::ChestCloud.request_cloud_save(@box_id)
end
rescue
end
lc_chest_cloud_terminate(*args, &block)
end
end
end
end