Files
LonaRPG-Online-Games/ModScripts/multiplayer/13_trade.rb
T

1577 lines
50 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
#==============================================================================
# Multiplayer Player-to-Player Trade (Z on remote player)
#------------------------------------------------------------------------------
# Flow:
# - Action on remote player event -> trade_inv_req:<target_id>
# - Server forwards -> trade_inv_req_from:<from_id>
# - Target replies -> trade_inv:<to_id>:<payload>
# - Server forwards -> trade_inv_from:<from_id>:<payload>
# - Client opens Scene_TradeStorage (buy only) using target inventory as store
# - On ACCEPT, client sends -> trade_purchased:<seller_id>:<payload>:<gold_total>
# - Server forwards -> trade_purchased_from:<buyer_id>:<payload>:<gold_total>
# - Seller applies: lose items, gain gold
#
# Payload is Base64(Marshal.dump(hash)) to keep protocol ':'-safe.
#==============================================================================
module WebSocket
# =============================================================
# Trade session state (2-phase confirm + synced close)
# =============================================================
def self.trade_active?
!!@trade_session
end
def self.trade_partner_id
return nil unless @trade_session
@trade_session[:partner_id]
end
# -------------------------
# pending inbound packets (race-safe before scene/session fully opens)
# -------------------------
def self.trade_pending_store(bucket, from_id, *values)
pid = from_id.to_i
return if pid <= 0
store = instance_variable_get(bucket)
store = {} unless store.is_a?(Hash)
store[pid] = values
instance_variable_set(bucket, store)
end
def self.trade_pending_take(bucket, from_id)
pid = from_id.to_i
return nil if pid <= 0
store = instance_variable_get(bucket)
return nil unless store.is_a?(Hash)
store.delete(pid)
end
def self.trade_consume_pending_for(partner_id)
pid = partner_id.to_i
return if pid <= 0
# close/cancel has the highest priority; if it arrived early, abort opening immediately
pending_close = trade_pending_take(:@trade_pending_close, pid)
if pending_close
trade_receive_close(pid, pending_close[0])
return
end
pending_ui = trade_pending_take(:@trade_pending_ui_sync, pid)
if pending_ui && @trade_session && @trade_session[:partner_id].to_i == pid
@trade_session[:remote_preview_payload] = pending_ui[0] || trade_empty_delta
@trade_session[:remote_preview_gold_delta] = pending_ui[1].to_i
end
pending_confirm_req = trade_pending_take(:@trade_pending_confirm_req, pid)
trade_receive_confirm_request(pid, pending_confirm_req[0]) if pending_confirm_req
pending_confirm_reply = trade_pending_take(:@trade_pending_confirm_reply, pid)
trade_receive_confirm_reply(pid, pending_confirm_reply[0]) if pending_confirm_reply
pending_ready = trade_pending_take(:@trade_pending_ready, pid)
trade_receive_ready(pid, pending_ready[0], pending_ready[1]) if pending_ready
end
# -------------------------
# encode/decode
# -------------------------
def self.trade_encode(obj)
begin
raw = Marshal.dump(obj)
return [raw].pack('m0')
rescue
return ""
end
end
def self.trade_decode(payload)
begin
return {} if payload.nil? || payload.to_s.strip == ""
raw = (payload.to_s).unpack('m0')[0]
obj = Marshal.load(raw)
return obj
rescue
return {}
end
end
# // NEW: Reusable empty delta object for preview/confirm flow.
def self.trade_empty_delta
{ "buy" => {}, "sell" => {} }
end
# // NEW: Resolve item object by trade name without changing existing storage logic.
def self.trade_item_from_name(name)
return nil if name.nil? || name.to_s.strip == ""
item = nil
begin
item = $data_ItemName[name.to_s] if defined?($data_ItemName)
rescue
item = nil
end
return item if item
begin
item = $data_items.find { |it| it && trade_item_key(it) == name.to_s }
rescue
item = nil
end
return item if item
begin
item = $data_weapons.find { |it| it && trade_item_key(it) == name.to_s }
rescue
item = nil
end
return item if item
begin
item = $data_armors.find { |it| it && trade_item_key(it) == name.to_s }
rescue
item = nil
end
item
end
# // NEW: Shift preview amount safely (visual only, no real inventory mutation here).
def self.trade_goods_shift!(goods, item_name, diff)
return if goods.nil?
amt = diff.to_i
return if amt == 0
key = item_name.to_s
return if key == ""
item = trade_item_from_name(key)
return if item.nil?
goods[key] ||= {}
goods[key]["amount"] = goods[key]["amount"].to_i + amt
goods[key]["price"] = trade_price_for(item) if goods[key]["price"].to_i <= 0
goods.delete(key) if goods[key]["amount"].to_i <= 0
end
# // NEW: Apply delta onto preview goods.
# // NEW: mode=:direct -> apply my local delta to partner inventory.
# // NEW: mode=:inverse -> apply partner delta back onto partner pane from my perspective.
def self.trade_goods_apply_delta!(goods, payload_hash, mode=:direct)
return if goods.nil?
payload_hash ||= trade_empty_delta
buy = payload_hash["buy"] || payload_hash[:buy] || {}
sell = payload_hash["sell"] || payload_hash[:sell] || {}
if mode == :direct
buy.each { |name, qty| trade_goods_shift!(goods, name, -qty.to_i) }
sell.each { |name, qty| trade_goods_shift!(goods, name, qty.to_i) }
else
buy.each { |name, qty| trade_goods_shift!(goods, name, qty.to_i) }
sell.each { |name, qty| trade_goods_shift!(goods, name, -qty.to_i) }
end
end
# // NEW: Build the shared visual state for the partner pane only.
# // NEW: This keeps existing authoritative temp-store untouched.
def self.trade_build_shared_preview(scene)
sess = @trade_session
return [nil, nil] if sess.nil? || scene.nil?
local_payload = trade_empty_delta
local_gold_delta = 0
begin
local_payload, local_gold_delta = trade_compute_delta_from_scene(scene)
rescue
local_payload = trade_empty_delta
local_gold_delta = 0
end
remote_payload = sess[:remote_preview_payload] || trade_empty_delta
remote_gold_delta = sess[:remote_preview_gold_delta].to_i
preview_goods = (Marshal.load(Marshal.dump(sess[:initial_goods] || {})) rescue (sess[:initial_goods] || {}).dup)
trade_goods_apply_delta!(preview_goods, local_payload, :direct)
trade_goods_apply_delta!(preview_goods, remote_payload, :inverse)
preview_tp = sess[:initial_storeTP].to_i + local_gold_delta.to_i - remote_gold_delta.to_i
[preview_goods, preview_tp]
end
# // NEW: Push current local delta to the partner for immediate visual mirror.
def self.trade_send_ui_sync(scene)
sess = @trade_session
return unless sess && @connected
return if sess[:remote_closed]
payload_hash, gold_delta = trade_compute_delta_from_scene(scene)
payload = trade_encode(payload_hash)
pid = sess[:partner_id].to_i
return if pid <= 0
send_line("trade_ui_sync:#{pid}:#{payload}:#{gold_delta}")
end
# // NEW: Save partner preview delta and refresh the visual cache in the open scene.
def self.trade_receive_ui_sync(from_id, payload_hash, gold_delta)
sess = @trade_session
unless sess
trade_pending_store(:@trade_pending_ui_sync, from_id, payload_hash || trade_empty_delta, gold_delta.to_i)
return
end
unless sess[:partner_id].to_i == from_id.to_i
trade_pending_store(:@trade_pending_ui_sync, from_id, payload_hash || trade_empty_delta, gold_delta.to_i)
return
end
sess[:remote_preview_payload] = payload_hash || trade_empty_delta
sess[:remote_preview_gold_delta] = gold_delta.to_i
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
sc.mp_trade_refresh_shared_preview if sc && sc.respond_to?(:mp_trade_refresh_shared_preview)
end
rescue
end
end
# // NEW: Player 1 requests finish confirmation from Player 2.
def self.trade_request_confirm(source="accept")
sess = @trade_session
return unless sess && @connected
return if sess[:remote_closed] || sess[:commit_done]
return if sess[:confirm_phase] == :waiting_reply || sess[:confirm_phase] == :awaiting_commit
pid = sess[:partner_id].to_i
return if pid <= 0
# // NEW: Reset ready flags before a fresh confirm round.
sess[:local_ready] = false
sess[:remote_ready] = false
sess[:local_payload] = nil
sess[:remote_payload] = nil
sess[:local_gold_delta] = 0
sess[:remote_gold_delta] = 0
sess[:confirm_phase] = :waiting_reply
sess[:confirm_source] = source.to_s
send_line("trade_confirm_req:#{pid}:#{source}")
end
# // NEW: Receive confirm request from partner.
def self.trade_receive_confirm_request(from_id, source=nil)
sess = @trade_session
unless sess
trade_pending_store(:@trade_pending_confirm_req, from_id, source.to_s)
return
end
unless sess[:partner_id].to_i == from_id.to_i
trade_pending_store(:@trade_pending_confirm_req, from_id, source.to_s)
return
end
return if sess[:remote_closed] || sess[:commit_done]
# // NEW: Simultaneous accept safety: if both pressed finish, auto-accept and continue into existing 2-phase ready.
if sess[:confirm_phase] == :waiting_reply
begin
send_line("trade_confirm_reply:#{from_id}:accept") if @connected
rescue
end
trade_receive_confirm_reply(from_id, "accept")
return
end
sess[:confirm_phase] = :incoming_prompt
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
if sc && sc.respond_to?(:mp_trade_open_partner_confirm_window)
sc.mp_trade_open_partner_confirm_window(source)
end
end
rescue
end
end
# // NEW: Player 2 answers the finish request.
def self.trade_send_confirm_reply(scene, answer)
sess = @trade_session
return unless sess && @connected
pid = sess[:partner_id].to_i
return if pid <= 0
ans = answer.to_s
send_line("trade_confirm_reply:#{pid}:#{ans}")
if ans == "accept"
sess[:confirm_phase] = :awaiting_commit
trade_send_ready(scene)
elsif ans == "continue"
sess[:confirm_phase] = :idle
end
end
# // NEW: Handle reply from Player 2 on Player 1 side.
def self.trade_receive_confirm_reply(from_id, answer)
sess = @trade_session
unless sess
trade_pending_store(:@trade_pending_confirm_reply, from_id, answer.to_s)
return
end
unless sess[:partner_id].to_i == from_id.to_i
trade_pending_store(:@trade_pending_confirm_reply, from_id, answer.to_s)
return
end
ans = answer.to_s
if ans == "accept"
sess[:confirm_phase] = :awaiting_commit
sent_ready = false
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
if sc
trade_send_ready(sc)
sent_ready = true
end
end
rescue
end
sess[:pending_auto_ready] = true unless sent_ready
elsif ans == "continue"
sess[:confirm_phase] = :idle
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
sc.mp_trade_on_partner_continue if sc && sc.respond_to?(:mp_trade_on_partner_continue)
end
rescue
end
end
end
# -------------------------
# trade UI titles (buyer/seller nicknames)
# -------------------------
def self.trade_titles
@trade_titles
end
def self.trade_set_titles(buyer_nick, seller_nick)
@trade_titles = { :buyer => buyer_nick.to_s, :seller => seller_nick.to_s }
end
def self.trade_clear_titles
@trade_titles = nil
end
# -------------------------
# inventory snapshot (seller side)
# -------------------------
def self.trade_inventory_snapshot
inv = {}
inv["items"] = ($game_party.respond_to?(:get_items) ? $game_party.get_items.clone : {})
inv["weapons"] = ($game_party.respond_to?(:get_weapons) ? $game_party.get_weapons.clone : {})
inv["armors"] = ($game_party.respond_to?(:get_armors) ? $game_party.get_armors.clone : {})
inv["gold"] = trade_tp_count
inv
end
def self.trade_tp_count
begin
return $game_party.gold.to_i if defined?($game_party) && $game_party && $game_party.respond_to?(:gold)
rescue
end
trade_coin3_count
rescue
0
end
def self.trade_coin3_item
begin
return WebSocket._live_sync_coin3_item if defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_coin3_item)
rescue
end
begin
return $data_ItemName["ItemCoin3"] if defined?($data_ItemName) && $data_ItemName && $data_ItemName["ItemCoin3"]
rescue
end
begin
return $data_items[52] if defined?($data_items) && $data_items
rescue
end
nil
end
def self.trade_coin3_count
begin
return WebSocket._live_sync_coin3_count.to_i if defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_coin3_count)
rescue
end
item = trade_coin3_item
return 0 if item.nil? || !$game_party || !$game_party.respond_to?(:item_number)
$game_party.item_number(item).to_i
rescue
0
end
def self.trade_apply_coin3_delta(amount)
delta = amount.to_i
return true if delta == 0
item = trade_coin3_item
return false if item.nil? || !$game_party
if delta > 0
return false unless $game_party.respond_to?(:gain_item)
$game_party.gain_item(item, delta)
else
return false unless $game_party.respond_to?(:lose_item)
$game_party.lose_item(item, -delta)
end
true
rescue
false
end
def self.trade_apply_tp_delta(amount)
delta = amount.to_i
return true if delta == 0
begin
if defined?($game_party) && $game_party
if delta > 0 && $game_party.respond_to?(:gain_gold)
$game_party.gain_gold(delta)
return true
elsif delta < 0 && $game_party.respond_to?(:lose_gold)
$game_party.lose_gold(-delta)
return true
elsif $game_party.respond_to?(:set_gold) && $game_party.respond_to?(:gold)
$game_party.set_gold($game_party.gold.to_i + delta)
return true
end
end
rescue
end
return trade_apply_coin3_delta(delta) if respond_to?(:trade_apply_coin3_delta)
false
rescue
false
end
def self.trade_price_for(item)
return 0 if item.nil?
p = 0
begin
p = item.price.to_i if item.respond_to?(:price)
rescue
p = 0
end
if p <= 0
begin
if item.respond_to?(:get_sell_price)
p = [item.get_sell_price.to_i * 2, 1].max
end
rescue
p = 0
end
end
p = 1 if p <= 0
p
end
def self.trade_item_key(item)
return "" if item.nil?
begin
return item.item_name.to_s if item.respond_to?(:item_name) && item.item_name
rescue
end
begin
return item.name.to_s if item.respond_to?(:name) && item.name
rescue
end
""
end
# build goods hash (name => {"amount"=>qty, "price"=>price})
def self.trade_build_goods(inv_hash)
goods = {}
return goods if inv_hash.nil? || inv_hash == {}
begin
(inv_hash["items"] || {}).each do |id, qty|
iid = id.to_i
q = qty.to_i
next if q <= 0
item = $data_items[iid] rescue nil
next if item.nil?
next if item.respond_to?(:key_item?) && item.key_item?
key = trade_item_key(item)
next if key == ""
goods[key] ||= {}
goods[key]["amount"] = q
goods[key]["price"] = trade_price_for(item)
end
(inv_hash["weapons"] || {}).each do |id, qty|
iid = id.to_i
q = qty.to_i
next if q <= 0
item = $data_weapons[iid] rescue nil
next if item.nil?
key = trade_item_key(item)
next if key == ""
goods[key] ||= {}
goods[key]["amount"] = q
goods[key]["price"] = trade_price_for(item)
end
(inv_hash["armors"] || {}).each do |id, qty|
iid = id.to_i
q = qty.to_i
next if q <= 0
item = $data_armors[iid] rescue nil
next if item.nil?
key = trade_item_key(item)
next if key == ""
goods[key] ||= {}
goods[key]["amount"] = q
goods[key]["price"] = trade_price_for(item)
end
rescue
end
goods
end
# -------------------------
# public: request trade inventory
# -------------------------
def self.trade_request(target_id)
return unless @connected
return if target_id.nil?
tid = target_id.to_i
return if tid <= 0 || (@my_id && tid == @my_id)
# Only from map scene & not in battle
begin
return if $game_party.in_battle
rescue
end
begin
return unless SceneManager.scene_is?(Scene_Map)
rescue
end
@trade_pending_target = tid
begin
@trade_pending_started = Graphics.frame_count
rescue
@trade_pending_started = 0
end
send_line("trade_inv_req:#{tid}")
end
# called when we got partner inventory
def self.trade_open_with(seller_id, inv_hash)
return unless @connected
return if seller_id.nil?
sid = seller_id.to_i
return if sid <= 0
# clear pending state
@trade_pending_target = nil
@trade_auto_mirror = nil
# set UI titles to player nicknames (buyer/seller)
begin
buyer_nick = nil
begin
buyer_nick = nickname_for(@my_id) if @my_id
rescue
buyer_nick = nil
end
begin
buyer_nick = local_nickname if buyer_nick.nil? || buyer_nick.to_s.strip == ""
rescue
end
seller_nick = nil
begin
seller_nick = nickname_for(sid)
rescue
seller_nick = nil
end
seller_nick = "Player #{sid}" if seller_nick.nil? || seller_nick.to_s.strip == ""
trade_set_titles(buyer_nick, seller_nick)
rescue
end
# must have required systems
return unless defined?(Scene_TradeStorage)
return unless defined?($game_boxes) && $game_boxes
goods = trade_build_goods(inv_hash)
# NOTE: In RGSS Ruby, modifier `rescue` inside an array literal needs
# parentheses, otherwise it becomes a syntax error.
store_tp = (inv_hash && inv_hash["gold"]) ? inv_hash["gold"].to_i : 0
char_hash = [ (Marshal.load(Marshal.dump(goods)) rescue goods), store_tp ]
# store session (2-phase commit)
@trade_session = {
:partner_id => sid,
:initial_goods => (Marshal.load(Marshal.dump(goods)) rescue goods),
:initial_storeTP => store_tp,
:char_hash => char_hash,
:local_ready => false,
:remote_ready => false,
:local_payload => nil,
:local_gold_delta => 0,
:remote_payload => nil,
:remote_gold_delta => 0,
# // NEW: Finish-confirm state machine.
:confirm_phase => :idle,
# // NEW: Why confirm was requested (accept / close_accept), future-safe.
:confirm_source => nil,
# // NEW: Partner live preview delta for shared UI mirror.
:remote_preview_payload => trade_empty_delta,
# // NEW: Partner live preview gold delta for shared UI mirror.
:remote_preview_gold_delta => 0,
# // NEW: If confirm reply arrived before the scene fully opened, auto-send ready once UI exists.
:pending_auto_ready => false,
:close_sent => false,
:remote_closed => false,
:commit_done => false,
:apply_payload => nil,
:apply_gold_delta => 0
}
trade_consume_pending_for(sid)
return if @trade_session.nil?
begin
$game_boxes.buildBarter(System_Settings::STORAGE_TEMP, goods, store_tp)
rescue Exception => e
puts "[TRADE] buildBarter error: #{e}"
@trade_session = nil
trade_clear_titles
return
end
begin
SceneManager.goto(Scene_TradeStorage)
# allow both buy+sell
SceneManager.scene.prepare(System_Settings::STORAGE_TEMP, false, false, char_hash)
rescue Exception => e
puts "[TRADE] open scene error: #{e}"
@trade_session = nil
trade_clear_titles
end
end
# -------------------------
# 2-phase: compute delta (affects partner) from current temp store
# -------------------------
def self.trade_compute_delta_from_scene(scene)
sess = @trade_session
return [ {"buy"=>{}, "sell"=>{}}, 0 ] if sess.nil?
init_goods = sess[:initial_goods] || {}
init_tp = sess[:initial_storeTP].to_i rescue 0
# Update characterHASH in-place from current temp store WITHOUT closing
begin
if defined?($game_boxes) && $game_boxes && scene
ch = scene.instance_variable_get(:@characterHASH) rescue nil
if ch
tp = $game_boxes.get_storeTP rescue init_tp
$game_boxes.exportStoreItems(System_Settings::STORAGE_TEMP, ch, tp) rescue nil
end
end
rescue
end
fin_goods = {}
fin_tp = init_tp
begin
ch = scene.instance_variable_get(:@characterHASH) rescue nil
fin_goods = (ch && ch[0]) ? ch[0] : {}
fin_tp = (ch && ch[1]) ? ch[1].to_i : init_tp
rescue
fin_goods = {}
fin_tp = init_tp
end
gold_delta = fin_tp - init_tp
buy = {}
sell = {}
begin
names = {}
init_goods.each_key { |k| names[k] = true }
fin_goods.each_key { |k| names[k] = true }
names.each_key do |name|
ia = (init_goods[name] && init_goods[name]["amount"]) ? init_goods[name]["amount"].to_i : 0
fa = (fin_goods[name] && fin_goods[name]["amount"]) ? fin_goods[name]["amount"].to_i : 0
if ia > fa
buy[name] = ia - fa
elsif fa > ia
sell[name] = fa - ia
end
end
rescue
end
[ { "buy" => buy, "sell" => sell }, gold_delta ]
end
# -------------------------
# 2-phase: close sync
# -------------------------
def self.trade_send_close(reason="cancel")
sess = @trade_session
return unless sess && @connected
pid = sess[:partner_id].to_i
return if pid <= 0
return if sess[:close_sent]
sess[:close_sent] = true
send_line("trade_close:#{pid}:#{reason}")
end
def self.trade_receive_close(from_id, reason=nil)
sess = @trade_session
unless sess
trade_pending_store(:@trade_pending_close, from_id, reason.to_s)
return
end
unless sess[:partner_id].to_i == from_id.to_i
trade_pending_store(:@trade_pending_close, from_id, reason.to_s)
return
end
sess[:remote_closed] = true
# If trade scene is open - force cancel/exit
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
if sc && sc.respond_to?(:mp_trade_force_cancel_from_partner)
sc.mp_trade_force_cancel_from_partner
end
else
@trade_session = nil
trade_clear_titles
end
rescue
@trade_session = nil
trade_clear_titles
end
end
# -------------------------
# 2-phase: ready/commit
# -------------------------
def self.trade_send_ready(scene)
sess = @trade_session
return unless sess && @connected
return if sess[:remote_closed]
payload_hash, gold_delta = trade_compute_delta_from_scene(scene)
payload = trade_encode(payload_hash)
pid = sess[:partner_id].to_i
return if pid <= 0
sess[:local_ready] = true
sess[:local_payload] = payload_hash
sess[:local_gold_delta] = gold_delta
send_line("trade_ready:#{pid}:#{payload}:#{gold_delta}")
trade_try_finalize
end
def self.trade_receive_ready(from_id, payload_hash, gold_delta)
sess = @trade_session
unless sess
trade_pending_store(:@trade_pending_ready, from_id, payload_hash, gold_delta.to_i)
return
end
unless sess[:partner_id].to_i == from_id.to_i
trade_pending_store(:@trade_pending_ready, from_id, payload_hash, gold_delta.to_i)
return
end
return if sess[:remote_closed]
sess[:remote_ready] = true
sess[:remote_payload] = payload_hash
sess[:remote_gold_delta] = gold_delta.to_i
trade_try_finalize
end
def self.trade_try_finalize
sess = @trade_session
return unless sess
return if sess[:commit_done]
return unless sess[:local_ready] && sess[:remote_ready]
sess[:commit_done] = true
# // NEW: Finish flow is complete; prevent extra confirm prompts.
sess[:confirm_phase] = :done
sess[:apply_payload] = sess[:remote_payload]
sess[:apply_gold_delta] = sess[:remote_gold_delta]
begin
if defined?(Scene_TradeStorage) && SceneManager.scene_is?(Scene_TradeStorage)
sc = SceneManager.scene
sc.mp_trade_finish_commit if sc && sc.respond_to?(:mp_trade_finish_commit)
else
# if no scene, just apply and clear
trade_apply_scheduled
@trade_session = nil
trade_clear_titles
end
rescue
trade_apply_scheduled
@trade_session = nil
trade_clear_titles
end
end
def self.trade_apply_scheduled
sess = @trade_session
return unless sess
return unless sess[:commit_done]
payload_hash = sess[:apply_payload]
gold_delta = sess[:apply_gold_delta]
pid = sess[:partner_id]
return if payload_hash.nil? || payload_hash == {}
trade_apply_purchased(pid, payload_hash, gold_delta)
end
# seller applies purchases / full commit
def self.trade_apply_purchased(buyer_id, payload_hash, gold_total)
return if payload_hash.nil? || payload_hash == {}
# New format: { "buy" => {name=>qty}, "sell" => {name=>qty} }
if payload_hash.is_a?(Hash) && (payload_hash["buy"] || payload_hash[:buy] || payload_hash["sell"] || payload_hash[:sell])
buy = payload_hash["buy"] || payload_hash[:buy] || {}
sell = payload_hash["sell"] || payload_hash[:sell] || {}
# Apply item transfers
begin
buy.each do |iname, qty|
amt = qty.to_i
next if amt <= 0
item = trade_item_from_name(iname)
next if item.nil?
have = ($game_party.item_number(item) rescue 0)
lose = [amt, have].min
$game_party.lose_item(item, lose) rescue nil
end
rescue
end
begin
sell.each do |iname, qty|
amt = qty.to_i
next if amt <= 0
item = trade_item_from_name(iname)
next if item.nil?
$game_party.gain_item(item, amt) rescue nil
end
rescue
end
# Apply gold delta (seller perspective)
gd = gold_total.to_i
trade_apply_tp_delta(gd)
puts "[TRADE] Commit from #{buyer_id}: gold_delta=#{gd}"
return
end
# Legacy format: purchases hash {name=>{"amount"=>qty,"price"=>price}}
total = 0
payload_hash.each do |iname, d|
amt = (d && d["amount"]) ? d["amount"].to_i : 0
price = (d && d["price"]) ? d["price"].to_i : 0
next if amt <= 0
item = nil
begin
item = trade_item_from_name(iname)
rescue
item = nil
end
next if item.nil?
begin
have = $game_party.item_number(item)
lose = [amt, have].min
$game_party.lose_item(item, lose)
total += lose * price
rescue
end
end
gt = gold_total.to_i
gt = total if total > 0
unless trade_apply_tp_delta(gt)
begin
$game_party.gain_gold(gt)
rescue
end
end
puts "[TRADE] Sold to #{buyer_id}: gold +#{gt}"
end
# -------------------------
# Parse hook
# -------------------------
class << self
alias mp_parse_without_trade parse
end
def self.parse(msg)
if msg.start_with?("trade_reject:")
@trade_pending_target = nil
@trade_auto_mirror = nil
return
end
# server -> you: request inventory to share
if msg.start_with?("trade_inv_req_from:")
parts = msg.split(":")
from_id = parts[1].to_i rescue 0
if from_id > 0
payload = trade_encode(trade_inventory_snapshot)
send_line("trade_inv:#{from_id}:#{payload}")
# Mirror open: if the other player started trade, open for us too
# (request the other player's inventory back, but only if we're not already in a trade/pending one)
if !@trade_session && !@trade_pending_target
begin
@trade_auto_mirror = true
trade_request(from_id)
rescue
end
end
end
return
end
# server -> you: got inventory of seller
if msg.start_with?("trade_inv_from:")
parts = msg.split(":", 3)
if parts.size >= 3
seller_id = parts[1].to_i
inv = trade_decode(parts[2])
trade_open_with(seller_id, inv)
end
return
end
# server -> you: apply sale
if msg.start_with?("trade_purchased_from:")
parts = msg.split(":", 4)
if parts.size >= 4
buyer_id = parts[1].to_i
purchases = trade_decode(parts[2])
gold_total = parts[3].to_i
trade_apply_purchased(buyer_id, purchases, gold_total)
end
return
end
# // NEW: live UI sync from partner
if msg.start_with?("trade_ui_sync_from:")
parts = msg.split(":", 4)
if parts.size >= 4
from_id = parts[1].to_i
payload = trade_decode(parts[2])
gold_delta = parts[3].to_i
trade_receive_ui_sync(from_id, payload, gold_delta)
end
return
end
# // NEW: finish-confirm request from partner
if msg.start_with?("trade_confirm_req_from:")
parts = msg.split(":", 3)
if parts.size >= 2
from_id = parts[1].to_i
source = (parts.size >= 3) ? parts[2] : "accept"
trade_receive_confirm_request(from_id, source)
end
return
end
# // NEW: finish-confirm reply from partner
if msg.start_with?("trade_confirm_reply_from:")
parts = msg.split(":", 3)
if parts.size >= 3
from_id = parts[1].to_i
answer = parts[2].to_s
trade_receive_confirm_reply(from_id, answer)
end
return
end
# 2-phase trade: ready
if msg.start_with?("trade_ready_from:")
parts = msg.split(":", 4)
if parts.size >= 4
from_id = parts[1].to_i
payload = trade_decode(parts[2])
gold_delta = parts[3].to_i
trade_receive_ready(from_id, payload, gold_delta)
end
return
end
# 2-phase trade: close/cancel
if msg.start_with?("trade_close_from:")
parts = msg.split(":", 3)
if parts.size >= 2
from_id = parts[1].to_i
reason = (parts.size >= 3) ? parts[2] : nil
trade_receive_close(from_id, reason)
end
return
end
mp_parse_without_trade(msg)
end
end
#==============================================================================
# Scene hook: on leaving trade scene, commit delta if ACCEPT
#==============================================================================
if defined?(Scene_TradeStorage)
class Scene_TradeStorage < Scene_ItemStorage
alias mp_trade_create_windows create_windows
def create_windows
mp_trade_create_windows
begin
if defined?(WebSocket)
titles = WebSocket.trade_titles
if titles
if defined?(@bag_title) && @bag_title
@bag_title.instance_variable_set(:@title, titles[:buyer].to_s)
@bag_title.refresh
end
if defined?(@box_title) && @box_title
@box_title.instance_variable_set(:@title, titles[:seller].to_s)
@box_title.refresh
end
end
end
rescue
end
begin
# // NEW: Visual cache for the shared partner pane.
@mp_trade_partner_confirm_window = nil
# // NEW: Cached merged goods for right pane rendering.
@mp_trade_preview_goods = nil
# // NEW: Cached merged TP for right title rendering.
@mp_trade_preview_store_tp = nil
# // NEW: Build first preview immediately on open.
mp_trade_refresh_shared_preview if defined?(WebSocket) && WebSocket.trade_active?
if defined?(WebSocket) && WebSocket.trade_active?
sess = WebSocket.instance_variable_get(:@trade_session) rescue nil
if sess
if sess[:confirm_phase] == :incoming_prompt
mp_trade_open_partner_confirm_window(sess[:confirm_source])
elsif sess[:pending_auto_ready] && !sess[:local_ready]
mp_trade_set_waiting(true)
sess[:pending_auto_ready] = false
WebSocket.trade_send_ready(self)
end
end
end
rescue
end
end
alias mp_trade_terminate terminate
def terminate
begin
# // NEW: Cleanup custom responder popup and preview cache.
dispose_mp_trade_partner_confirm_window rescue nil
@mp_trade_preview_goods = nil
@mp_trade_preview_store_tp = nil
rescue
end
mp_trade_terminate
begin
# Apply scheduled delta only AFTER leaving the scene (commit path)
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
WebSocket.trade_apply_scheduled
WebSocket.instance_variable_set(:@trade_session, nil)
WebSocket.trade_clear_titles
end
rescue
end
# Always cleanup temp store to avoid leftovers
begin
if defined?($game_boxes) && $game_boxes
$game_boxes.box(System_Settings::STORAGE_TEMP).clear rescue nil
$game_boxes.set_storeTP(0) rescue nil
end
rescue
end
end
# ------------------------------------------------------------
# 2-phase hooks: accept/cancel + synced close
# ------------------------------------------------------------
# // NEW: Rebuild merged partner-side preview (my local delta + partner remote delta).
def mp_trade_refresh_shared_preview
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
goods, tp = WebSocket.trade_build_shared_preview(self)
@mp_trade_preview_goods = goods
@mp_trade_preview_store_tp = tp
else
@mp_trade_preview_goods = nil
@mp_trade_preview_store_tp = nil
end
@box_window.refresh if @box_window
@box_title.refresh if @box_title
rescue
end
end
# // NEW: Renderer hook for right pane item list.
def mp_trade_preview_goods_hash
@mp_trade_preview_goods
end
# // NEW: Renderer hook for right pane title TP.
def mp_trade_preview_store_tp
@mp_trade_preview_store_tp
end
# // NEW: Open the responder popup for Player 2.
def mp_trade_open_partner_confirm_window(source=nil)
begin
dispose_confirm_window rescue nil
dispose_sort_window rescue nil
dispose_mp_trade_partner_confirm_window rescue nil
@mp_trade_prev_bag_window_active = (@bag_window.active rescue false)
@mp_trade_prev_box_window_active = (@box_window.active rescue false)
@mp_trade_partner_confirm_window = MPTradePartnerConfirm_Command.new
@bag_window.deactivate if @bag_window
@box_window.deactivate if @box_window
@help_window.set_text("Второй игрок хочет завершить обмен.
Подтвердить / Отказ / Продолжить") if @help_window
rescue
end
end
# // NEW: Close responder popup and restore previous active windows.
def dispose_mp_trade_partner_confirm_window
if @mp_trade_partner_confirm_window
@mp_trade_partner_confirm_window.dispose rescue nil
@mp_trade_partner_confirm_window = nil
end
return if mp_trade_waiting?
begin
if @bag_window
@mp_trade_prev_bag_window_active ? @bag_window.activate : @bag_window.deactivate
end
if @box_window
@mp_trade_prev_box_window_active ? @box_window.activate : @box_window.deactivate
end
rescue
end
end
# // NEW: Helper flag for update loop.
def mp_trade_partner_confirm_active?
!!@mp_trade_partner_confirm_window
end
# // NEW: Player 1 was released back into trading mode.
def mp_trade_on_partner_continue
begin
mp_trade_set_waiting(false)
@help_window.set_text("Второй игрок продолжает торговлю.") if @help_window
rescue
end
end
# // NEW: Player 2 accepted the finish request.
def mp_trade_partner_confirm_accept
begin
dispose_mp_trade_partner_confirm_window
mp_trade_set_waiting(true)
WebSocket.trade_send_confirm_reply(self, "accept") if defined?(WebSocket)
rescue
end
end
# // NEW: Player 2 wants to continue editing the trade.
def mp_trade_partner_confirm_continue
begin
dispose_mp_trade_partner_confirm_window
@help_window.clear if @help_window
WebSocket.trade_send_confirm_reply(self, "continue") if defined?(WebSocket)
rescue
end
end
# // NEW: Player 2 declines and cancels the trade entirely.
def mp_trade_partner_confirm_decline
begin
dispose_mp_trade_partner_confirm_window
WebSocket.trade_send_close("decline") if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
@resetToDefault = true
SndLib.sys_PaperTear rescue nil
SceneManager.goto(Scene_Map)
rescue
SceneManager.goto(Scene_Map) rescue nil
end
end
def mp_trade_set_waiting(flag)
# // NEW: Persist explicit waiting state.
@mp_trade_waiting = flag ? true : false
begin
if @mp_trade_waiting
# // NEW: Remember which pane was active before lock.
@mp_trade_wait_prev_bag = (@bag_window.active rescue false)
@mp_trade_wait_prev_box = (@box_window.active rescue false)
# // NEW: Waiting state and responder popup are mutually exclusive.
dispose_mp_trade_partner_confirm_window rescue nil
@bag_window.deactivate if @bag_window
@box_window.deactivate if @box_window
dispose_confirm_window rescue nil
dispose_sort_window rescue nil
@help_window.set_text("Ожидаем подтверждения второго игрока...
B / X = отмена") if @help_window
else
# // NEW: Restore focus so trade can continue after 'Продолжить торговлю'.
unless mp_trade_partner_confirm_active?
if @bag_window
@mp_trade_wait_prev_bag ? @bag_window.activate : @bag_window.deactivate
end
if @box_window
@mp_trade_wait_prev_box ? @box_window.activate : @box_window.deactivate
end
end
@help_window.clear if @help_window && !mp_trade_partner_confirm_active?
end
rescue
end
end
def mp_trade_waiting?
@mp_trade_waiting == true
end
def mp_trade_force_cancel_from_partner
begin
# // NEW: Close responder popup if it is open.
dispose_mp_trade_partner_confirm_window rescue nil
@resetToDefault = true
mp_trade_set_waiting(false)
SndLib.sys_PaperTear rescue nil
SceneManager.goto(Scene_Map)
rescue
SceneManager.goto(Scene_Map) rescue nil
end
end
def mp_trade_finish_commit
begin
# // NEW: Close responder popup if it is open.
dispose_mp_trade_partner_confirm_window rescue nil
@resetToDefault = false
mp_trade_set_waiting(false)
SndLib.sound_step_chain(100,90) rescue nil
SndLib.closeChest rescue nil
SceneManager.goto(Scene_Map)
rescue
SceneManager.goto(Scene_Map) rescue nil
end
end
alias mp_trade_press_accept press_trade_Accept
def press_trade_Accept
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
# // NEW: Do not send ready immediately anymore.
# // NEW: First ask the partner for explicit confirm/decline/continue.
mp_trade_set_waiting(true)
WebSocket.trade_request_confirm("accept")
return
end
rescue
end
mp_trade_press_accept
end
alias mp_trade_press_cancel press_trade_Cancel
def press_trade_Cancel
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
WebSocket.trade_send_close("cancel")
end
rescue
end
mp_trade_press_cancel
end
# Treat direct close (B/X when no confirm) as cancel too
alias mp_trade_update_item_selection update_item_selection
def update_item_selection
# // NEW: Partner responder popup has priority over all other trade inputs.
if mp_trade_partner_confirm_active?
if (Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) || (Mouse.enable? && Input.trigger?(:MX_LINK)))
mp_trade_partner_confirm_continue
return
end
@mp_trade_partner_confirm_window.update if @mp_trade_partner_confirm_window
case @mp_trade_partner_confirm_window.choosed
when :Accept
mp_trade_partner_confirm_accept
when :Decline
mp_trade_partner_confirm_decline
when :Continue
mp_trade_partner_confirm_continue
end
return
end
if mp_trade_waiting?
if (Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) || (Mouse.enable? && Input.trigger?(:MX_LINK)))
press_trade_Cancel
return
end
@trade_confirm_window.update if @trade_confirm_window
return
end
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
if !@trade_confirm_window && !@trade_sort_window && !@needConfirmB4Close && (Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) || (Mouse.enable? && Input.trigger?(:MX_LINK)))
press_trade_Cancel
return
end
end
mp_trade_update_item_selection
end
alias mp_trade_move_item move_item
def move_item(val=nil)
# // NEW: Snapshot before local action to avoid sending duplicate/no-op sync.
before_payload = nil
before_gold = 0
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
before_payload, before_gold = WebSocket.trade_compute_delta_from_scene(self)
end
rescue
end
mp_trade_move_item(val)
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.trade_active?
after_payload, after_gold = WebSocket.trade_compute_delta_from_scene(self)
# // NEW: Only sync if something actually changed.
if before_payload != after_payload || before_gold.to_i != after_gold.to_i
mp_trade_refresh_shared_preview
WebSocket.trade_send_ui_sync(self)
refresh
end
end
rescue
end
end
# ------------------------------------------------------------
# Keep game logic running while trading (no gameplay pause).
# В онлайне полный live-тикт (spriteset + map.update(true))
# делает 29_live_esc_menu.rb — здесь только оффлайн fallback.
# ------------------------------------------------------------
alias mp_trade_update update unless method_defined?(:mp_trade_update)
def update
unless defined?(MPLiveEscMenu) && MPLiveEscMenu.online?
begin
$game_map.update(false) if $game_map
$game_player.update if $game_player
rescue
end
end
mp_trade_update
end
end
end
# // NEW: Responder popup for Player 2: confirm / continue / decline.
if defined?(Trade_Confirm_Command)
class MPTradePartnerConfirm_Command < Trade_Confirm_Command
def firstTimeBuildOPT
# // NEW: Explicit 3-way response flow.
buildOptions(:Accept, "Подтвердить торговлю", "", [:Accept])
buildOptions(:Continue, "Продолжить торговлю", "", [:Continue])
buildOptions(:Decline, "Отказ", "", [:Decline])
end
def setOPT(setting, value)
case setting
when :Accept
handlerAccept(value)
when :Continue
handlerContinue(value)
when :Decline
handlerDecline(value)
end
end
def handlerContinue(value)
return if @onBegin == true
@choosed = value
end
def handlerDecline(value)
return if @onBegin == true
@choosed = value
end
end
end
# // NEW: Right pane draws merged shared preview instead of raw local temp-store when trade sync is active.
if defined?(Window_TradeStorageRight)
class Window_TradeStorageRight < Window_ItemList
alias mp_trade_sync_make_item_list make_item_list unless method_defined?(:mp_trade_sync_make_item_list)
alias mp_trade_sync_draw_item_number draw_item_number unless method_defined?(:mp_trade_sync_draw_item_number)
def mp_trade_preview_goods_hash
begin
sc = SceneManager.scene
return sc.mp_trade_preview_goods_hash if sc && sc.respond_to?(:mp_trade_preview_goods_hash)
rescue
end
nil
end
def make_item_list
preview = mp_trade_preview_goods_hash
if preview && preview.is_a?(Hash)
@data = []
preview.each_key do |item_name|
item = nil
begin
item = WebSocket.trade_item_from_name(item_name) if defined?(WebSocket)
rescue
item = nil
end
@data << item if item && !@data.include?(item)
end
sort_item_list
return
end
mp_trade_sync_make_item_list
end
def draw_item_number(rect, item)
preview = mp_trade_preview_goods_hash
if preview && item
key = ""
begin
key = WebSocket.trade_item_key(item) if defined?(WebSocket)
rescue
key = ""
end
key = item.name.to_s if key.to_s == ""
row = preview[key] || {}
self.contents.font.size = 16
self.contents.font.outline = false
item.weight = 0 if !item.weight
self.contents.draw_text(rect, sprintf("#{(item.weight).round(1)}w #{row['price'].to_i}p x#{row['amount'].to_i}"), 2)
return
end
mp_trade_sync_draw_item_number(rect, item)
end
end
end
#==============================================================================
# UI tweak: move the "w" (weight) value lower under the nickname/title
#==============================================================================
if defined?(Window_TradeBoxTitle)
class Window_TradeBoxTitle < Window_Base
def mp_tradebox_weight_patch; end
alias mp_trade_draw_box_amount_orig draw_box_amount unless method_defined?(:mp_trade_draw_box_amount_orig)
def draw_box_amount
self.contents.clear
self.contents.font.name = (defined?(MPSafeFont) ? MPSafeFont.name : (System_Settings::MESSAGE_WINDOW_FONT_NAME rescue "VL Gothic")) #- # Print ()
self.contents.font.size = 16 #24 # Print ()
tmpPlayerTP = (defined?(WebSocket) && WebSocket.respond_to?(:trade_tp_count)) ? WebSocket.trade_tp_count : $game_party.gold
# // NEW: Use merged preview TP on the partner side when multiplayer trade cache exists.
tmpStoreTP = nil
begin
sc = SceneManager.scene
tmpStoreTP = sc.mp_trade_preview_store_tp if sc && sc.respond_to?(:mp_trade_preview_store_tp)
rescue
tmpStoreTP = nil
end
tmpStoreTP = $game_boxes.get_storeTP if tmpStoreTP.nil?
if @selfMode
self.contents.draw_text(0, 0, contents.width, line_height, @title, 0)
wtext = ""
begin
wtext = "#{(2*$game_player.actor.attr_dimensions["sta"][2] - $game_player.actor.weight_carried).round(1)}w"
rescue
wtext = ""
end
# was y=0, move down by one line
self.contents.draw_text(0, line_height, contents.width, line_height, wtext, 2)
if tmpStoreTP < 0
self.contents.draw_text(0, line_height * 2, contents.width, line_height, "#{tmpPlayerTP} + #{tmpStoreTP.abs} = #{tmpPlayerTP + tmpStoreTP.abs} TP", 0)
else
self.contents.draw_text(0, line_height * 2, contents.width, line_height, "#{tmpPlayerTP} TP", 0)
end
else
self.contents.draw_text(0, 0, contents.width, line_height, @title, 2)
self.contents.draw_text(0, line_height * 2, contents.width, line_height, "#{tmpStoreTP} TP", 2)
end
end
end
end