536 lines
17 KiB
Ruby
536 lines
17 KiB
Ruby
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
|