# encoding: UTF-8 #============================================================================== # Multiplayer Player-to-Player Trade (Z on remote player) #------------------------------------------------------------------------------ # Flow: # - Action on remote player event -> trade_inv_req: # - Server forwards -> trade_inv_req_from: # - Target replies -> trade_inv:: # - Server forwards -> trade_inv_from:: # - Client opens Scene_TradeStorage (buy only) using target inventory as store # - On ACCEPT, client sends -> trade_purchased::: # - Server forwards -> trade_purchased_from::: # - 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