Files
LonaRPG-Online-Games/ModScripts/100008_CorpseRecovery.rb
T
2026-10-29 21:59:06 +04:00

1803 lines
58 KiB
Ruby

# encoding: UTF-8
#==============================================================================
# 100008_CorpseRecovery.rb
# CorpseRecovery 1.1.3 client bridge for LonaRPG Online.
#
# - Sends a protected pre-respawn corpse snapshot on Scene_Gameover.
# - Shows corpse marker with the same VIP emoji renderer (☠) + real-time timer.
# - Owner can press C near the corpse to restore the saved character state.
# - After 15 protected minutes other players can loot only additive equipment,
# items and physical coins; their character/quest state is never replaced.
# - Map002 shows the same skull at the entrance of the corpse's interior map.
# - Death respawn goes to NoerSewer. New accounts are directed to TutorialOP
# by the server plugin through bootstrap_map/bootstrap_pos.
#==============================================================================
begin
require 'base64'
rescue LoadError
end
module MPCorpseRecovery
SKULL = "💀"
MARKER_WIDTH = 118
MARKER_HEIGHT = 30
TOP_HUD_WIDTH = 58
TOP_HUD_HEIGHT = 24
TOP_HUD_Y = 6
DEATH_ACK_WAIT_FRAMES = 240
MAX_WIRE_CHARS = 240_000
MAX_BODY_CHARS = 90_000
OVERMAP_MAP_ID = 2
TUTORIAL_MAP_ID = 139
TUTORIAL_X = 0
TUTORIAL_Y = 0
TUTORIAL_DIRECTION = 2
@corpses = {}
@death_pending = false
@death_deadline_frame = 0
@death_corpse_id = nil
@restore_pending_id = nil
@restore_save_pending_id = nil
@restore_save_next_retry_frame = 0
@restore_save_attempts = 0
@public_loot_pending_id = nil
@public_loot_save_pending_id = nil
@public_loot_save_next_retry_frame = 0
@public_loot_save_attempts = 0
@public_loot_applied = {}
@restore_loot_applied = {}
@last_claim_at = 0.0
@new_registration_tutorial = false
@new_registration_tutorial_consumed = false
@post_death_reset_save = false
@tutorial_initial_save = false
@server_clock_server_ms = 0
@server_clock_local_ms = 0
module_function
def now_ms
(Time.now.to_f * 1000.0).to_i
rescue
0
end
# Monotonic clock is used only to animate the visible countdown. The server
# remains authoritative for expiration. A server timestamp received with each
# corpse packet calibrates this clock, so different PC wall clocks do not
# skew the HUD timer.
def monotonic_ms
begin
if defined?(Process) && Process.respond_to?(:clock_gettime) && defined?(Process::CLOCK_MONOTONIC)
return (Process.clock_gettime(Process::CLOCK_MONOTONIC).to_f * 1000.0).to_i
end
rescue
end
now_ms
rescue
now_ms
end
def calibrate_server_clock(server_now_ms)
value = server_now_ms.to_i
return false if value <= 0
@server_clock_server_ms = value
@server_clock_local_ms = monotonic_ms
true
rescue
false
end
def display_server_now_ms
base = @server_clock_server_ms.to_i
local = @server_clock_local_ms.to_i
return now_ms if base <= 0 || local <= 0
base + [monotonic_ms - local, 0].max
rescue
now_ms
end
def frame_now
Graphics.frame_count.to_i
rescue
0
end
def connected?
defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
rescue
false
end
def notify(text, type=:info)
begin
if defined?(System_NotificationOverlay)
if type == :error && System_NotificationOverlay.respond_to?(:error)
System_NotificationOverlay.error(text.to_s)
return
elsif type == :success && System_NotificationOverlay.respond_to?(:success)
System_NotificationOverlay.success(text.to_s)
return
elsif System_NotificationOverlay.respond_to?(:notify)
System_NotificationOverlay.notify(text.to_s, type)
return
end
end
rescue
end
puts "[CORPSE] #{text}" rescue nil
end
def current_map_id
($game_map && $game_map.map_id.to_i) rescue 0
end
# LastOverMapX/Y are written immediately before the base game enters a tag or
# region map. Send that entrance tile with the protected death snapshot so the
# server can persist it and Map002 can point at an indoor/sub-map corpse.
def capture_death_overmap_origin(death_map_id, death_x, death_y)
if death_map_id.to_i == OVERMAP_MAP_ID
return {
"map_id" => OVERMAP_MAP_ID,
"x" => death_x.to_i,
"y" => death_y.to_i
}
end
story = nil
begin
story = $story_stats if defined?($story_stats)
rescue
story = nil
end
return nil if story.nil? || !story.respond_to?(:[])
return nil unless story["OverMapID"].to_i == OVERMAP_MAP_ID
x = story["LastOverMapX"].to_i
y = story["LastOverMapY"].to_i
return nil if x < 0 || y < 0
{ "map_id" => OVERMAP_MAP_ID, "x" => x, "y" => y }
rescue
nil
end
# Build a corpse body blob that prioritizes quest/mission progress.
# Normal live-sync already includes quest keys in body.story_stats, but the
# corpse path must never silently drop them just because the wider body blob
# grew large. If the full body cannot fit, fall back to a quest-only body.
def collect_quest_story_state
out = {}
story = nil
begin
story = $story_stats if defined?($story_stats)
rescue
story = nil
end
return out if story.nil?
source = nil
begin
source = story.data if story.respond_to?(:data)
rescue
source = nil
end
source = story if !source.is_a?(Hash) && story.is_a?(Hash)
return out unless source && source.respond_to?(:each)
source.each do |raw_key, raw_value|
key = raw_key.to_s
next if key.empty?
is_quest = false
begin
is_quest = MPQuestCloudState.quest_key?(key) if defined?(MPQuestCloudState) && MPQuestCloudState.respond_to?(:quest_key?)
rescue
is_quest = false
end
next unless is_quest
value = raw_value
begin
if WebSocket.respond_to?(:_live_sync_body_safe_value)
value = WebSocket._live_sync_body_safe_value(raw_value)
end
rescue
value = raw_value
end
out[key] = value unless value.nil?
break if out.length >= 4096
end
out
rescue
{}
end
def pack_body_object(obj, label)
return "" unless obj.is_a?(Hash)
begin
if WebSocket.respond_to?(:_live_sync_blob_from_object)
return WebSocket._live_sync_blob_from_object(obj, MAX_BODY_CHARS, label.to_s).to_s
end
rescue
end
""
end
def quest_only_body_blob
quests = collect_quest_story_state
return "" if quests.empty?
pack_body_object({ "schema" => 3, "story_stats" => quests }, "corpse_quests")
rescue
""
end
def prioritized_body_blob(actor, original_blob)
original = original_blob.to_s
return original if !original.empty? && original.length <= MAX_BODY_CHARS
begin
if WebSocket.respond_to?(:_live_sync_collect_body)
full = WebSocket._live_sync_collect_body(actor)
packed = pack_body_object(full, "corpse_body")
return packed unless packed.empty?
end
rescue
end
quest_only_body_blob
rescue
quest_only_body_blob
end
# Survival resources are deliberately NOT part of corpse recovery. The
# corpse contains death-time values (usually health/STA close to zero), but
# picking it up must keep the resources of the CURRENT living character.
#
# Lona has two different health values: RGSS actor.hp and Lona's own
# actor.health stored in @actStat. The HUD/gameplay uses actor.health, so both
# must be protected. STA and satiety live in @actStat as well.
def active_local_actor
actor = nil
begin
actor = $game_player.actor if defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
rescue
actor = nil
end
begin
actor = $game_party.members[0] if actor.nil? && defined?($game_party) && $game_party && $game_party.respond_to?(:members)
rescue
end
actor
rescue
nil
end
def current_survival_resources
actor = active_local_actor
return {} if actor.nil?
out = {}
begin; out["hp"] = actor.hp if actor.respond_to?(:hp); rescue; end
begin; out["health"] = actor.health if actor.respond_to?(:health); rescue; end
begin; out["sta"] = actor.sta if actor.respond_to?(:sta); rescue; end
begin; out["sat"] = actor.sat if actor.respond_to?(:sat); rescue; end
out
rescue
{}
end
def survival_current_stat_index
begin
return ActorStat::CURRENT_STAT.to_i if defined?(ActorStat::CURRENT_STAT)
rescue
end
0
rescue
0
end
# The bootstrap stats blob contains the whole @actStat table and is applied
# AFTER the top-level hp/sta/sat fields. If it is left untouched it can put
# the corpse's zero health/STA straight back into the living character.
# Replace only CURRENT resource values; max/min/base stats still come from
# the recovered corpse as intended.
def protect_survival_in_restore_payload(payload, snapshot)
return unless payload.is_a?(Hash) && snapshot.is_a?(Hash)
payload["hp"] = snapshot["hp"] if snapshot.has_key?("hp")
payload["sta"] = snapshot["sta"] if snapshot.has_key?("sta")
payload["sat"] = snapshot["sat"] if snapshot.has_key?("sat")
stats = payload["stats_json"]
if stats.is_a?(Hash)
full = stats["act_stat_full"]
idx = survival_current_stat_index
{ "health" => "health", "sta" => "sta", "sat" => "sat" }.each do |stat_key, snap_key|
next unless snapshot.has_key?(snap_key)
value = snapshot[snap_key]
stats[stat_key] = value
next unless full.is_a?(Hash) && full.has_key?(stat_key)
row = full[stat_key]
if row.is_a?(Array)
row[idx] = value if idx >= 0 && idx < row.length
else
full[stat_key] = value
end
end
end
# This normally does not contain these keys, but sanitize them too so a
# future body schema cannot accidentally re-introduce death resources.
body = payload["body_json"]
if body.is_a?(Hash) && body["body_stats"].is_a?(Hash)
body_stats = body["body_stats"]
["health", "sta", "sat"].each do |key|
body_stats[key] = snapshot[key] if snapshot.has_key?(key) && body_stats.has_key?(key)
end
end
rescue => e
puts "[CORPSE] survival payload protection failed: #{e.class}: #{e.message}" rescue nil
end
def restore_survival_resources(snapshot)
return unless snapshot.is_a?(Hash)
# Re-acquire the actor AFTER bootstrap. Some restore/bootstrap paths may
# replace the local actor object, so keeping the pre-apply object reference
# is not reliable.
actor = active_local_actor
return if actor.nil?
begin
if snapshot.has_key?("health")
if actor.respond_to?(:health=)
actor.health = snapshot["health"]
else
act_stat = actor.instance_variable_get(:@actStat) rescue nil
act_stat.set_stat("health", snapshot["health"], survival_current_stat_index) if act_stat && act_stat.respond_to?(:set_stat)
end
end
rescue
end
begin
if snapshot.has_key?("sta")
if actor.respond_to?(:sta=)
actor.sta = snapshot["sta"]
else
act_stat = actor.instance_variable_get(:@actStat) rescue nil
act_stat.set_stat("sta", snapshot["sta"], survival_current_stat_index) if act_stat && act_stat.respond_to?(:set_stat)
end
end
rescue
end
begin
if snapshot.has_key?("sat")
if actor.respond_to?(:sat=)
actor.sat = snapshot["sat"]
else
act_stat = actor.instance_variable_get(:@actStat) rescue nil
act_stat.set_stat("sat", snapshot["sat"], survival_current_stat_index) if act_stat && act_stat.respond_to?(:set_stat)
end
end
rescue
end
begin
if snapshot.has_key?("hp")
if actor.respond_to?(:hp=)
actor.hp = snapshot["hp"]
else
actor.instance_variable_set(:@hp, snapshot["hp"])
end
end
rescue
end
begin
actor.instance_variable_set(:@stat_changed, true)
rescue
end
rescue
end
def submit_death_snapshot
@death_pending = false
@death_corpse_id = nil
return false unless connected?
return false unless defined?($game_map) && $game_map
return false unless defined?($game_player) && $game_player
return false unless WebSocket.respond_to?(:_live_sync_build_packet)
built = WebSocket._live_sync_build_packet rescue nil
base = if built.is_a?(Array)
built[0].to_s
else
built.to_s
end
return false if base.empty?
parts = base.split(":", -1)
return false if parts.length < 16 || parts[0].to_s != "sync_state"
map_id = current_map_id
x = $game_player.x.to_i rescue 0
y = $game_player.y.to_i rescue 0
dir = $game_player.direction.to_i rescue 2
death_overmap_origin = capture_death_overmap_origin(map_id, x, y)
actor = nil
begin
actor = $game_player.actor if $game_player.respond_to?(:actor)
rescue
actor = nil
end
begin
actor = $game_party.members[0] if actor.nil? && $game_party && $game_party.respond_to?(:members)
rescue
end
sta = 0
sat = 0
begin
sta = actor.sta.to_i if actor && actor.respond_to?(:sta)
rescue
end
begin
sat = actor.sat.to_i if actor && actor.respond_to?(:sat)
rescue
end
body = prioritized_body_blob(actor, parts[15].to_s)
packet = [
"sync_state", "corpse_death",
map_id, x, y, dir,
parts[1].to_i, # level
parts[2].to_i, # gold
[parts[4].to_i, 1].max,
sta, sat,
parts[5].to_s, # items
parts[6].to_s, # weapons
parts[7].to_s, # armors
parts[8].to_s, # equips
parts[9].to_s, # skills
parts[10].to_s, # stats / EXP / trait points
parts[12].to_s, # player meta / hotkeys
body, # body/story subset; omitted if unusually large
death_overmap_origin ? death_overmap_origin["map_id"].to_i : 0,
death_overmap_origin ? death_overmap_origin["x"].to_i : 0,
death_overmap_origin ? death_overmap_origin["y"].to_i : 0
].join(":")
if packet.length > MAX_WIRE_CHARS
# Keep mission/quest progress even when non-critical body data is large.
chunks = packet.split(":", -1)
quest_blob = quest_only_body_blob
chunks[18] = quest_blob if chunks.length > 18
packet = chunks.join(":")
end
if packet.length > MAX_WIRE_CHARS
notify("Труп не сохранён: снимок слишком большой даже после сохранения только прогресса миссий.", :error)
return false
end
result = WebSocket.send_line(packet)
ok = !result.nil? && result.to_i >= 0
if ok
@death_pending = true
@death_deadline_frame = frame_now + DEATH_ACK_WAIT_FRAMES
end
ok
rescue => e
puts "[CORPSE] death snapshot failed: #{e.class}: #{e.message}" rescue nil
false
end
def waiting_death_ack?
return false unless @death_pending
if frame_now >= @death_deadline_frame.to_i
@death_pending = false
notify("Сервер не подтвердил создание трупа. Респавн продолжен.", :error)
return false
end
true
rescue
false
end
def death_ok(id, expires_at_ms, server_now_ms=nil)
@death_pending = false
@death_corpse_id = id.to_i
calibrate_server_clock(server_now_ms) if server_now_ms.to_i > 0
notify("Труп защищён для вас на 15 минут. Затем его смогут обыскать другие игроки.", :info)
rescue
end
def decode_nick(value)
raw = value.to_s
return "Player" if raw.empty?
begin
if defined?(Base64)
pad = (4 - raw.length % 4) % 4
padded = raw.tr("-_", "+/") + ("=" * pad)
decoded = if Base64.respond_to?(:strict_decode64)
Base64.strict_decode64(padded)
elsif Base64.respond_to?(:decode64)
Base64.decode64(padded)
else
nil
end
unless decoded.nil?
decoded = decoded.to_s
decoded.force_encoding("UTF-8") if decoded.respond_to?(:force_encoding)
return decoded
end
end
rescue
end
raw
rescue
"Player"
end
def upsert_corpse(id, map_id, x, y, public_at_ms, owner, nick_b64, server_now_ms=nil,
overmap_map_id=nil, overmap_x=nil, overmap_y=nil, expires_at_ms=nil)
cid = id.to_i
return if cid <= 0
calibrate_server_clock(server_now_ms) if server_now_ms.to_i > 0
corpse = {
"id" => cid,
"map_id" => map_id.to_i,
"x" => x.to_i,
"y" => y.to_i,
"public_at_ms" => public_at_ms.to_i,
# Old 1.0.x servers sent only one expiry field. Keep that protocol valid.
"expires_at_ms" => (expires_at_ms.nil? ? public_at_ms.to_i : expires_at_ms.to_i),
"owner" => owner.to_i == 1,
"nick" => decode_nick(nick_b64)
}
if overmap_map_id.to_i == OVERMAP_MAP_ID && overmap_x.to_i >= 0 && overmap_y.to_i >= 0
corpse["overmap_origin"] = {
"map_id" => OVERMAP_MAP_ID,
"x" => overmap_x.to_i,
"y" => overmap_y.to_i
}
end
@corpses[cid] = corpse
rescue
end
def remove_corpse(id)
@corpses.delete(id.to_i)
rescue
end
def corpses_for_current_map
map_id = current_map_id
now = display_server_now_ms
out = []
@corpses.keys.each do |id|
c = @corpses[id]
next unless c.is_a?(Hash)
if c["expires_at_ms"].to_i <= now
@corpses.delete(id)
next
end
out << c if c["map_id"].to_i == map_id
end
out
rescue
[]
end
# Real corpse markers remain on their actual map. On Map002, a display-only
# proxy points at the entrance tile of the location where the death occurred.
# A proxy is never claimable from OverMap.
def marker_corpses_for_current_map
out = corpses_for_current_map
return out unless current_map_id == OVERMAP_MAP_ID
seen = {}
out.each { |corpse| seen[corpse["id"].to_i] = true if corpse.is_a?(Hash) }
now = display_server_now_ms
@corpses.each_value do |corpse|
next unless corpse.is_a?(Hash)
next if seen[corpse["id"].to_i]
next if corpse["expires_at_ms"].to_i <= now
origin = corpse["overmap_origin"]
next unless origin.is_a?(Hash) && origin["map_id"].to_i == OVERMAP_MAP_ID
proxy = corpse.dup
proxy["x"] = origin["x"].to_i
proxy["y"] = origin["y"].to_i
proxy["overmap_proxy"] = true
out << proxy
end
out
rescue
corpses_for_current_map
end
def remaining_seconds(corpse)
return 0 unless corpse.is_a?(Hash)
now = display_server_now_ms
target = corpse_public?(corpse, now) ? corpse["expires_at_ms"].to_i : corpse["public_at_ms"].to_i
left = target - now
[(left / 1000.0).ceil, 0].max
rescue
0
end
def corpse_public?(corpse, now=nil)
return false unless corpse.is_a?(Hash)
current = now.nil? ? display_server_now_ms : now.to_i
public_at = corpse["public_at_ms"].to_i
public_at > 0 && current >= public_at
rescue
false
end
def owner_corpse
now = display_server_now_ms
best = nil
@corpses.keys.each do |id|
c = @corpses[id]
next unless c.is_a?(Hash)
if c["expires_at_ms"].to_i <= now
@corpses.delete(id)
next
end
next unless c["owner"]
best = c if best.nil? || c["expires_at_ms"].to_i > best["expires_at_ms"].to_i
end
best
rescue
nil
end
def near?(corpse)
return false unless corpse.is_a?(Hash)
return false unless defined?($game_player) && $game_player
dx = ($game_player.x.to_i - corpse["x"].to_i).abs
dy = ($game_player.y.to_i - corpse["y"].to_i).abs
[dx, dy].max <= 1
rescue
false
end
def try_claim_nearby
return unless connected?
return unless defined?(Input)
return unless Input.trigger?(:C)
now = Time.now.to_f rescue 0.0
return if now > 0.0 && (now - @last_claim_at.to_f) < 0.45
target = corpses_for_current_map.find do |c|
near?(c) && (c["owner"] || corpse_public?(c))
end
return if target.nil?
@last_claim_at = now
WebSocket.send_line("corpse_claim:#{target['id']}")
rescue
end
def begin_restore(id)
@restore_pending_id = id.to_i
rescue
end
def restore_pending?
@restore_pending_id.to_i > 0
rescue
false
end
def consume_restore_packet(msg)
return false unless restore_pending?
return false unless msg.to_s.start_with?("bootstrap_state:")
parts = msg.to_s.split(":", 21)
corpse_id = @restore_pending_id.to_i
@restore_pending_id = nil
if parts.length < 20
notify("Не удалось прочитать содержимое тела. Труп не удалён.", :error)
return true
end
# A corpse is loot, never a character save. In particular, never feed its
# stale stats/skills/race/player/body fields to apply_bootstrap_state.
unless @restore_loot_applied[corpse_id]
items = WebSocket.bootstrap_parse_blob(parts[11].to_s, true) rescue {}
weapons = WebSocket.bootstrap_parse_blob(parts[12].to_s, true) rescue {}
armors = WebSocket.bootstrap_parse_blob(parts[13].to_s, true) rescue {}
equips = WebSocket.bootstrap_parse_blob(parts[14].to_s, false) rescue {}
begin
WebSocket._bootstrap_gain_hash("item", items) if WebSocket.respond_to?(:_bootstrap_gain_hash)
WebSocket._bootstrap_gain_hash("weapon", weapons) if WebSocket.respond_to?(:_bootstrap_gain_hash)
WebSocket._bootstrap_gain_hash("armor", armors) if WebSocket.respond_to?(:_bootstrap_gain_hash)
gain_public_equip_items(equips)
rescue => e
puts "[CORPSE] owner loot apply failed: #{e.class}: #{e.message}" rescue nil
notify("Не удалось вернуть вещи из тела. Труп не удалён.", :error)
return true
end
@restore_loot_applied[corpse_id] = true
puts "[CORPSE] owner loot-only recovery corpse=#{corpse_id} player=#{WebSocket.instance_variable_get(:@my_id) rescue nil}" rescue nil
end
if send_compact_restore_save(corpse_id)
notify("Вещи из тела возвращены. Сохраняю на сервере…", :info)
else
notify("Вещи возвращены, но save не отправлен. Труп не удалён; попробуйте ещё раз.", :error)
end
true
rescue => e
@restore_pending_id = nil
puts "[CORPSE] restore parse failed: #{e.class}: #{e.message}" rescue nil
false
end
def begin_public_loot(id)
@public_loot_pending_id = id.to_i
rescue
end
def public_loot_pending?
@public_loot_pending_id.to_i > 0
rescue
false
end
def gain_public_equip_items(equips)
return unless equips.is_a?(Hash)
return unless defined?($game_party) && $game_party && $game_party.respond_to?(:gain_item)
equips.each_value do |raw_token|
token = raw_token.to_s.split(",", 3)
kind = token[0].to_s.strip.downcase
item_id = token[1].to_i
item_name = token[2].to_s.strip
next if kind == "none" || item_id <= 0
item = nil
begin
if !item_name.empty? && WebSocket.respond_to?(:_bootstrap_data_item_by_name)
item = WebSocket._bootstrap_data_item_by_name(item_name)
end
rescue
item = nil
end
begin
item = WebSocket._bootstrap_data_item(kind, item_id) if item.nil? && WebSocket.respond_to?(:_bootstrap_data_item)
rescue
item = nil
end
$game_party.gain_item(item, 1) unless item.nil?
end
rescue
end
# Public corpse loot is intentionally additive. It never invokes the normal
# bootstrap applier, so the looter's inventory, EXP, skills, quests, stats,
# body state, position and survival resources cannot be replaced.
def consume_public_loot_packet(msg)
return false unless public_loot_pending?
return false unless msg.to_s.start_with?("bootstrap_state:")
parts = msg.to_s.split(":", 21)
corpse_id = @public_loot_pending_id.to_i
@public_loot_pending_id = nil
if parts.length < 20
notify("Не удалось прочитать добычу из тела. Труп не удалён.", :error)
return true
end
unless @public_loot_applied[corpse_id]
items = WebSocket.bootstrap_parse_blob(parts[11].to_s, true) rescue {}
weapons = WebSocket.bootstrap_parse_blob(parts[12].to_s, true) rescue {}
armors = WebSocket.bootstrap_parse_blob(parts[13].to_s, true) rescue {}
equips = WebSocket.bootstrap_parse_blob(parts[14].to_s, false) rescue {}
begin
WebSocket._bootstrap_gain_hash("item", items) if WebSocket.respond_to?(:_bootstrap_gain_hash)
WebSocket._bootstrap_gain_hash("weapon", weapons) if WebSocket.respond_to?(:_bootstrap_gain_hash)
WebSocket._bootstrap_gain_hash("armor", armors) if WebSocket.respond_to?(:_bootstrap_gain_hash)
gain_public_equip_items(equips)
rescue => e
puts "[CORPSE] public loot apply failed: #{e.class}: #{e.message}" rescue nil
notify("Не удалось добавить добычу. Труп не удалён.", :error)
return true
end
@public_loot_applied[corpse_id] = true
end
if send_compact_public_loot_save(corpse_id)
notify("Добыча добавлена. Сохраняю её на сервере…", :info)
else
notify("Добыча добавлена, но серверный save не отправлен. Труп оставлен; попробуйте ещё раз.", :error)
end
true
rescue => e
@public_loot_pending_id = nil
puts "[CORPSE] public loot parse failed: #{e.class}: #{e.message}" rescue nil
true
end
def compact_reason(reason)
value = reason.to_s.strip.downcase.gsub(/[^a-z0-9_]+/, "_")
value = "cloud_corpse" if value.empty?
value = "cloud_#{value}" unless value.start_with?("cloud_")
value[0, 48]
rescue
"cloud_corpse"
end
def send_compact_current_save(reason)
return false unless connected?
return false unless WebSocket.respond_to?(:_live_sync_build_packet)
built = WebSocket._live_sync_build_packet rescue nil
base = built.is_a?(Array) ? built[0].to_s : built.to_s
parts = base.split(":", -1)
return false if parts.length < 13 || parts[0].to_s != "sync_state"
# Keep reason inside the first 14 server payload fields. LonaRPG 1.0.6
# parses sync_state with splitPayload(14); omitting bank/stat_pack/body makes
# the cloud reason visible to the stock dispatcher without changing Java core.
clean_reason = compact_reason(reason)
compact = [
"sync_state",
parts[1], parts[2], parts[3], parts[4],
parts[5], parts[6], parts[7], parts[8],
parts[9], parts[10], "", parts[12],
"reason=#{clean_reason}"
].join(":")
return false if compact.length > MAX_WIRE_CHARS
begin
map_id = current_map_id
line = WebSocket.respond_to?(:map_packet_for_server) ? WebSocket.map_packet_for_server(map_id) : "map:#{map_id}"
WebSocket.send_line(line) if map_id > 0
WebSocket.live_sync_position_now(clean_reason, true) if WebSocket.respond_to?(:live_sync_position_now)
rescue
end
result = WebSocket.send_line(compact)
!result.nil? && result.to_i >= 0
rescue => e
puts "[CORPSE] compact save failed: #{e.class}: #{e.message}" rescue nil
false
end
def send_compact_restore_save(corpse_id, retrying=false)
ok = send_compact_current_save("cloud_corpse_restore")
if ok
@restore_save_pending_id = corpse_id.to_i
@restore_save_attempts = retrying ? (@restore_save_attempts.to_i + 1) : 1
@restore_save_next_retry_frame = frame_now + 90
end
ok
rescue
false
end
def tick_restore_save
id = @restore_save_pending_id.to_i
return if id <= 0
return if frame_now < @restore_save_next_retry_frame.to_i
if @restore_save_attempts.to_i >= 4
@restore_save_pending_id = nil
@restore_save_attempts = 0
notify("Сервер не подтвердил сохранение восстановленного тела. Труп оставлен; подойдите и попробуйте снова.", :error)
return
end
send_compact_restore_save(id, true)
rescue
end
def send_compact_public_loot_save(corpse_id, retrying=false)
ok = send_compact_current_save("cloud_corpse_public_loot")
if ok
@public_loot_save_pending_id = corpse_id.to_i
@public_loot_save_attempts = retrying ? (@public_loot_save_attempts.to_i + 1) : 1
@public_loot_save_next_retry_frame = frame_now + 90
end
ok
rescue
false
end
def tick_public_loot_save
id = @public_loot_save_pending_id.to_i
return if id <= 0
return if frame_now < @public_loot_save_next_retry_frame.to_i
if @public_loot_save_attempts.to_i >= 4
@public_loot_save_pending_id = nil
@public_loot_save_attempts = 0
notify("Сервер не подтвердил сохранение добычи. Труп оставлен; попробуйте снова.", :error)
return
end
send_compact_public_loot_save(id, true)
rescue
end
def request_post_death_reset_save
@post_death_reset_save = true
rescue
end
def request_tutorial_initial_save
@tutorial_initial_save = true
rescue
end
def post_death_reset_save_pending?
!!@post_death_reset_save
rescue
false
end
def tutorial_initial_save_pending?
!!@tutorial_initial_save
rescue
false
end
def send_post_death_reset_save
if send_compact_current_save("cloud_corpse_death_reset")
@post_death_reset_save = false
return true
end
false
rescue
false
end
def send_tutorial_initial_save
if send_compact_current_save("cloud_tutorial_initial")
@tutorial_initial_save = false
return true
end
false
rescue
false
end
def cloud_restore_saved
id = @restore_save_pending_id.to_i
return if id <= 0
@restore_save_pending_id = nil
@restore_save_attempts = 0
@restore_save_next_retry_frame = 0
begin
WebSocket.send_line("corpse_restore_ack:#{id}") if connected?
rescue
end
rescue
end
def cloud_public_loot_saved
id = @public_loot_save_pending_id.to_i
return if id <= 0
@public_loot_save_pending_id = nil
@public_loot_save_attempts = 0
@public_loot_save_next_retry_frame = 0
begin
WebSocket.send_line("corpse_loot_ack:#{id}") if connected?
rescue
end
rescue
end
def restore_done(id)
cid = id.to_i
remove_corpse(cid)
@restore_loot_applied.delete(cid)
notify("💀 Тело подобрано: вещи возвращены, текущее развитие персонажа сохранено.", :success)
rescue
end
def public_loot_done(id)
cid = id.to_i
remove_corpse(cid)
@public_loot_applied.delete(cid)
notify("💀 Чужое тело обыскано: предметы, оружие, броня и монеты добавлены к вашему инвентарю.", :success)
rescue
end
def claim_error(code)
@restore_pending_id = nil
@public_loot_pending_id = nil
text = case code.to_s
when "too_far" then "Подойдите ближе к телу."
when "wrong_map" then "Тело находится на другой карте."
when "expired", "not_found" then "Это тело уже исчезло."
when "not_owner" then "Можно подобрать только собственное тело."
when "protected" then "Тело пока защищено владельцем."
when "busy" then "Это тело сейчас обыскивает другой игрок."
when "restore_too_large" then "Снимок тела слишком большой для восстановления."
else "Тело пока нельзя подобрать (#{code})."
end
notify(text, :error)
rescue
end
def mark_new_registration_tutorial(reset_consumed=true)
@new_registration_tutorial = true
# auth_ok:created starts a genuinely new registration. A later helper
# packet must not re-arm TutorialOP after the first bootstrap was consumed.
@new_registration_tutorial_consumed = false if reset_consumed
rescue
end
def new_registration_tutorial?
!!@new_registration_tutorial && !tutorial_bootstrap_consumed?
rescue
false
end
def tutorial_bootstrap_consumed?
!!@new_registration_tutorial_consumed
rescue
false
end
def finish_new_registration_tutorial
@new_registration_tutorial = false
@new_registration_tutorial_consumed = true
@post_death_reset_save = false
@tutorial_initial_save = true
rescue
end
def tutorial_new(map_id, x, y, direction)
begin
WebSocket.set_bootstrap_map(map_id.to_i) if WebSocket.respond_to?(:set_bootstrap_map)
WebSocket.set_bootstrap_position(x.to_i, y.to_i, direction.to_i) if WebSocket.respond_to?(:set_bootstrap_position)
rescue
end
rescue
end
#--------------------------------------------------------------------------
# Owner corpse HUD: always fixed at the top-center of the screen. It uses the
# real VIP skull asset (U+1F480 / 1f480.png) and the authoritative server
# expiration timestamp. This is display-only; server cleanup remains final.
#--------------------------------------------------------------------------
class TopHud
def initialize
@last_id = 0
@last_second = -1
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 10_000
@panel = Sprite.new(@viewport)
@panel.bitmap = Bitmap.new(TOP_HUD_WIDTH, TOP_HUD_HEIGHT)
@panel.x = (Graphics.width - TOP_HUD_WIDTH) / 2
@panel.y = TOP_HUD_Y
@panel.z = 1
@skull_left = Sprite.new(@viewport)
@skull_right = Sprite.new(@viewport)
@skull_left.z = 2
@skull_right.z = 2
render_skull(@skull_left)
render_skull(@skull_right)
hide
rescue
end
def render_skull(sprite)
return if sprite.nil?
rendered = false
begin
rendered = !!MPNickEmoji.redraw_sprite(sprite, SKULL, 16) if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:redraw_sprite)
rescue
rendered = false
end
unless rendered
bmp = Bitmap.new(22, 22)
begin
bmp.font.name = MPNickEmoji.font_name if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:font_name)
rescue
end
bmp.font.size = 16
bmp.draw_text(0, 0, 22, 22, SKULL, 1)
sprite.bitmap = bmp
sprite.ox = 11
sprite.oy = 22
end
rescue
end
def hide
@panel.visible = false if @panel
@skull_left.visible = false if @skull_left
@skull_right.visible = false if @skull_right
rescue
end
def update
corpse = MPCorpseRecovery.owner_corpse
if corpse.nil?
@last_id = 0
@last_second = -1
hide
return
end
sec = MPCorpseRecovery.remaining_seconds(corpse)
if sec <= 0
hide
return
end
@panel.visible = true if @panel
@skull_left.visible = true if @skull_left
@skull_right.visible = true if @skull_right
# Symmetric layout: timer is exactly centered. Compared with the previous
# HUD the skull-to-clock gap is roughly halved, but they do not touch.
center = Graphics.width / 2
skull_offset = 33
@skull_left.x = center - skull_offset
@skull_left.y = TOP_HUD_Y + 21
@skull_right.x = center + skull_offset
@skull_right.y = TOP_HUD_Y + 21
id = corpse["id"].to_i
return if @last_id == id && @last_second == sec
@last_id = id
@last_second = sec
redraw(corpse, sec)
rescue
hide
end
def redraw(corpse, sec)
bmp = @panel.bitmap
return if bmp.nil?
bmp.clear
# Transparent HUD: two VIP skulls + centered timer, no background.
bmp.font.size = 13
bmp.font.bold = true
bmp.font.outline = true rescue nil
bmp.font.color = Color.new(255, 255, 255, 255) rescue nil
mins = sec / 60
secs = sec % 60
bmp.draw_text(0, 1, TOP_HUD_WIDTH, 20, "%02d:%02d" % [mins, secs], 1)
rescue
end
def dispose_sprite(sprite)
return if sprite.nil?
begin
own = sprite.bitmap
sprite.dispose unless sprite.disposed?
own.dispose if own && !own.disposed?
rescue
end
end
def dispose
dispose_sprite(@skull_left)
dispose_sprite(@skull_right)
begin
if @panel
own = @panel.bitmap
@panel.dispose unless @panel.disposed?
own.dispose if own && !own.disposed?
end
rescue
end
begin
@viewport.dispose if @viewport && !@viewport.disposed?
rescue
end
@skull_left = nil
@skull_right = nil
@panel = nil
@viewport = nil
end
end
#--------------------------------------------------------------------------
# Map marker sprite
#--------------------------------------------------------------------------
class Marker
def initialize(corpse, viewport=nil)
@corpse = corpse
@last_second = nil
@last_near = nil
# OverMap proxy markers are skull-only. The marker is recreated when the
# player changes map / switches between OverMap and a normal map, so a
# real corpse on a normal map gets its nickname, timer and action text.
@overmap = !!@corpse["overmap_proxy"]
@skull = Sprite.new(viewport)
@label = nil
unless @overmap
@label = Sprite.new(viewport)
@label.bitmap = Bitmap.new(MARKER_WIDTH, MARKER_HEIGHT)
@label.z = 239
end
@skull.z = 240
begin
rendered = false
if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:redraw_sprite)
rendered = !!MPNickEmoji.redraw_sprite(@skull, SKULL, 15)
end
unless rendered
bmp = Bitmap.new(22, 22)
bmp.font.name = MPNickEmoji.font_name if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:font_name)
bmp.font.size = 15
bmp.draw_text(0, 0, 22, 22, SKULL, 1)
@skull.bitmap = bmp
@skull.ox = 11
@skull.oy = 22
end
rescue
end
redraw(true)
end
def id
@corpse["id"].to_i
rescue
0
end
def update(corpse)
@corpse = corpse if corpse.is_a?(Hash)
reposition
redraw(false)
rescue
end
def reposition
tile_w = 32
tile_h = 32
begin
tile_w = $game_map.tile_width.to_i if $game_map.respond_to?(:tile_width)
tile_h = $game_map.tile_height.to_i if $game_map.respond_to?(:tile_height)
rescue
end
tile_w = 32 if tile_w <= 0
tile_h = 32 if tile_h <= 0
sx = (($game_map.adjust_x(@corpse["x"].to_i) * tile_w) + tile_w / 2).to_i
sy = (($game_map.adjust_y(@corpse["y"].to_i) * tile_h) + tile_h).to_i
if @corpse["overmap_proxy"]
# Match OverMap mission-guide behavior: the skull stays visible at the
# screen edge while its location tile is outside the camera.
sx = [[sx, 32].max, Graphics.width - 32].min
sy = [[sy - 6, 32].max, Graphics.height - 32].min + 6
end
@skull.x = sx
@skull.y = sy - 6
if @label
label_x = sx - MARKER_WIDTH / 2
if @corpse["overmap_proxy"]
label_x = [[label_x, 0].max, Graphics.width - MARKER_WIDTH].min
end
@label.x = label_x
@label.y = sy - 5
end
rescue
end
def redraw(force=false)
# OverMap intentionally shows only the skull.
return if @overmap
sec = MPCorpseRecovery.remaining_seconds(@corpse)
near = !!(!@corpse["overmap_proxy"] &&
(@corpse["owner"] || MPCorpseRecovery.corpse_public?(@corpse)) &&
MPCorpseRecovery.near?(@corpse))
return if !force && @last_second == sec && @last_near == near
@last_second = sec
@last_near = near
bmp = @label.bitmap
return if bmp.nil?
bmp.clear
# Transparent corpse marker: no dark rectangle behind the text.
bmp.font.size = 10
bmp.font.bold = true
bmp.font.outline = true rescue nil
bmp.font.color = Color.new(255, 255, 255, 255) rescue nil
owner = @corpse["nick"].to_s
owner = owner[0, 16] if owner.length > 16
mins = sec / 60
secs = sec % 60
bmp.draw_text(3, 0, MARKER_WIDTH - 6, 13, "#{owner} %02d:%02d" % [mins, secs], 1)
if near
bmp.font.size = 9
action = @corpse["owner"] ? "Забрать тело" : "Обыскать тело"
bmp.draw_text(3, 13, MARKER_WIDTH - 6, 13, action, 1)
end
rescue
end
def dispose
begin
if @skull
bmp = @skull.bitmap
@skull.dispose unless @skull.disposed?
bmp.dispose if bmp && !bmp.disposed?
end
rescue
end
begin
if @label
bmp = @label.bitmap
@label.dispose unless @label.disposed?
bmp.dispose if bmp && !bmp.disposed?
end
rescue
end
@skull = nil
@label = nil
end
end
end
#==============================================================================
# Corpse restore map-entry safety.
#
# Some normal maps (for example map 20) intentionally have no "WakeUp"
# storypoint. A restored quest/body snapshot may legitimately contain
# Captured/RapeLoop progress from the moment of death. The stock
# enter_static_tag_map then assumes WakeUp exists and raises before the
# reserved corpse-position transfer can finish.
#
# Do NOT delete the mission state. We only suppress the two transient entry
# routing flags while the stock map-entry cleanup runs, then restore them.
# This keeps quest progress intact and prevents the missing-WakeUp crash.
#==============================================================================
if defined?(GIM_ADDON)
module GIM_ADDON
unless instance_methods.include?(:mp_corpse_safe_enter_static_tag_map_without_guard)
alias mp_corpse_safe_enter_static_tag_map_without_guard enter_static_tag_map
end
def enter_static_tag_map(event_id=nil, fadeout=false)
needs_guard = false
old_captured = nil
old_rape_loop = nil
begin
if event_id.nil? && defined?($story_stats) && $story_stats && defined?($game_map) && $game_map
captured = ($story_stats["Captured"].to_i == 1 rescue false)
rape_loop = ($story_stats["RapeLoop"].to_i == 1 rescue false)
if captured || rape_loop
points = ($game_map.list_storypoints rescue nil)
wake_up = (points["WakeUp"] rescue nil) if points
needs_guard = wake_up.nil?
end
end
rescue
needs_guard = false
end
return mp_corpse_safe_enter_static_tag_map_without_guard(event_id, fadeout) unless needs_guard
begin
old_captured = $story_stats["Captured"]
old_rape_loop = $story_stats["RapeLoop"]
# Skip only the stock WakeUp routing branch. The original routine still
# performs its normal map-entry cleanup, while the player remains at the
# position reserved by corpse bootstrap/transfer.
$story_stats["Captured"] = 0
$story_stats["RapeLoop"] = 0
$story_stats["ReRollHalfEvents"] = 0
puts "[CORPSE] map entry: WakeUp missing on map=#{$game_map.map_id}; preserving corpse quest state without WakeUp routing" rescue nil
mp_corpse_safe_enter_static_tag_map_without_guard(nil, fadeout)
ensure
begin
$story_stats["Captured"] = old_captured unless old_captured.nil?
$story_stats["RapeLoop"] = old_rape_loop unless old_rape_loop.nil?
$game_map.need_refresh = true if $game_map && $game_map.respond_to?(:need_refresh=)
rescue
end
end
end
end
end
#==============================================================================
# Network parser bridge
#==============================================================================
if defined?(WebSocket)
module WebSocket
class << self
alias mp_corpse_recovery_parse parse
def parse(msg)
text = msg.to_s
# auth_ok:created is the exact client-visible signal that this profile was
# registered right now. Prime TutorialOP before bootstrap_mode:new is applied.
if text == "auth_ok:created"
MPCorpseRecovery.mark_new_registration_tutorial
end
if text.start_with?("bootstrap_mode:new") && MPCorpseRecovery.new_registration_tutorial?
MPCorpseRecovery.tutorial_new(
MPCorpseRecovery::TUTORIAL_MAP_ID, MPCorpseRecovery::TUTORIAL_X,
MPCorpseRecovery::TUTORIAL_Y, MPCorpseRecovery::TUTORIAL_DIRECTION
)
# Keep the flag until MPCloudOnlySave creates the actual new-game base.
end
if text.start_with?("corpse_spawn:")
p = text.split(":", 13)
if p.length >= 8
MPCorpseRecovery.upsert_corpse(
p[1], p[2], p[3], p[4], p[5], p[6], p[7],
(p.length >= 9 ? p[8] : nil),
(p.length >= 10 ? p[9] : nil),
(p.length >= 11 ? p[10] : nil),
(p.length >= 12 ? p[11] : nil),
(p.length >= 13 ? p[12] : nil)
)
end
return
end
if text.start_with?("corpse_remove:")
p = text.split(":", 3)
MPCorpseRecovery.remove_corpse(p[1]) if p.length >= 2
return
end
if text.start_with?("corpse_death_ok:")
p = text.split(":", 4)
MPCorpseRecovery.death_ok(p[1], p[2], (p.length >= 4 ? p[3] : nil)) if p.length >= 3
return
end
if text.start_with?("corpse_death_error:")
code = text.split(":", 2)[1].to_s
MPCorpseRecovery.instance_variable_set(:@death_pending, false)
MPCorpseRecovery.notify("Труп не создан (#{code}).", :error)
return
end
if text.start_with?("corpse_claim_error:")
MPCorpseRecovery.claim_error(text.split(":", 2)[1].to_s)
return
end
if text.start_with?("corpse_restore_begin:")
MPCorpseRecovery.begin_restore(text.split(":", 2)[1])
return
end
if text.start_with?("corpse_loot_begin:")
MPCorpseRecovery.begin_public_loot(text.split(":", 2)[1])
return
end
if MPCorpseRecovery.public_loot_pending? && text.start_with?("bootstrap_state:")
return if MPCorpseRecovery.consume_public_loot_packet(text)
end
if MPCorpseRecovery.restore_pending? && text.start_with?("bootstrap_state:")
return if MPCorpseRecovery.consume_restore_packet(text)
end
if text == "cloud_save_ok:cloud_corpse_restore"
MPCorpseRecovery.cloud_restore_saved
# Let the normal CloudOnlySave parser see the acknowledgement too.
end
if text == "cloud_save_ok:cloud_corpse_public_loot"
MPCorpseRecovery.cloud_public_loot_saved
# Let the normal CloudOnlySave parser see the acknowledgement too.
end
if text.start_with?("corpse_restore_done:")
MPCorpseRecovery.restore_done(text.split(":", 2)[1])
return
end
if text.start_with?("corpse_loot_done:")
MPCorpseRecovery.public_loot_done(text.split(":", 2)[1])
return
end
if text.start_with?("corpse_tutorial_new:")
p = text.split(":", 5)
if p.length >= 5 && !MPCorpseRecovery.tutorial_bootstrap_consumed?
# Do not let a delayed/repeated helper packet re-arm the tutorial.
MPCorpseRecovery.mark_new_registration_tutorial(false)
MPCorpseRecovery.tutorial_new(p[1], p[2], p[3], p[4])
end
return
end
mp_corpse_recovery_parse(msg)
end
end
end
end
#==============================================================================
# Tutorial bootstrap is one-shot.
#
# The stock new_game_setting asks WebSocket.bootstrap_new_character_spawn on
# every DataManager.setup_new_game. Tutorial completion itself creates a fresh
# NoerSewer game, so leaving the original spawn (TutorialOP/139) alive rewrites
# OverMapID back to 139 and the sewer exit sends the player into the tutorial
# again. Once the first TutorialOP base exists, keep its position transfer but
# stop exposing that spawn to subsequent new-game setup calls.
#==============================================================================
if defined?(WebSocket)
module WebSocket
class << self
if method_defined?(:bootstrap_new_character_spawn) && !method_defined?(:mp_corpse_bootstrap_new_character_spawn_without_tutorial_once)
alias mp_corpse_bootstrap_new_character_spawn_without_tutorial_once bootstrap_new_character_spawn
def bootstrap_new_character_spawn
if defined?(MPCorpseRecovery) && MPCorpseRecovery.tutorial_bootstrap_consumed?
return nil
end
mp_corpse_bootstrap_new_character_spawn_without_tutorial_once
rescue
nil
end
end
if method_defined?(:_bootstrap_apply_new_character_overmap_spawn) && !method_defined?(:mp_corpse_apply_new_character_overmap_spawn_without_tutorial_once)
alias mp_corpse_apply_new_character_overmap_spawn_without_tutorial_once _bootstrap_apply_new_character_overmap_spawn
def _bootstrap_apply_new_character_overmap_spawn(state)
begin
if defined?(MPCorpseRecovery) && MPCorpseRecovery.tutorial_bootstrap_consumed? && state.is_a?(Hash) && state['map_id'].to_i == MPCorpseRecovery::TUTORIAL_MAP_ID
# Position is still applied by apply_bootstrap_state; only avoid
# poisoning OverMapID/LastOverMap* with TutorialOP.
return true
end
rescue
end
mp_corpse_apply_new_character_overmap_spawn_without_tutorial_once(state)
rescue
false
end
end
end
end
end
#==============================================================================
# Exact first-registration tutorial base. NewGameTutorialOP in this client is
# functionally DataManager.setup_new_game(true, "TutorialOP") + Scene_Map.
# We keep the CloudOnly bootstrap flow but create its blank base on TutorialOP
# only when the server explicitly answered auth_ok:created.
#==============================================================================
if defined?(MPCloudOnlySave)
module MPCloudOnlySave
class << self
if method_defined?(:setup_blank_cloud_base) && !method_defined?(:mp_corpse_setup_blank_cloud_base_without_tutorial)
alias mp_corpse_setup_blank_cloud_base_without_tutorial setup_blank_cloud_base
def setup_blank_cloud_base(tag="cloud_only_base")
unless MPCorpseRecovery.new_registration_tutorial?
return mp_corpse_setup_blank_cloud_base_without_tutorial(tag)
end
begin
progress_update(0.58, "Подготовка обучения...") if respond_to?(:progress_update)
if defined?(MPStateInfra) && MPStateInfra.respond_to?(:with_sync_suppressed)
MPStateInfra.with_sync_suppressed(tag) { DataManager.setup_new_game(true, "TutorialOP") }
else
DataManager.setup_new_game(true, "TutorialOP")
end
MPCorpseRecovery.finish_new_registration_tutorial
progress_update(0.68, "Обучающая карта готова...") if respond_to?(:progress_update)
return true
rescue => e
puts "[CORPSE] TutorialOP base failed: #{e.class}: #{e.message}" rescue nil
MPCorpseRecovery.finish_new_registration_tutorial
return mp_corpse_setup_blank_cloud_base_without_tutorial(tag)
end
end
end
end
end
end
#==============================================================================
# Game-over integration: capture state before the existing death new-game reset.
#==============================================================================
if defined?(Scene_Gameover)
class Scene_Gameover
alias mp_corpse_recovery_start start
def start(*args)
mp_corpse_recovery_start(*args)
@mp_corpse_deferred_restart = false
MPCorpseRecovery.submit_death_snapshot
end
alias mp_corpse_recovery_update update
def update(*args)
mp_corpse_recovery_update(*args)
if @mp_corpse_deferred_restart && !MPCorpseRecovery.waiting_death_ack?
@mp_corpse_deferred_restart = false
mp_corpse_recovery_goto_title
end
end
alias mp_corpse_recovery_goto_title goto_title
def goto_title(*args)
if MPCorpseRecovery.waiting_death_ack?
@mp_corpse_deferred_restart = true
return
end
mp_corpse_recovery_goto_title(*args)
end
end
end
#==============================================================================
# Death respawn: sewer. TutorialOP is reserved for a truly new server profile.
#==============================================================================
if defined?(MP_DeathRestart)
module MP_DeathRestart
class << self
alias mp_corpse_original_start_new_game_now start_new_game_now
end
def self.start_new_game_now(scene=nil)
begin
case rand(3)
when 0 then SndLib.sound_OrcSpot(95)
when 1 then SndLib.sound_MaleWarriorSpot(95)
when 2 then SndLib.sound_UndeadQuestion(95)
end
rescue
end
begin
scene.fadeout_all if scene && scene.respond_to?(:fadeout_all)
rescue
end
Cache.clear rescue nil
begin
DataManager.setup_new_game(true, "NoerSewer")
$titleCreateActorReq = true
$hudForceHide = false
$balloonForceHide = false
begin
$game_map.interpreter.new_game_setup
rescue
end
begin
SceneManager.prevOptChooseSet(nil)
SceneManager.prevTitleOptChooseSet(nil)
rescue
end
begin
$game_map.interpreter.change_map_weather_cleaner
rescue
end
begin
$game_player.force_update = true
rescue
end
begin
$game_system.menu_disabled = false
rescue
end
clear_autostart
begin_resync
MPCorpseRecovery.request_post_death_reset_save
SceneManager.goto(Scene_Map)
return true
rescue => e
begin
msgbox "CorpseRecovery: ошибка респавна в канализации\n#{e.class}: #{e.message}"
rescue
end
end
false
end
end
end
#==============================================================================
# Scene_Map corpse markers + interaction.
#==============================================================================
if defined?(Scene_Map)
class Scene_Map
alias mp_corpse_recovery_map_start start
def start(*args)
mp_corpse_recovery_map_start(*args)
@mp_corpse_markers = {}
@mp_corpse_marker_map_id = nil
@mp_corpse_marker_overmap = nil
@mp_corpse_overmap_viewport = nil
@mp_corpse_save_tick = 0
@mp_corpse_top_hud = MPCorpseRecovery::TopHud.new
end
alias mp_corpse_recovery_map_update update
def update(*args)
mp_corpse_recovery_map_update(*args)
mp_corpse_update_markers
@mp_corpse_top_hud.update if @mp_corpse_top_hud
MPCorpseRecovery.try_claim_nearby
MPCorpseRecovery.tick_restore_save
MPCorpseRecovery.tick_public_loot_save
@mp_corpse_save_tick = @mp_corpse_save_tick.to_i + 1
if MPCorpseRecovery.post_death_reset_save_pending? && [45, 90, 150].include?(@mp_corpse_save_tick)
MPCorpseRecovery.send_post_death_reset_save
end
if MPCorpseRecovery.tutorial_initial_save_pending? && [90, 150, 240].include?(@mp_corpse_save_tick)
MPCorpseRecovery.send_tutorial_initial_save
end
end
alias mp_corpse_recovery_map_terminate terminate
def terminate(*args)
mp_corpse_dispose_markers
begin
@mp_corpse_top_hud.dispose if @mp_corpse_top_hud
rescue
end
@mp_corpse_top_hud = nil
mp_corpse_recovery_map_terminate(*args)
end
def mp_corpse_marker_viewport
begin
# OverMap gets a dedicated high viewport so buildings/events cannot
# cover the skull. Normal maps keep the original map viewport.
if $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
if @mp_corpse_overmap_viewport.nil? || @mp_corpse_overmap_viewport.disposed?
@mp_corpse_overmap_viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
z = 1119
begin
if defined?(System_Settings) && System_Settings.const_defined?(:MAP_HUD_Z)
z = System_Settings::MAP_HUD_Z.to_i - 1
end
rescue
end
@mp_corpse_overmap_viewport.z = z
end
return @mp_corpse_overmap_viewport
end
spriteset = instance_variable_get(:@spriteset)
return spriteset.instance_variable_get(:@viewport1) if spriteset
rescue
end
nil
end
def mp_corpse_update_markers
@mp_corpse_markers ||= {}
# Scene_Map survives ordinary map transfers. A corpse can therefore have
# the same id first as an OverMap proxy and then as the real local corpse.
# Recreate marker sprites whenever map/type changes so the skull moves to
# the correct viewport and normal-map labels are restored.
current_map_id = ($game_map.map_id.to_i rescue 0)
current_overmap = begin
!!($game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap)
rescue
false
end
if @mp_corpse_marker_map_id != current_map_id || @mp_corpse_marker_overmap != current_overmap
mp_corpse_dispose_markers
@mp_corpse_marker_map_id = current_map_id
@mp_corpse_marker_overmap = current_overmap
end
current = {}
MPCorpseRecovery.marker_corpses_for_current_map.each do |corpse|
id = corpse["id"].to_i
current[id] = true
marker = @mp_corpse_markers[id]
if marker.nil?
marker = MPCorpseRecovery::Marker.new(corpse, mp_corpse_marker_viewport)
@mp_corpse_markers[id] = marker
end
marker.update(corpse)
end
@mp_corpse_markers.keys.each do |id|
next if current[id]
begin
@mp_corpse_markers[id].dispose
rescue
end
@mp_corpse_markers.delete(id)
end
rescue
end
def mp_corpse_dispose_markers
if @mp_corpse_markers
@mp_corpse_markers.each_value do |marker|
marker.dispose rescue nil
end
end
@mp_corpse_markers = {}
begin
if @mp_corpse_overmap_viewport && !@mp_corpse_overmap_viewport.disposed?
@mp_corpse_overmap_viewport.dispose
end
rescue
end
@mp_corpse_overmap_viewport = nil
rescue
end
end
end