Files
LonaRPG-Online-Games/ModScripts/_Mods/LonaCraft/Scripts/180_OnlineSync.rb
T

1347 lines
49 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
# LonaCraft online camp persistence fix 1.5.3 - metadata-safe camps.
# Uses the online client's EXISTING deistvia relay; does not modify the server.
# Only players running this same mod, in the same map instance, will sync.
# Inventory, chest contents, raid AI, and account/cloud data remain independent.
module LonaCraft
module OnlineSync
ACTION = 'lonacraft_world_v1'
MAX_PACKET = 1150
MAX_OBJECTS = 300
REQUEST_INTERVAL = 45.0
RESPONSE_INTERVAL = 6.0
SCAN_INTERVAL = 0.6
MAX_QUEUE = 1000
SEND_PER_TICK = 2
VALID_PIECES = ['W', 'B', 'F', 'D', 'FD', 'DS', 'FDS'].freeze
@map_token = nil
@observed = {}
@outbox = []
@last_scan = 0.0
@last_request = 0.0
@responses = {}
@online_last = false
@failure_last = 0.0
@newly_founded_token = nil
@last_discovery = 0.0
@last_camp_request = 0.0
@camp_sync_token = nil
@camp_sync_started = 0.0
@camp_sync_done = false
@last_camp_retry = 0.0
@saved_camps = {}
@pending_new_camps = {}
@pending_camp_meta = {}
# Temporary camp diagnostics are disabled in this release.
def self.log(message)
nil
end
def self.data
return nil if !$game_system || !$game_system.respond_to?(:lonacraft_data)
$game_system.lonacraft_data
end
STORY_ID_KEY = 'LonaCraftOnlineId'
STORY_ALIASES_KEY = 'LonaCraftOnlineIds'
def self.valid_player_id?(id)
id.is_a?(String) && id =~ /\A[a-z0-9]{12}\z/
end
def self.story_get(key)
return nil unless defined?($story_stats) && $story_stats
$story_stats[key]
rescue
nil
end
def self.story_set(key, value)
return false unless defined?($story_stats) && $story_stats && $story_stats.respond_to?(:[]=)
$story_stats[key] = value
true
rescue
false
end
# Durable identity: lonacraft_data is wiped on cloud restore, story_stats is not.
def self.player_id
d = data
return 'unknown' unless d
story_id = story_get(STORY_ID_KEY).to_s
if valid_player_id?(story_id)
d['lc_online_identity'] = story_id
remember_identity(story_id)
return story_id
end
id = d['lc_online_identity']
unless valid_player_id?(id)
id = adopt_identity_from_owned_furniture
id = ('%08x%04x' % [Time.now.to_i & 0xffffffff, rand(65536)]) unless valid_player_id?(id)
end
d['lc_online_identity'] = id
story_set(STORY_ID_KEY, id)
remember_identity(id)
id
end
def self.remember_identity(id)
return false unless valid_player_id?(id)
raw = story_get(STORY_ALIASES_KEY).to_s
list = raw.split(',').map { |s| s.strip }.select { |s| valid_player_id?(s) }
unless list.include?(id)
list << id
list = list.last(8)
story_set(STORY_ALIASES_KEY, list.join(','))
end
true
rescue
false
end
def self.known_identity?(id)
return false unless valid_player_id?(id)
story_id = story_get(STORY_ID_KEY).to_s
return true if id == story_id
begin
cur = data && data['lc_online_identity']
return true if id == cur.to_s
rescue
end
raw = story_get(STORY_ALIASES_KEY).to_s
raw.split(',').map { |s| s.strip }.include?(id)
rescue
false
end
# After a cloud wipe the random identity is new, but placed furniture still
# carries the old lc_net_id prefix. Reclaim that prefix when our durable
# chest snapshots still reference it.
def self.adopt_identity_from_owned_furniture
counts = Hash.new(0)
begin
store = nil
store = LonaCraft::ChestCloud.durable_store if defined?(LonaCraft::ChestCloud)
if store.is_a?(Hash)
store.each_key do |net_id|
prefix = net_id.to_s.split('.', 2)[0]
counts[prefix] += 1 if valid_player_id?(prefix)
end
end
rescue
end
begin
if defined?(LonaCraft::ChestCloud) && LonaCraft::ChestCloud.respond_to?(:cache)
LonaCraft::ChestCloud.cache.each_key do |net_id|
prefix = net_id.to_s.split('.', 2)[0]
counts[prefix] += 1 if valid_player_id?(prefix)
end
end
rescue
end
begin
records = LonaCraft::Furniture.records if defined?(LonaCraft::Furniture)
Array(records).each do |rec|
next unless rec.is_a?(Hash)
prefix = rec['lc_net_id'].to_s.split('.', 2)[0]
counts[prefix] += 1 if valid_player_id?(prefix)
end
rescue
end
return nil if counts.empty?
best = counts.max_by { |_, n| n }
best && valid_player_id?(best[0]) ? best[0] : nil
rescue
nil
end
def self.reclaim_identity!(id)
return false unless valid_player_id?(id)
d = data
d['lc_online_identity'] = id if d.is_a?(Hash)
story_set(STORY_ID_KEY, id)
remember_identity(id)
true
rescue
false
end
def self.stamps
d = data
return {} unless d
d['lc_online_stamps'] = {} unless d['lc_online_stamps'].is_a?(Hash)
d['lc_online_stamps']
end
def self.map_revisions(token)
store = stamps
store[token] = {} unless store[token].is_a?(Hash)
store[token]
end
def self.map_token
map = $game_map
return nil unless map && map.respond_to?(:map_id_rec) && map.respond_to?(:map_id)
# Include BOTH the map key and numeric ID. Never apply packets to a
# different randomly generated field map / private base instance.
key = map.map_id_rec.to_s
return nil if key.empty? || key.size > 120
"#{map.map_id.to_i}|#{key}"
end
def self.ready?
return false unless defined?(::WebSocket)
return false unless ::WebSocket.respond_to?(:connected?) && ::WebSocket.connected?
return false unless ::WebSocket.respond_to?(:worldsync?) && ::WebSocket.worldsync?
return false unless ::WebSocket.respond_to?(:send_deistvia)
return false if ::WebSocket.respond_to?(:gameplay_scene_active?) && !::WebSocket.gameplay_scene_active?
!data.nil? && !map_token.nil?
end
def self.now
Time.now.to_f
end
# RPG Maker bundles game_guy JSON 1.2 (encode/decode, not generate/parse).
# Prefer the native encoder when present, but support the bundled one.
def self.wire(packet)
str = JSON.respond_to?(:encode) ? JSON.encode(packet) : JSON.generate(packet)
return nil unless str.is_a?(String) && str.bytesize <= MAX_PACKET
[str].pack('m0')
end
def self.queue(packet)
line = wire(packet)
return false if line.nil? || @outbox.size >= MAX_QUEUE
@outbox << line
true
end
def self.send_now(packet)
line = wire(packet)
return false if line.nil? || !ready?
::WebSocket.send_deistvia(ACTION, 'msg', line)
true
end
def self.decode(payload)
return nil if !payload.is_a?(String) || payload.bytesize > 1700 || payload !~ /\A[A-Za-z0-9+\/=]+\z/
raw = payload.unpack1('m')
return nil if raw.bytesize > MAX_PACKET
obj = JSON.respond_to?(:decode) ? JSON.decode(raw) : JSON.parse(raw)
obj.is_a?(Hash) && obj['v'] == 1 ? obj : nil
rescue StandardError
nil
end
def self.stamp_cmp(a, b)
a = a.to_s.split('@', 2)
b = b.to_s.split('@', 2)
n = a[0].to_i <=> b[0].to_i
return n unless n == 0
a[1].to_s <=> b[1].to_s
end
def self.next_stamp
d = data
value = [d['lc_online_clock'].to_i + 1, 1].max
d['lc_online_clock'] = value
"#{value}@#{player_id}"
end
def self.touch_clock(stamp)
d = data
return if d.nil?
counter = stamp.to_s.split('@', 2)[0].to_i
d['lc_online_clock'] = counter if counter > d['lc_online_clock'].to_i
end
def self.normal_stamp(revisions, id)
r = revisions[id]
r.is_a?(Hash) && r['stamp'].is_a?(String) ? r['stamp'] : '0@0'
end
def self.furniture_id(rec)
net_id = rec['lc_net_id']
unless net_id.is_a?(String) && net_id =~ /\A[a-z0-9]{12}\.[0-9]{1,12}\z/
net_id = "#{player_id}.#{rec['uid'].to_i}"
rec['lc_net_id'] = net_id
end
'f:' + net_id
end
def self.state
map = $game_map
token = map_token
return {} if map.nil? || token.nil?
result = {}
furn = LonaCraft::Furniture
count = 0
furn.records.each do |rec|
next unless rec.is_a?(Hash) && rec['map_id'].to_i == map.map_id.to_i
next unless furn.kind_for(rec['item_name'])
x, y = rec['x'].to_i, rec['y'].to_i
next unless map.valid?(x, y)
id = furniture_id(rec)
result[id] = {'t'=>'f', 'x'=>x, 'y'=>y, 'name'=>rec['item_name'].to_s}
count += 1
break if count >= MAX_OBJECTS
end
base = LonaCraft::Bases.record_for_map(map)
if base && base['pieces'].is_a?(Hash)
base['pieces'].each do |key, value|
break if count >= MAX_OBJECTS
next unless key.to_s =~ /\A\d{1,4},\d{1,4}\z/
x, y = key.split(',').map(&:to_i)
next unless map.valid?(x, y) && VALID_PIECES.include?(value.to_s)
hp = base['hp'].is_a?(Hash) ? base['hp'][key] : nil
info = {'t'=>'b', 'x'=>x, 'y'=>y, 'code'=>value.to_s}
info['hp'] = hp.to_i if hp.is_a?(Integer) && hp >= 0
result['b:' + key] = info
count += 1
break if count >= MAX_OBJECTS
end
end
result
end
def self.changed?(a, b)
a != b
end
def self.publish_changes(current)
revisions = map_revisions(@map_token)
ids = (@observed.keys + current.keys).uniq
ids.each do |id|
old_value = @observed[id]
value = current[id]
next unless changed?(old_value, value)
stamp = next_stamp
revisions[id] = {'stamp'=>stamp, 'deleted'=>value.nil?}
queue({'v'=>1, 'm'=>@map_token, 'id'=>id, 's'=>stamp, 'o'=>value.nil? ? 'del' : 'put', 'd'=>value})
end
@observed = current
end
def self.snapshot
return unless ready?
token = map_token
current = state
revisions = map_revisions(token)
current.each do |id, value|
queue({'v'=>1, 'm'=>token, 'id'=>id, 's'=>(revisions.key?(id) ? normal_stamp(revisions, id) : ('0@' + player_id)), 'o'=>'put', 'd'=>value})
end
if $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
LonaCraft::Bases.records_on_overmap($game_map.map_id).first(80).each do |base|
packet = foundation_packet(base, token)
queue(packet) if packet
end
end
revisions.each do |id, rev|
next unless rev.is_a?(Hash) && rev['deleted'] && !current.key?(id)
queue({'v'=>1, 'm'=>token, 'id'=>id, 's'=>rev['stamp'].to_s, 'o'=>'del'})
end
end
# Base creation must be announced while the sender still occupies the
# original field map on the server. The receiver registers the same map ID,
# allowing both clients to move to the same online map instance. Other
# existing bases with clashing IDs are never overwritten.
# Owner names stay compact for the automatic "Лагерь <ник>" label. A
# manually renamed camp is validated separately by Bases.clean_name and
# may contain up to 48 characters.
def self.owner_name(raw)
raw.to_s.gsub(/[\r\n\t,\[\]:\\<>]/, '').strip[0, 24]
end
def self.camp_name(owner)
"Лагерь #{owner_name(owner)}"[0, 32]
end
def self.owns_camp?(rec)
return false unless rec.is_a?(Hash)
owner = owner_name(rec['owner'])
local = owner_name((::WebSocket.local_nickname rescue nil))
!owner.empty? && !local.empty? && owner.casecmp(local) == 0
rescue StandardError
false
end
# Wilderness maps can have numeric keys (e.g. 26), not only names.
# Preserve the original map-key type so Bases.register locates MapInfo.
def self.normal_field_key(raw)
if raw.is_a?(Integer)
return raw if raw > 0 && raw < 2_000_000_000
elsif raw.is_a?(String) && raw =~ /\A[a-zA-Z0-9_]{1,90}\z/
if raw =~ /\A[0-9]+\z/ && $data_mapinfos && $data_mapinfos[raw.to_i]
return raw.to_i
end
return raw
end
nil
end
def self.foundation_packet(rec, token)
return nil unless rec.is_a?(Hash) && rec['om'].is_a?(Array) && rec['om'].size == 3
field = normal_field_key(rec['field'])
return nil if field.nil?
# Migrate the owner's pre-fix camp name on the next snapshot. A camp
# imported from the server is tagged lc_shared and must keep its owner.
unless rec['lc_shared']
nick = (::WebSocket.local_nickname.to_s rescue '').strip
if !nick.empty?
nick = owner_name(nick)
rec['owner'] = nick
rec['name'] = camp_name(nick) if LonaCraft::Bases.clean_name(rec['name']).empty?
rec['lc_shared'] = true
end
end
id = rec['id'].to_i
return nil if id < 1 || id > 90000
{'v'=>1, 'm'=>token, 'o'=>'base', 'd'=>{
'id'=>id, 'om'=>rec['om'].map(&:to_i), 'key'=>rec['key'].to_s,
'field'=>field, 'region'=>rec['region'].to_i, 'no'=>rec['map_no'].to_i,
'owner'=>rec['owner'].to_s, 'name'=>LonaCraft::Bases.name_of(rec).to_s,
'danger'=>LonaCraft::Bases.danger_of(rec)
}}
end
# Discovery uses OVERMAP coordinates, so camps persist across field-map
# randomization and two players who entered at different moments converge.
def self.discover_camp
return false unless ready?
map = $game_map
return false unless map && !map.isOverMap
e = LonaCraft::Bases.entry
return false unless e.is_a?(Hash) && e['om'].is_a?(Array) && e['om'].size == 3
return false if LonaCraft::Bases.record_for_tile(*e['om'])
send_now({'v'=>1, 'm'=>map_token, 'o'=>'discover', 'om'=>e['om'].map(&:to_i)})
end
# The map can already be loaded when server replay arrives. Always ask
# MySQL-backed server for the complete camp list for this OverMap.
# Request again after login/map transition to survive bootstrap packet loss.
def self.request_overmap_camps
return false unless ready? && $game_map && $game_map.isOverMap
time = now
token = map_token
if @camp_sync_token != token
@camp_sync_token = token
@camp_sync_started = time
@camp_sync_done = false
@last_camp_request = 0.0
end
# At first login the map packet and camps_req can cross during server
# bootstrap. Retry quickly until the server confirms the complete list;
# after that retain the slow poll for camps created by other players.
interval = if @camp_sync_done
8.0
elsif time - @camp_sync_started < 6.0
0.75
elsif time - @camp_sync_started < 20.0
2.0
else
8.0
end
return false if time - @last_camp_request < interval
@last_camp_request = time
send_now({'v'=>1, 'm'=>map_token, 'o'=>'camps_req', 'om_id'=>$game_map.map_id.to_i})
end
def self.receive_camps_done(packet, sender)
return false unless sender.to_i == 0
info = packet['d']
return false unless info.is_a?(Hash) && info['om_id'].is_a?(Integer)
return false unless $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
return false unless info['om_id'] == $game_map.map_id.to_i
@camp_sync_token = map_token
@camp_sync_done = true
LonaCraft::Bases.records_on_overmap($game_map.map_id).each{|rec| refresh_marker(rec) }
update_tab_camp
true
end
# Send existing LOCAL foundations until the server confirms they were
# committed to MySQL. A local OverMap marker is not an acknowledgement.
# Retry also covers bootstrap timing, map transitions and packet loss.
def self.retry_unsaved_camps
return false unless ready?
time = now
return false if time - @last_camp_retry < 6.0
@last_camp_retry = time
map = $game_map
return false unless map
records = if map.respond_to?(:isOverMap) && map.isOverMap
LonaCraft::Bases.records_on_overmap(map.map_id)
else
e = LonaCraft::Bases.entry
e.is_a?(Hash) && e['om'].is_a?(Array) ? [LonaCraft::Bases.record_for_tile(*e['om'])].compact : []
end
# Keep retrying a creation/rename/danger update even after the owner has
# left that map. The server authenticates ownership before accepting it.
pending = @pending_new_camps.keys + @pending_camp_meta.keys
records += LonaCraft::Bases.list.select do |rec|
rec.is_a?(Hash) && rec['om'].is_a?(Array) && pending.include?(camp_ack_key(rec['om'], rec['id']))
end
records = records.uniq
nick = owner_name((::WebSocket.local_nickname rescue nil))
return false if nick.empty?
records.first(100).each do |rec|
next unless rec.is_a?(Hash) && rec['om'].is_a?(Array)
# Old locally-created bases may have been founded before the socket
# became ready. They still need their first MySQL synchronization.
unless rec['lc_shared']
rec['owner'] = nick
rec['name'] = camp_name(nick) if LonaCraft::Bases.clean_name(rec['name']).empty?
rec['lc_shared'] = true
end
next unless owner_name(rec['owner']).casecmp(nick) == 0
key = camp_ack_key(rec['om'], rec['id'])
next if @saved_camps[key]
packet = foundation_packet(rec, map_token)
if packet
if @pending_new_camps[key]
packet['o'] = 'base_new'
elsif @pending_camp_meta[key]
packet['o'] = 'base_meta'
end
end
if packet && send_now(packet)
log "camp awaiting SQL confirmation #{key}"
end
end
true
end
def self.camp_ack_key(om, id)
om.map(&:to_i).join(':') + ':' + id.to_i.to_s
end
def self.receive_camp_ack(packet, sender)
return false unless sender.to_i == 0
d = packet['d']
return false unless d.is_a?(Hash) && d['om'].is_a?(Array) && d['om'].size == 3
return false unless d['om'].all? { |n| n.is_a?(Integer) && n >= 0 && n < 5000 }
return false unless d['id'].is_a?(Integer) && d['id'] > 0 && d['id'] < 90000
key = camp_ack_key(d['om'], d['id'])
desired = @pending_camp_meta[key]
if desired
ack_name = LonaCraft::Bases.clean_name(d['name'])
ack_danger = d['danger'].is_a?(Integer) ? d['danger'] : nil
return true unless ack_name == desired['name'] && ack_danger == desired['danger']
@pending_camp_meta.delete(key)
end
@saved_camps[key] = true
@pending_new_camps.delete(key)
log "camp stored in MySQL #{key}"
true
end
def self.update_tab_camp
if defined?(MPTabLocationStatus) && MPTabLocationStatus.respond_to?(:send_current)
MPTabLocationStatus.send_current(true)
end
rescue StandardError => e
log "TAB location error: #{e.class}: #{e.message}"
end
def self.newly_founded!(token)
@newly_founded_token = token
end
def self.announce_foundation(rec, previous_token)
if rec.is_a?(Hash) && rec['om'].is_a?(Array)
key = camp_ack_key(rec['om'], rec['id'])
@saved_camps.delete(key)
@pending_new_camps[key] = true
end
return unless ready?
packet = foundation_packet(rec, previous_token)
if packet
# Only a foundation built NOW can reactivate a previously deleted camp.
# Ordinary snapshots use 'base' and never resurrect tombstones.
packet['o'] = 'base_new'
send_now(packet)
end
end
# Reliable owner-only update for the two mutable camp properties. It uses
# the existing foundation identity, but the server copies only name/danger
# into its canonical row and ACKs after MySQL commit.
def self.announce_metadata(rec)
return false unless rec.is_a?(Hash) && rec['om'].is_a?(Array)
return false unless owns_camp?(rec)
key = camp_ack_key(rec['om'], rec['id'])
@saved_camps.delete(key)
@pending_camp_meta[key] = {
'name'=>LonaCraft::Bases.clean_name(LonaCraft::Bases.name_of(rec)),
'danger'=>LonaCraft::Bases.danger_of(rec)
}
return false unless ready?
packet = foundation_packet(rec, map_token)
return false unless packet
packet['o'] = 'base_meta'
send_now(packet)
end
def self.announce_removed(rec)
return unless ready? && rec.is_a?(Hash) && rec['om'].is_a?(Array)
packet = {'v'=>1, 'm'=>map_token, 'o'=>'base_del',
'd'=>{'om'=>rec['om'].map(&:to_i), 'id'=>rec['id'].to_i,
'no'=>rec['map_no'].to_i}}
@saved_camps.delete(camp_ack_key(rec['om'], rec['id']))
@pending_new_camps.delete(camp_ack_key(rec['om'], rec['id']))
@pending_camp_meta.delete(camp_ack_key(rec['om'], rec['id']))
send_now(packet)
end
def self.receive_removal(packet, sender)
# Never accept camp deletion straight from a peer; only the server has
# authenticated the camp owner's profile before broadcasting this.
return false unless sender.to_i == 0
info = packet['d']
return false unless info.is_a?(Hash) && info['om'].is_a?(Array) && info['om'].size == 3
coords = info['om']
return false unless coords.all?{|v| v.is_a?(Integer) && v >= 0 && v < 5000}
bases = LonaCraft::Bases
rec = bases.record_for_tile(*coords)
return true unless rec
return false unless rec['id'].to_i == info['id'].to_i
# Do not re-transmit a removal; the server already broadcast it.
bases.list.delete(rec)
key = camp_ack_key(coords, info['id'])
@saved_camps.delete(key)
@pending_new_camps.delete(key)
@pending_camp_meta.delete(key)
begin
bases.remove_live_markers($game_map, [rec]) if $game_map
rescue StandardError => e
log "remove marker error: #{e.class}: #{e.message}"
end
update_tab_camp
log "camp permanently removed: #{coords.inspect}"
true
end
def self.receive_foundation(packet)
info = packet['d']
return false unless info.is_a?(Hash)
id = info['id']
om = info['om']
key = info['key']
no = info['no']
field = normal_field_key(info['field'])
region = info['region']
return false unless id.is_a?(Integer) && id > 0 && id < 90000
return false unless om.is_a?(Array) && om.size == 3 && om.all?{|v| v.is_a?(Integer) && v >= 0 && v < 5000}
return false unless key == "LonaCraftBase_#{id}" && no == LonaCraft::Bases::MAP_ID_BASE + id
return false unless region.is_a?(Integer) && region >= 0 && region <= 200
return false if field.nil?
owner = owner_name(info['owner'])
label = LonaCraft::Bases.clean_name(info['name'])
label = camp_name(owner) if label.empty? && !owner.empty?
danger = info['danger'].is_a?(Integer) && info['danger'] >= -1 && info['danger'] <= 1 ? info['danger'] : 0
bases = LonaCraft::Bases
root = bases.root
return false unless root && $data_mapinfos && $data_mapinfos[field]
# Either we are on the same original field tile, or on the overmap.
world = $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
unless world
ent = bases.entry
return false unless ent.is_a?(Hash) && ent['om'].is_a?(Array)
return false unless ent['om'].map(&:to_i) == om && ent['to'].to_s == field
end
if world
return false unless $game_map.map_id.to_i == om[0]
end
existing = bases.record_for_tile(*om)
if existing
# An old local/offline camp may already occupy the same tile. Never
# replace its structures; fill in its shared display metadata.
if existing['key'].to_s == key && existing['map_no'].to_i == no
existing['owner'] = owner unless owner.empty?
pending_meta = @pending_camp_meta[camp_ack_key(om, id)]
unless pending_meta
existing['name'] = label unless label.empty?
existing['danger'] = danger
end
existing['lc_shared'] = true
refresh_marker(existing) if world
update_tab_camp
return true
end
return false
end
if bases.record_by_id(id) || root['maps'].key?(key)
log "shared camp ID collision #{id} at #{om.inspect}; keeping local record"
return false
end
registered = bases.register(key, no, field)
return false if registered.to_i != no
rec = {'id'=>id, 'om'=>om, 'region'=>region, 'field'=>field,
'key'=>key, 'map_no'=>no, 'pieces'=>{}, 'made'=>bases.date_now,
'owner'=>owner, 'name'=>label, 'danger'=>danger, 'lc_shared'=>true}
bases.list << rec
root['next_id'] = [root['next_id'].to_i, id + 1].max
refresh_marker(rec) if world
log "camp discovered: #{label} on #{om.inspect}, overmap=#{world}"
unless world
ent = bases.entry
ent['base'] = id
bases.rekey($game_map, rec)
end
log "registered shared base #{id} on #{om.inspect}"
update_tab_camp
true
end
# A foundation can arrive AFTER Game_Map#setup_event_hack. Make its icon
# visible immediately, instead of only after exiting/re-entering the map.
def self.refresh_marker(rec)
map = $game_map
return unless map && map.respond_to?(:isOverMap) && map.isOverMap
return unless rec['om'].is_a?(Array) && rec['om'][0].to_i == map.map_id.to_i
map.lonacraft_inject_base_markers
raw_map = map.instance_variable_get(:@map)
return unless raw_map && map.events.is_a?(Hash)
raw_map.events.each do |event_id, raw_event|
next unless raw_event && raw_event.name.to_s == LonaCraft::Bases.marker_name(rec)
next if map.events.key?(event_id)
map.events[event_id] = Game_Event.new(map.map_id, raw_event)
if map.respond_to?(:added_ev_ids) && map.added_ev_ids
map.added_ev_ids << event_id unless map.added_ev_ids.include?(event_id)
end
end
rescue StandardError => e
log "marker refresh error: #{e.class}: #{e.message}"
end
def self.accepts_foundation?(packet)
info = packet['d']
return false unless info.is_a?(Hash) && info['om'].is_a?(Array) && info['om'].size == 3
return true if packet['m'] == map_token
return false unless $game_map
if $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
return $game_map.map_id.to_i == info['om'][0].to_i
end
# A reply to the geographic discovery request carries the founder's
# original map token, which may no longer equal the visitor's token.
e = LonaCraft::Bases.entry
e.is_a?(Hash) && e['om'].is_a?(Array) &&
e['om'].map(&:to_i) == info['om'].map(&:to_i) &&
e['to'].to_s == info['field'].to_s
end
def self.tick
online = ready?
unless online
@online_last = false
@map_token = nil
@outbox.clear
@observed.clear
@newly_founded_token = nil
@saved_camps.clear
@last_camp_retry = 0.0
@camp_sync_token = nil
@camp_sync_started = 0.0
@camp_sync_done = false
return
end
token = map_token
time = now
if !@online_last || token != @map_token
@online_last = true
@map_token = token
founding = (@newly_founded_token == token)
@newly_founded_token = nil
@observed = founding ? {} : state
@outbox.clear
@last_scan = time
@last_request = time
send_now({'v'=>1, 'm'=>token, 'o'=>'req'})
@last_discovery = time
discover_camp
@camp_sync_token = nil
@last_camp_request = 0.0
request_overmap_camps
update_tab_camp
if founding
# The very FIRST floor is already laid by the time the map changes.
# Publish it with a nonzero revision, so a stale snapshot from the
# other player cannot erase it when both clients enter the camp.
publish_changes(state)
else
snapshot
end
log "entered #{token}, requested object state"
elsif time - @last_scan >= SCAN_INTERVAL
@last_scan = time
publish_changes(state)
end
if time - @last_discovery >= 7.0
@last_discovery = time
discover_camp
end
request_overmap_camps
retry_unsaved_camps
request_delay = ($game_map.respond_to?(:isOverMap) && $game_map.isOverMap) ? 7.0 : REQUEST_INTERVAL
if time - @last_request > request_delay
@last_request = time
send_now({'v'=>1, 'm'=>token, 'o'=>'req'})
end
SEND_PER_TICK.times do
line = @outbox.shift
break if line.nil?
::WebSocket.send_deistvia(ACTION, 'msg', line)
end
rescue StandardError => e
time = now
if time - @failure_last > 10.0
log "tick error: #{e.class}: #{e.message}"
@failure_last = time
end
end
def self.receive(sender, phase, payload)
return false unless phase == 'msg' && ready?
return false if sender.to_i == ::WebSocket.my_id.to_i
packet = decode(payload)
return false unless packet
if packet['o'] == 'base_ack'
return receive_camp_ack(packet, sender)
end
if packet['o'] == 'camps_done'
return receive_camps_done(packet, sender)
end
if packet['o'] == 'base' || packet['o'] == 'base_new'
return false unless accepts_foundation?(packet)
return receive_foundation(packet)
end
if packet['o'] == 'base_del'
return receive_removal(packet, sender)
end
return false unless packet['m'] == map_token
if packet['o'] == 'req'
last = @responses[sender.to_i].to_f
if now - last >= RESPONSE_INTERVAL
@responses[sender.to_i] = now
snapshot
end
return true
end
id = packet['id'].to_s
stamp = packet['s'].to_s
return false unless id =~ /\A(?:f:[a-z0-9]{12}\.[0-9]{1,12}|b:\d{1,4},\d{1,4})\z/
return false unless stamp =~ /\A\d{1,16}@[a-z0-9]{1,16}\z/
op = packet['o']
return false unless op == 'put' || op == 'del'
revisions = map_revisions(packet['m'])
return true if stamp_cmp(stamp, normal_stamp(revisions, id)) <= 0
value = packet['d']
return false if op == 'put' && !valid_payload?(id, value)
touch_clock(stamp)
if apply(id, op, value)
revisions[id] = {'stamp'=>stamp, 'deleted'=>op == 'del'}
@observed = state
true
else
false
end
rescue StandardError => e
log "incoming packet rejected: #{e.class}: #{e.message}"
false
end
def self.valid_payload?(id, value)
return false unless value.is_a?(Hash) && value['x'].is_a?(Integer) && value['y'].is_a?(Integer)
x, y = value['x'], value['y']
return false unless x >= 0 && y >= 0 && x < 1000 && y < 1000 && $game_map.valid?(x,y)
if id.start_with?('f:')
return false unless value['t'] == 'f' && value['name'].is_a?(String) && value['name'].size < 110
!LonaCraft::Furniture.kind_for(value['name']).nil?
else
return false unless value['t'] == 'b' && id == "b:#{x},#{y}" && VALID_PIECES.include?(value['code'])
value['hp'].nil? || (value['hp'].is_a?(Integer) && value['hp'] >= 0 && value['hp'] < 100000)
end
end
def self.apply(id, op, value)
return apply_furniture(id, op, value) if id.start_with?('f:')
apply_piece(id, op, value)
end
def self.apply_furniture(id, op, value)
furn = LonaCraft::Furniture
map = $game_map
rec = furn.records.find{|r| r.is_a?(Hash) && r['lc_net_id'] == id[2..-1]}
if op == 'del'
if rec && rec['map_id'].to_i == map.map_id.to_i
furn.remove(map, rec['uid'])
if defined?(LonaCraft::Bases) && LonaCraft::Bases.record_for_map(map)
LonaCraft::Bases.after_furniture_removed(map)
end
end
return true
end
kind = furn.kind_for(value['name'])
return false unless kind
return true if rec && rec['x'].to_i == value['x'] && rec['y'].to_i == value['y'] && rec['item_name'] == value['name']
# Never create a base or transfer a player's inventory on behalf of a peer.
# Only sync furniture on an already allowed map instance.
return false unless rec || furn.map_allowed?(map)
keep_box = 0
begin
if kind[:storage] && defined?(LonaCraft::ChestCloud)
LonaCraft::ChestCloud.snapshot_record(rec) if rec
end
keep_box = rec['box'].to_i if rec && kind[:storage]
rescue
keep_box = 0
end
if rec
furn.remove(map, rec['uid'])
end
fresh = {'uid'=>furn.next_uid, 'map_id'=>map.map_id, 'x'=>value['x'], 'y'=>value['y'],
'item_name'=>value['name'], 'lc_net_id'=>id[2..-1]}
if kind[:storage]
# Reuse the previous box so a sync echo cannot orphan filled storage.
fresh['box'] = (keep_box >= LonaCraft::Furniture::BOX_BASE) ? keep_box : furn.next_box_id
end
furn.records << fresh
furn.spawn(map, fresh, kind)
begin
if kind[:storage] && defined?(LonaCraft::ChestCloud)
LonaCraft::ChestCloud.apply_to_record(fresh)
end
rescue
end
true
end
def self.apply_piece(id, op, value)
map = $game_map
bases = LonaCraft::Bases
x, y = id[2..-1].split(',').map(&:to_i)
return false unless map.valid?(x, y)
rec = bases.record_for_map(map)
return true if op == 'del' && rec.nil?
# Do not create/re-key an unsynchronised field map when a remote player
# builds. This avoids splitting the existing online map instance.
return false if rec.nil?
pieces = bases.pieces_of(rec)
key = bases.piece_key(x, y)
old = pieces[key]
new_value = op == 'del' ? nil : value['code']
if old && bases.door?(old) && (!new_value || !bases.door?(new_value))
bases.remove_door_event(map, x, y)
end
if new_value
pieces[key] = new_value
else
pieces.delete(key)
end
bases.clear_hp(rec, x, y)
bases.set_hp(rec, x, y, value['hp']) if new_value && value['hp']
bases.paint(map, pieces, bases.around(x, y))
bases.repaint(map)
bases.sync_doors(map, rec)
bases.orient_doors_near(map, x, y)
bases.update_block(map, pieces)
bases.refresh_spawn_lists(map)
bases.revert_if_empty(map) if pieces.empty? && bases.respond_to?(:revert_if_empty)
true
end
# Cloud login starts on NoerSewer (0, 0) and then transfers to the saved
# numeric map. A camp map (9200 + id) does not exist until it is registered,
# so that transfer is dropped and the player stays outside the sewer.
def self.camp_resume
return nil unless defined?(LonaCraft::Bases) && $game_map
rec = LonaCraft::Bases.record_for_map($game_map)
return nil unless rec.is_a?(Hash)
field = normal_field_key(rec['field'])
return nil if field.nil?
om = rec['om'].is_a?(Array) && rec['om'].size == 3 ? rec['om'].map(&:to_i) : nil
{
'id' => rec['id'].to_i,
'key' => rec['key'].to_s,
'field' => field.to_s,
'no' => rec['map_no'].to_i,
'om' => om
}
rescue StandardError
nil
end
def self.stamp_camp_resume(meta)
return meta unless meta.is_a?(Hash)
resume = camp_resume
if resume
meta['lc_camp_id'] = resume['id']
meta['lc_camp_key'] = resume['key']
meta['lc_camp_field'] = resume['field']
meta['lc_camp_no'] = resume['no']
meta['lc_camp_om'] = resume['om'] if resume['om']
else
%w[lc_camp_id lc_camp_key lc_camp_field lc_camp_no lc_camp_om].each { |key| meta.delete(key) }
end
meta
rescue StandardError
meta
end
def self.camp_map_known?(map_id)
numeric = map_id.to_i
return false if numeric <= 0 || $data_mapinfos.nil?
return true if $data_mapinfos[numeric] || $data_mapinfos[map_id]
$data_mapinfos.any? { |_key, info| info && info.respond_to?(:id) && info.id.to_i == numeric }
rescue StandardError
false
end
def self.resume_from_player(player, map_id)
info = player.is_a?(Hash) ? player : {}
id = info['lc_camp_id'].to_i
no = info['lc_camp_no'].to_i
no = map_id.to_i if no <= 0
id = no - LonaCraft::Bases::MAP_ID_BASE if id <= 0 && no >= LonaCraft::Bases::MAP_ID_BASE
key = info['lc_camp_key'].to_s
key = "#{LonaCraft::Bases::KEY_PREFIX}#{id}" if key.empty? && id > 0
field = normal_field_key(info['lc_camp_field'])
om = info['lc_camp_om']
om = om.map(&:to_i) if om.is_a?(Array) && om.size == 3
om = nil unless om.is_a?(Array) && om.size == 3 && om[0] > 0
return nil if id <= 0 || key.empty?
{'id' => id, 'key' => key, 'field' => field, 'no' => no, 'om' => om}
rescue StandardError
nil
end
def self.ensure_login_record(resume)
bases = LonaCraft::Bases
root = bases.root
return false if root.nil? || resume.nil?
existing = bases.record_by_id(resume['id'])
if existing.is_a?(Hash)
bases.ensure_registered(existing) if bases.respond_to?(:ensure_registered)
return true
end
field = resume['field']
return false if field.nil?
registered = bases.register(resume['key'], resume['no'], field)
return false if registered.nil?
resume['no'] = registered.to_i
om = resume['om']
rec = {
'id' => resume['id'], 'om' => om, 'region' => 0, 'field' => field,
'key' => resume['key'], 'map_no' => resume['no'], 'pieces' => {},
'made' => (bases.respond_to?(:date_now) ? bases.date_now : ''),
'lc_shared' => true
}
bases.list << rec
root['next_id'] = [root['next_id'].to_i, resume['id'] + 1].max
if om.is_a?(Array)
root['entry'] = {
'om' => om, 'region' => 0, 'event' => 0, 'to' => field,
'at' => resume['key'], 'base' => resume['id'], 'allowed' => true
}
end
true
rescue StandardError => e
log "camp login register error: #{e.class}: #{e.message}" if respond_to?(:log)
false
end
def self.overmap_fallback(state)
story = defined?($story_stats) ? $story_stats : nil
return false unless story && story.respond_to?(:[])
mid = story['OverMapID'].to_i
x = story['LastOverMapX'].to_i
y = story['LastOverMapY'].to_i
return false if mid <= 0 || x < 0 || y < 0
return false if defined?(WebSocket) && WebSocket.respond_to?(:overmap_map_id?) && !WebSocket.overmap_map_id?(mid)
state['map_id'] = mid
state['x'] = x
state['y'] = y
state['direction'] = 2
true
rescue StandardError
false
end
# Register the saved camp before the login transfer. If the field map is
# not in this snapshot yet, stand on the camp's overmap tile instead of
# the blank NoerSewer cell.
def self.prepare_camp_login(state)
return unless state.is_a?(Hash)
map_id = state['map_id'].to_i
return if map_id < LonaCraft::Bases::MAP_ID_BASE
return if camp_map_known?(map_id)
player = state['player_json']
resume = resume_from_player(player, map_id)
if resume && resume['field'] && ensure_login_record(resume)
om = resume['om']
if om && defined?(WebSocket) && WebSocket.respond_to?(:capture_overmap_location)
WebSocket.capture_overmap_location(om[0], om[1], om[2], 'camp_login')
end
state['map_id'] = resume['no'] if resume['no'].to_i > 0
return
end
if resume && resume['om']
om = resume['om']
if !defined?(WebSocket) || !WebSocket.respond_to?(:overmap_map_id?) || WebSocket.overmap_map_id?(om[0])
state['map_id'] = om[0]
state['x'] = om[1]
state['y'] = om[2]
state['direction'] = 2
return
end
end
overmap_fallback(state)
rescue StandardError => e
log "camp login prepare error: #{e.class}: #{e.message}" if respond_to?(:log)
end
end
end
if defined?(WebSocket)
module WebSocket
class << self
if method_defined?(:_live_sync_collect_player_meta) && !method_defined?(:lc_camp_collect_player_meta)
alias lc_camp_collect_player_meta _live_sync_collect_player_meta
def _live_sync_collect_player_meta(actor)
out = lc_camp_collect_player_meta(actor)
LonaCraft::OnlineSync.stamp_camp_resume(out) if defined?(LonaCraft::OnlineSync)
out
end
end
if method_defined?(:_bootstrap_apply_position) && !method_defined?(:lc_camp_bootstrap_position)
alias lc_camp_bootstrap_position _bootstrap_apply_position
def _bootstrap_apply_position(state)
LonaCraft::OnlineSync.prepare_camp_login(state) if defined?(LonaCraft::OnlineSync)
lc_camp_bootstrap_position(state)
end
end
end
end
end
# Socket/multiplayer scripts are loaded by the online client, before LonaCraft
# in the 2026-10-09 build. No edits to ModScripts/multiplayer are necessary.
if defined?(::WebSocket) && ::WebSocket.respond_to?(:update)
module WebSocket
class << self
alias_method :lc_online_previous_update, :update
def update(*args, **kwargs, &block)
result = lc_online_previous_update(*args, **kwargs, &block)
LonaCraft::OnlineSync.tick
result
end
if method_defined?(:handle_remote_deistvia)
alias_method :lc_online_previous_deistvia, :handle_remote_deistvia
def handle_remote_deistvia(player_id, action_id, phase, payload)
if action_id.to_s == LonaCraft::OnlineSync::ACTION
LonaCraft::OnlineSync.receive(player_id, phase.to_s, payload.to_s)
return
end
lc_online_previous_deistvia(player_id, action_id, phase, payload)
end
end
end
end
else
puts '[LonaCraft Online] WebSocket unavailable when mod loaded; online relay disabled.'
end
# Send the foundation BEFORE WebSocket.update reports the re-keyed map ID.
# The packet travels through the old shared map's peer relay.
module LonaCraft
module Bases
class << self
# Clearing the final floor must NOT silently delete a persistent camp.
# The dedicated "Destroy all bases" action remains an explicit deletion.
alias_method :lc_online_previous_on_piece_removed, :on_piece_removed
def on_piece_removed(map, x, y)
rec = record_for_map(map)
if LonaCraft::OnlineSync.ready? && rec && rec['om'].is_a?(Array)
pieces = rec['pieces'].is_a?(Hash) ? rec['pieces'] : {}
key = piece_key(x, y)
return nil unless pieces.key?(key)
pieces.delete(key)
return :removed
end
lc_online_previous_on_piece_removed(map, x, y)
end
alias_method :lc_online_previous_destroy_all, :destroy_all!
def destroy_all!
shared = list.select{|rec| rec.is_a?(Hash) && rec['lc_shared'] && rec['om'].is_a?(Array) }
return lc_online_previous_destroy_all if shared.empty?
removable = list.select do |rec|
next false unless rec.is_a?(Hash)
!rec['lc_shared'] || (LonaCraft::OnlineSync.ready? && LonaCraft::OnlineSync.owns_camp?(rec))
end
removable.each do |rec|
LonaCraft::OnlineSync.announce_removed(rec) if rec['lc_shared'] && rec['om'].is_a?(Array)
end
destroy_records!(removable)
end
alias_method :lc_online_previous_after_furniture_removed, :after_furniture_removed
def after_furniture_removed(map)
rec = record_for_map(map)
return false if LonaCraft::OnlineSync.ready? && rec && rec['om'].is_a?(Array)
lc_online_previous_after_furniture_removed(map)
end
alias_method :lc_online_previous_revert_if_empty, :revert_if_empty
def revert_if_empty(map)
rec = record_for_map(map)
return false if LonaCraft::OnlineSync.ready? && rec && rec['om'].is_a?(Array)
lc_online_previous_revert_if_empty(map)
end
alias_method :lc_online_previous_remove_record, :remove_record
def remove_record(rec)
if rec.is_a?(Hash) && rec['om'].is_a?(Array)
LonaCraft::OnlineSync.announce_removed(rec)
end
lc_online_previous_remove_record(rec)
end
alias_method :lc_online_previous_create_record, :create_record
def create_record(map)
previous = LonaCraft::OnlineSync.map_token
root_data = root
original_next = root_data && root_data['next_id']
online_field = LonaCraft::OnlineSync.ready? && !named_map?(map) &&
entry.is_a?(Hash) && entry['om'].is_a?(Array)
# Every player gets the same ID for the same world tile, regardless of
# their private save's next_id. Avoid the old all-players-use-ID-1 race.
if online_field
coords = entry['om'].map(&:to_i).join(':')
hash = coords.each_byte.inject(2166136261) { |h, b| ((h ^ b) * 16777619) & 0xffffffff }
root_data['next_id'] = 1000 + hash % 85000
end
rec = lc_online_previous_create_record(map)
if rec && online_field
nick = (::WebSocket.local_nickname.to_s rescue '').strip
nick = 'Игрок' if nick.empty?
nick = LonaCraft::OnlineSync.owner_name(nick)
rec['owner'] = nick
rec['name'] = LonaCraft::OnlineSync.camp_name(nick)
rec['lc_shared'] = true
end
if root_data && original_next
root_data['next_id'] = [original_next.to_i, root_data['next_id'].to_i].max
end
if rec && previous
LonaCraft::OnlineSync.announce_foundation(rec, previous)
LonaCraft::OnlineSync.update_tab_camp
LonaCraft::OnlineSync.newly_founded!(LonaCraft::OnlineSync.map_token) if online_field
end
rec
end
end
end
end
# The original LonaCraft randomly selects a wilderness field every visit. In
# co-op that sends two players at the SAME world tile to different map rooms.
# Select the same field deterministically while connected. Offline choice stays
# completely unchanged. Registered/pinned existing bases still take priority.
module LonaCraft
module Bases
class << self
alias_method :lc_online_previous_pick_for_entry, :pick_for_entry
def pick_for_entry(region)
return lc_online_previous_pick_for_entry(region) unless LonaCraft::OnlineSync.ready?
return lc_online_previous_pick_for_entry(region) unless $game_map && $game_map.isOverMap
maps = ($data_region_maps && $data_region_maps[region])
return lc_online_previous_pick_for_entry(region) unless maps.is_a?(Array) && maps.size > 1
if record_for_tile($game_map.map_id, $game_player.x, $game_player.y)
return lc_online_previous_pick_for_entry(region)
end
event = $story_stats && $story_stats['OverMapEvent_name']
return lc_online_previous_pick_for_entry(region) if event && event.to_s != '0'
selected = maps.sort_by(&:to_s)
seed = "#{$game_map.map_id}|#{$game_player.x}|#{$game_player.y}|#{region}"
number = seed.each_byte.inject(5381){|h, b| ((h * 33) ^ b) & 0xffffffff}
$data_region_maps[region] = [selected[number % selected.size]]
begin
lc_online_previous_pick_for_entry(region)
ensure
$data_region_maps[region] = maps
end
end
end
end
end
# Every visible overmap camp marker carries the shared owner's label. This is
# deliberately tied to the event sprite: scrolling, loading a save and the
# runtime addition of an online marker all follow the same path.
if defined?(Sprite_Character)
class Sprite_Character
unless method_defined?(:lc_camp_previous_update)
alias_method :lc_camp_previous_update, :update
def update(*args, **kwargs, &block)
result = lc_camp_previous_update(*args, **kwargs, &block)
lc_camp_update_label
result
end
def lc_camp_update_label
game_event = @character
prefix = LonaCraft::Bases::MARKER_PREFIX
name = game_event && game_event.respond_to?(:name) ? game_event.name.to_s : ''
unless name.start_with?(prefix)
@lc_camp_label.visible = false if @lc_camp_label && !@lc_camp_label.disposed?
return
end
id = name[prefix.length..-1].to_i
rec = LonaCraft::Bases.record_by_id(id)
label = rec ? LonaCraft::Bases.name_of(rec).to_s : ''
if label.empty?
@lc_camp_label.visible = false if @lc_camp_label && !@lc_camp_label.disposed?
return
end
if @lc_camp_label.nil? || @lc_camp_label.disposed?
@lc_camp_label = Sprite.new(viewport)
@lc_camp_label.ox = 240
@lc_camp_label.oy = 32
end
if @lc_camp_label_text != label
old_bitmap = @lc_camp_label.bitmap
old_bitmap.dispose if old_bitmap && !old_bitmap.disposed?
bitmap = Bitmap.new(480, 32)
LonaCraft.apply_ui_font(bitmap)
bitmap.font.size = 18
bitmap.draw_text(0, 0, 480, 30, label, 1)
@lc_camp_label.bitmap = bitmap
@lc_camp_label_text = label
end
@lc_camp_label.x = x
@lc_camp_label.y = y - 25
@lc_camp_label.z = z + 10
@lc_camp_label.visible = visible && opacity > 0
rescue StandardError
# Map rendering must never crash because of a cosmetic label.
end
alias_method :lc_camp_previous_dispose, :dispose
def dispose(*args, **kwargs, &block)
if @lc_camp_label && !@lc_camp_label.disposed?
bmp = @lc_camp_label.bitmap
@lc_camp_label.dispose
bmp.dispose if bmp && !bmp.disposed?
end
lc_camp_previous_dispose(*args, **kwargs, &block)
end
end
end
end