1578 lines
50 KiB
Ruby
1578 lines
50 KiB
Ruby
# 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
|