Files
LonaRPG-Online-Games/ModScripts/multiplayer/09_master_tick.rb
T

535 lines
17 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
module WebSocket
FULL_EVENT_SNAPSHOT_BATCH = 12
def self.net_event_line(wire, priority=false)
if respond_to?(:send_world_line)
send_world_line(wire, priority)
else
send_line(wire)
end
rescue
send_line(wire) rescue nil
end
def self.map_sync_authority?
return true if map_master?
return local_map_authority_fallback? if respond_to?(:local_map_authority_fallback?)
false
rescue
false
end
def self.pvp_arena_synced_event_id(eid, ev)
return eid.to_i if ev.nil?
slot_id = nil
begin
slot_id = ev.instance_variable_get(:@mp_pvp_arena_slot).to_i
rescue
slot_id = nil
end
return eid.to_i if slot_id.nil? || slot_id <= 0
base = nil
begin
base = WebSocket::PVP_ARENA_NET_EVENT_ID_BASE if defined?(WebSocket::PVP_ARENA_NET_EVENT_ID_BASE)
rescue
base = nil
end
base = 900000 if base.nil? || base.to_i <= SERVER_DYNAMIC_EVENT_ID_BASE
base.to_i + slot_id.to_i
rescue
eid.to_i
end
#==========================================================================
# NPC OWNER SYNC (no tags)
#--------------------------------------------------------------------------
# - Syncs NPC events (Game_Event with npc?) without any [NET] tag.
# - Current NPC owner sends: move + hp/max_hp + AI + target + npc_type.
# - Ownership is assigned by server (target player first, else nearest).
#==========================================================================
#--------------------------------------------------------------------------
# Is this map event an NPC we should sync?
#--------------------------------------------------------------------------
def self.npc_event?(ev)
return false unless ev
begin
return false if ev.respond_to?(:erased?) && ev.erased?
rescue
return false
end
begin
return false if ev.id.to_i >= DROP_EVENT_ID_BASE
rescue
end
# skip remote-dynamic placeholder events (created from server)
begin
sid = ev.instance_variable_get(:@net_server_event_id) rescue nil
return false if sid && !pvp_arena_remote_npc?(ev)
rescue
end
begin
return ev.npc? if ev.respond_to?(:npc?)
rescue
end
# fallback: ignore net helper events
begin
n = (ev.event && ev.event.name) ? ev.event.name.to_s : ""
return false if n.start_with?("Net_Player_")
return false if n.start_with?("NetDrop_")
rescue
end
# heuristics (graphic + priority as character, not autorun/parallel)
begin
page = nil
if ev.event && ev.event.pages && ev.event.pages.size > 0
idx = (ev.instance_variable_get(:@page_index) rescue 0).to_i
idx = 0 if idx < 0
idx = ev.event.pages.size - 1 if idx >= ev.event.pages.size
page = ev.event.pages[idx] rescue nil
end
if page
g = page.graphic rescue nil
has_graphic = (g && g.character_name && g.character_name.to_s != "")
is_character = (page.priority_type.to_i == 1)
not_parallel = (page.trigger.to_i != 3 && page.trigger.to_i != 4)
return true if has_graphic && is_character && not_parallel
end
rescue
end
false
end
#--------------------------------------------------------------------------
# NPC type fingerprint (full snapshot + periodic refresh)
#--------------------------------------------------------------------------
def self.npc_type_of_event(ev)
begin
if ev.respond_to?(:npc) && (n = ev.npc)
return n.npc_name.to_s if n.respond_to?(:npc_name)
return n.name.to_s if n.respond_to?(:name)
end
rescue
end
begin
return (ev.event && ev.event.name) ? ev.event.name.to_s : ""
rescue
end
""
end
def self.map_state_event?(ev)
return false unless ev
begin
return false if ev.id.to_i >= DROP_EVENT_ID_BASE
rescue
end
begin
sid = ev.instance_variable_get(:@net_server_event_id) rescue nil
return false if sid
rescue
end
begin
n = (ev.event && ev.event.name) ? ev.event.name.to_s : ""
return false if n.start_with?("Net_Player_")
return false if n.start_with?("NetDrop_")
return false if n.start_with?("NetEvent_")
rescue
end
# Doors, transfers, chests and quest events are player-local in LonaRPG.
# Only deliberately tagged shared events may replicate page/erase/position.
return false unless explicit_net_event?(ev)
begin
return false if npc_event?(ev)
rescue
end
begin
return true if ev.respond_to?(:erased?) && ev.erased?
rescue
end
begin
page = nil
if ev.event && ev.event.pages && ev.event.pages.size > 0
idx = (ev.instance_variable_get(:@page_index) rescue 1).to_i - 1
idx = 0 if idx < 0
idx = ev.event.pages.size - 1 if idx >= ev.event.pages.size
page = ev.event.pages[idx] rescue nil
end
return false unless page
g = page.graphic rescue nil
has_graphic = (g && ((g.character_name && g.character_name.to_s != "") || g.tile_id.to_i > 0))
not_parallel = (page.trigger.to_i != 3 && page.trigger.to_i != 4)
has_graphic && not_parallel
rescue
false
end
end
def self.extract_map_event_state(ev)
page_idx = (ev.instance_variable_get(:@page_index) rescue 0).to_i
erased = 0
begin
erased = (ev.respond_to?(:erased?) && ev.erased?) ? 1 : 0
rescue
end
transparent = 0
begin
transparent = ev.transparent ? 1 : 0 if ev.respond_to?(:transparent)
rescue
transparent = (ev.instance_variable_get(:@transparent) rescue false) ? 1 : 0
end
through = (ev.instance_variable_get(:@through) rescue false) ? 1 : 0
direction_fix = (ev.instance_variable_get(:@direction_fix) rescue false) ? 1 : 0
walk_anime = (ev.instance_variable_get(:@walk_anime) rescue false) ? 1 : 0
step_anime = (ev.instance_variable_get(:@step_anime) rescue false) ? 1 : 0
pattern = (ev.instance_variable_get(:@pattern) rescue 0).to_i
[ev.x.to_i, ev.y.to_i, ev.direction.to_i, pattern, page_idx, erased, transparent, through, direction_fix, walk_anime, step_anime]
rescue
[0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]
end
def self.net_sync_map_state_event_send(eid, ev, full=false)
return unless map_sync_authority?
return unless map_state_event?(ev)
@map_event_state_cache ||= {}
sid = eid.to_i
st = extract_map_event_state(ev)
sig = st.join(":")
return if !full && @map_event_state_cache[sid] == sig
@map_event_state_cache[sid] = sig
x, y, dir, pat, page_idx, erased, transparent, through, direction_fix, walk_anime, step_anime = st
net_event_line("event_move:#{sid}:#{x}:#{y}:#{dir}:#{pat}")
net_event_line("event_state:#{sid}:page:#{page_idx}") if page_idx > 0
net_event_line("event_state:#{sid}:erased:#{erased}")
net_event_line("event_state:#{sid}:transparent:#{transparent}")
net_event_line("event_state:#{sid}:through:#{through}")
net_event_line("event_state:#{sid}:direction_fix:#{direction_fix}")
net_event_line("event_state:#{sid}:walk_anime:#{walk_anime}")
net_event_line("event_state:#{sid}:step_anime:#{step_anime}")
rescue
end
#--------------------------------------------------------------------------
# Extract hp / max_hp from real NPC if present, else from cached net vars
#--------------------------------------------------------------------------
def self.extract_event_hp(ev)
hp = nil
maxhp = nil
begin
if ev.respond_to?(:npc) && (n = ev.npc)
hp = n.health rescue nil
begin
if n.respond_to?(:battle_stat) && n.battle_stat && defined?(ActorStat)
maxhp = n.battle_stat.get_stat("health", ActorStat::MAX_STAT) rescue nil
end
rescue
end
end
rescue
end
begin
hp = ev.instance_variable_get(:@net_hp) if hp.nil?
maxhp = ev.instance_variable_get(:@net_max_hp) if maxhp.nil?
rescue
end
[hp, maxhp]
end
#--------------------------------------------------------------------------
# Resolve target character to network player_id (>0) when possible.
#--------------------------------------------------------------------------
def self.target_player_id_from_character(ch, depth=0)
return 0 if ch.nil?
begin
if ch.is_a?(Numeric)
pid = ch.to_i
return pid if pid > 0
return 0
end
rescue
end
begin
return @my_id.to_i if !@my_id.nil? && ch == $game_player
rescue
end
begin
if ch.instance_variable_defined?(:@net_player_id)
pid = ch.instance_variable_get(:@net_player_id).to_i
return pid if pid > 0
end
rescue
end
begin
if !@my_id.nil? && $game_player && ch.respond_to?(:actor) && $game_player.respond_to?(:actor)
return @my_id.to_i if ch.actor == $game_player.actor
end
rescue
end
begin
if depth.to_i < 1 && ch.respond_to?(:map_token)
token = ch.map_token
if !token.nil? && token != ch
pid = target_player_id_from_character(token, depth.to_i + 1)
return pid if pid > 0
end
end
rescue
end
0
end
#--------------------------------------------------------------------------
# Extract current NPC target player_id from runtime state.
#--------------------------------------------------------------------------
def self.extract_event_target_id(ev)
return 0 if ev.nil?
npc = nil
begin
npc = ev.npc if ev.respond_to?(:npc)
rescue
npc = nil
end
candidates = []
begin
candidates << npc.fucker_target if npc && npc.respond_to?(:fucker_target)
rescue
end
begin
candidates << npc.target if npc && npc.respond_to?(:target)
rescue
end
begin
candidates << ev.instance_variable_get(:@net_target_id) if ev.instance_variable_defined?(:@net_target_id)
rescue
end
candidates.each do |candidate|
pid = target_player_id_from_character(candidate)
return pid if pid.to_i > 0
end
0
rescue
0
end
#--------------------------------------------------------------------------
# Extract runtime AI state from Game_Event
#--------------------------------------------------------------------------
def self.extract_event_ai(ev)
to_i_safe = lambda do |v, d|
begin
return v.to_i if v.is_a?(Numeric)
return d if v.is_a?(Symbol)
return v.to_i if v.respond_to?(:to_i)
rescue
end
d
end
ms_raw = (ev.respond_to?(:move_speed) ? ev.move_speed : (ev.instance_variable_get(:@move_speed) rescue 4)) rescue 4
mf_raw = (ev.respond_to?(:move_frequency) ? ev.move_frequency : (ev.instance_variable_get(:@move_frequency) rescue 3)) rescue 3
mt_raw = (ev.respond_to?(:move_type) ? ev.move_type : (ev.instance_variable_get(:@move_type) rescue 0)) rescue 0
ms = to_i_safe.call(ms_raw, 4)
mf = to_i_safe.call(mf_raw, 3)
# In Lona some NPCs/events can have Symbol move_type (e.g. :move_type_return).
# Encode it as a single token without ':' so our protocol stays stable.
mt = if mt_raw.is_a?(Symbol)
"sym_#{mt_raw.to_s}"
elsif mt_raw.is_a?(String) && mt_raw.start_with?("sym_")
mt_raw
elsif mt_raw.is_a?(Numeric)
mt_raw.to_i
else
to_i_safe.call(mt_raw, 0)
end
df = (ev.instance_variable_get(:@direction_fix) rescue false) ? 1 : 0
th = (ev.instance_variable_get(:@through) rescue false) ? 1 : 0
wa = (ev.instance_variable_get(:@walk_anime) rescue false) ? 1 : 0
sa = (ev.instance_variable_get(:@step_anime) rescue false) ? 1 : 0
sc = to_i_safe.call((ev.instance_variable_get(:@stop_count) rescue 0), 0)
wc = to_i_safe.call((ev.instance_variable_get(:@wait_count) rescue 0), 0)
mri = to_i_safe.call((ev.instance_variable_get(:@move_route_index) rescue 0), 0)
mrf = (ev.instance_variable_get(:@move_route_forcing) rescue false) ? 1 : 0
[ms, mf, mt, df, th, wa, sa, sc, wc, mri, mrf]
end
#--------------------------------------------------------------------------
# Send one NPC snapshot/tick packet set
#--------------------------------------------------------------------------
def self.net_sync_event_send(eid, ev, full=false, force_ai=false)
@event_cache ||= {}
@event_ai_cache ||= {}
@event_target_cache ||= {}
@event_type_cache ||= {}
@event_dead_cache ||= {}
sid = pvp_arena_synced_event_id(eid, ev)
owner_me = npc_owned_by_me?(eid)
return unless owner_me
# Send the NPC type first and repeat it with the periodic AI refresh. The
# receiver uses it as a fingerprint before accepting movement or health for
# a static map event id.
t = npc_type_of_event(ev).to_s
if full || force_ai || @event_type_cache[sid] != t
@event_type_cache[sid] = t
net_event_line("npc_type:#{sid}:#{esc(t)}")
end
pat = (ev.instance_variable_get(:@pattern) rescue 0).to_i
hp, maxhp = extract_event_hp(ev)
dead = false
begin
npc = ev.npc if ev.respond_to?(:npc)
dead ||= npc && npc.respond_to?(:action_state) && npc.action_state == :death
rescue
end
dead ||= (!hp.nil? && hp.to_i <= 0 && !maxhp.nil? && maxhp.to_i > 0)
if dead
unless @event_dead_cache[sid]
@event_dead_cache[sid] = true
net_event_line("event_move:#{sid}:#{ev.x}:#{ev.y}:#{ev.direction}:#{pat}", true)
net_event_line("event_state:#{sid}:max_hp:#{maxhp.to_i}", true) unless maxhp.nil?
net_event_line("event_state:#{sid}:hp:0", true)
net_event_line("event_state:#{sid}:state:death", true)
net_event_line("event_state:#{sid}:dead:1", true)
end
return
else
@event_dead_cache.delete(sid) rescue nil
end
sig = "#{ev.x}:#{ev.y}:#{ev.direction}:#{pat}:#{hp.to_i}:#{maxhp.to_i}"
if (full || @event_cache[sid] != sig)
@event_cache[sid] = sig
net_event_line("event_move:#{sid}:#{ev.x}:#{ev.y}:#{ev.direction}:#{pat}")
net_event_line("event_state:#{sid}:max_hp:#{maxhp.to_i}") unless maxhp.nil?
net_event_line("event_state:#{sid}:hp:#{hp.to_i}") unless hp.nil?
end
ai = extract_event_ai(ev)
ai_sig = ai.join(":")
if full || force_ai || @event_ai_cache[sid] != ai_sig
@event_ai_cache[sid] = ai_sig
net_event_line("event_ai:#{sid}:#{ai_sig}")
end
target_pid = extract_event_target_id(ev).to_i
if full || @event_target_cache[sid] != target_pid
@event_target_cache[sid] = target_pid
net_event_line("event_state:#{sid}:target:#{target_pid}")
end
end
#--------------------------------------------------------------------------
# Full snapshot (map enter / master switch)
#--------------------------------------------------------------------------
def self.prepare_net_sync_events_full
return unless map_sync_authority?
return unless $game_map && $game_map.events
@event_cache = {}
@event_ai_cache = {}
@event_target_cache = {}
@event_type_cache = {}
@event_dead_cache = {}
@map_event_state_cache = {}
@full_event_sync_queue = []
$game_map.events.each do |eid, ev|
if npc_event?(ev)
@full_event_sync_queue << [:npc, eid, ev]
elsif map_state_event?(ev)
@full_event_sync_queue << [:map_state, eid, ev]
end
end
end
def self.net_sync_events_full
prepare_net_sync_events_full
end
def self.net_sync_events_full_step
return false unless map_sync_authority?
q = @full_event_sync_queue
return false if q.nil? || q.empty?
sent = 0
while sent < FULL_EVENT_SNAPSHOT_BATCH && !q.empty?
kind, eid, ev = q.shift
next if ev.nil?
if kind == :npc
next unless npc_event?(ev)
net_sync_event_send(eid, ev, true, true)
else
next unless map_state_event?(ev)
net_sync_map_state_event_send(eid, ev, true)
end
sent += 1
end
@full_event_sync_queue = nil if q.empty?
true
rescue
@full_event_sync_queue = nil
false
end
#--------------------------------------------------------------------------
# Tick sync (master only)
#--------------------------------------------------------------------------
def self.net_sync_events_tick
return unless $game_map && $game_map.events
@net_tick ||= 0
@net_tick += 1
# first tick after becoming master / map change -> full snapshot
if @need_master_sync && map_sync_authority?
@need_master_sync = false
prepare_net_sync_events_full
end
if net_sync_events_full_step
return
end
# 10 FPS sync
return if (@net_tick % 6) != 0
force_ai = ((@net_tick % 60) == 0) # ~1 sec
$game_map.events.each do |eid, ev|
if npc_event?(ev)
next unless map_master? || npc_owned_by_me?(eid)
net_sync_event_send(eid, ev, false, force_ai)
elsif map_sync_authority? && map_state_event?(ev)
net_sync_map_state_event_send(eid, ev, false)
end
end
end
end