Files
LonaRPG-Online-Games/ModScripts/multiplayer/35_player_slavery.rb
T

3183 lines
107 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
module WebSocket
SLAVE_MENU_TEXT = "Рабские контракты"
SLAVE_CONTEXT_TEXT = "Долг / рабство"
SLAVE_CAPTURE_TEXT = "Захватить без сил"
SLAVE_LOAN_TEXT = "Дать в долг"
SLAVE_BORROW_TEXT = "Попросить займ"
SLAVE_DEFAULT_LIST_PRICE = 100
SLAVE_DEFAULT_LOAN_AMOUNT = 10
SLAVE_DEFAULT_LOAN_HOURS = 24
# The server may send 0/blank for old contracts. In this game the prison
# mine is registered under the map tag "MinerPrison" (Map050).
SLAVE_DEFAULT_WORK_MAP = "MinerPrison" unless const_defined?(:SLAVE_DEFAULT_WORK_MAP)
SLAVE_LOAN_AMOUNTS = [10, 25, 50, 100, 250, 500] unless const_defined?(:SLAVE_LOAN_AMOUNTS)
SLAVE_LOAN_TERMS = [[1, "1 час"], [6, "6 часов"], [24, "24 часа"], [72, "3 дня"], [168, "7 дней"]] unless const_defined?(:SLAVE_LOAN_TERMS)
SLAVE_LIST_PRICES = [100, 250, 500, 1000] unless const_defined?(:SLAVE_LIST_PRICES)
SLAVE_BONDAGE_BY_SLOT = {
0 => ["ItemCuff", "ItemChainCuff"],
5 => ["ItemCollar", "ItemChainCollar"],
6 => ["ItemChainMidExtra"]
} unless const_defined?(:SLAVE_BONDAGE_BY_SLOT)
@mp_slave_contracts ||= []
@mp_slave_debts ||= []
@mp_slave_listings ||= []
@mp_slave_wallet ||= 0
@mp_slave_loan_offers ||= {}
@mp_slave_loan_requests ||= {}
@mp_slave_state_loading ||= false
def self.slave_clear_state
@mp_slave_contracts = []
@mp_slave_debts = []
@mp_slave_listings = []
@mp_slave_wallet = 0
@mp_slave_loan_offers = {}
@mp_slave_loan_requests = {}
@mp_slave_state_loading = false
MPPlayerSlavery.clear_loan_dialog_queues if defined?(MPPlayerSlavery) && MPPlayerSlavery.respond_to?(:clear_loan_dialog_queues)
rescue
end
def self.slave_notify(text, error=false)
msg = text.to_s
begin
if defined?(System_NotificationOverlay)
if error && System_NotificationOverlay.respond_to?(:error)
System_NotificationOverlay.error(msg)
return
elsif System_NotificationOverlay.respond_to?(:success)
System_NotificationOverlay.success(msg)
return
elsif System_NotificationOverlay.respond_to?(:notify)
System_NotificationOverlay.notify(msg, error ? :error : :success)
return
end
end
rescue
end
begin
$game_map.popup(0, msg, 0, 0) if defined?($game_map) && $game_map
rescue
puts("[MP_SLAVE] #{msg}")
end
end
# Commands selected through the guild employee are answered asynchronously
# by the server. Remember that origin until the matching ok/error arrives so
# the answer is shown as the employee's dialogue instead of a screen banner.
def self.slave_expect_worker_reply!
@mp_slave_worker_reply_pending = true
@mp_slave_worker_reply_deadline = (Graphics.frame_count rescue 0) + 900
true
rescue
false
end
def self.slave_consume_worker_reply?
pending = !!@mp_slave_worker_reply_pending
deadline = @mp_slave_worker_reply_deadline.to_i
now = (Graphics.frame_count rescue 0)
pending = false if deadline > 0 && now > deadline
@mp_slave_worker_reply_pending = false
@mp_slave_worker_reply_deadline = 0
pending
rescue
false
end
def self.slave_worker_say(text)
msg = text.to_s
if defined?(MPClanEstate) && MPClanEstate.respond_to?(:queue_worker_dialogue)
MPClanEstate.queue_worker_dialogue(msg)
elsif defined?($game_message) && $game_message && $game_message.respond_to?(:add)
$game_message.add("\\CBmp[GuildEmpolyee,20]\\c[4]Работник:\\C[0] #{msg}")
else
slave_notify(msg)
end
true
rescue
slave_notify(text)
false
end
def self.slave_reply(text, error=false)
return slave_worker_say(text) if slave_consume_worker_reply?
slave_notify(text, error)
end
def self.slave_system_chat(text)
begin
now = Time.now.to_i * 1000
chat_add(now + rand(1000), now, -1, "SLAVE", text.to_s) if respond_to?(:chat_add)
rescue
end
end
def self.slave_unesc(text)
s = text.to_s
begin
s = unesc(s) if respond_to?(:unesc)
rescue
end
s.gsub(/%([0-9A-Fa-f]{2})/) { [$1.hex].pack("C") }
rescue
text.to_s
end
def self.slave_request_state
send_line("mp_slave_state_req") if @connected
rescue
end
def self.slave_player_name(player_id)
pid = player_id.to_i
name = ""
begin
name = nickname_for(pid).to_s if respond_to?(:nickname_for)
rescue
name = ""
end
name = "игрок ##{pid}" if name.strip.empty?
name
rescue
"игрок"
end
def self.slave_status_text(status)
{
"ACTIVE" => "активен",
"OVERDUE" => "просрочен",
"ENSLAVED" => "перешёл в рабство",
"PAID" => "выплачен",
"ESCAPED" => "раб сбежал",
"RELEASED" => "закрыт",
"SOLD" => "продан",
"CANCELLED" => "отменён"
}[status.to_s] || status.to_s
rescue
status.to_s
end
def self.slave_origin_text(origin)
{
"debt_overdue" => "просроченный долг",
"ally_sale" => "продажа союзником",
"voluntary_sale" => "добровольная продажа",
"pvp_capture" => "захват без выносливости"
}[origin.to_s] || origin.to_s
rescue
origin.to_s
end
def self.slave_hours_text(hours)
h = hours.to_i
return "1 час" if h == 1
return "#{h / 24} дн." if h > 0 && (h % 24) == 0
"#{h} ч."
rescue
"#{hours} ч."
end
def self.slave_due_text(ms)
left = ms.to_i - ((Time.now.to_f * 1000).to_i rescue 0)
return "просрочен" if left <= 0
hours = (left / 3_600_000.0).ceil
"осталось #{slave_hours_text(hours)}"
rescue
""
end
def self.slave_debt_left(debt)
return 0 unless debt.is_a?(Hash)
[debt[:amount_due].to_i - debt[:amount_paid].to_i, 0].max
rescue
0
end
def self.slave_pending_loan_offers
@mp_slave_loan_offers ||= {}
rescue
{}
end
def self.slave_pending_loan_requests
@mp_slave_loan_requests ||= {}
rescue
{}
end
def self.slave_loan_offer_info(offer_id)
slave_pending_loan_offers[offer_id.to_i]
rescue
nil
end
def self.slave_loan_request_info(request_id)
slave_pending_loan_requests[request_id.to_i]
rescue
nil
end
def self.slave_remove_loan_offer(offer_id)
slave_pending_loan_offers.delete(offer_id.to_i)
rescue
end
def self.slave_remove_loan_request(request_id)
slave_pending_loan_requests.delete(request_id.to_i)
rescue
end
def self.slave_market_list
@mp_slave_listings.is_a?(Array) ? @mp_slave_listings : []
rescue
[]
end
def self.slave_list_self(price=SLAVE_DEFAULT_LIST_PRICE)
return slave_notify("Нет соединения с сервером.", true) unless @connected
send_line("mp_slave_list:#{price.to_i}")
rescue
end
def self.slave_cancel_listing
send_line("mp_slave_cancel_listing") if @connected
rescue
end
def self.slave_buy_listing(listing_id)
id = listing_id.to_i
return if id <= 0
send_line("mp_slave_buy:#{id}") if @connected
rescue
end
def self.slave_capture(target_id)
tid = target_id.to_i
return false if tid <= 0
return slave_notify("Нет соединения с сервером.", true) unless @connected
slave_notify("Проверяю актуальную выносливость цели...")
send_line("mp_slave_capture:#{tid}")
true
rescue
false
end
def self.slave_loan_offer(target_id, amount=SLAVE_DEFAULT_LOAN_AMOUNT, hours=SLAVE_DEFAULT_LOAN_HOURS)
tid = target_id.to_i
amt = amount.to_i
hrs = hours.to_i
return false if tid <= 0 || amt <= 0 || hrs <= 0
send_line("mp_slave_loan_offer:#{tid}:#{amt}:#{hrs}") if @connected
true
rescue
false
end
def self.slave_loan_request(target_id, amount=SLAVE_DEFAULT_LOAN_AMOUNT, hours=SLAVE_DEFAULT_LOAN_HOURS)
tid = target_id.to_i
amt = amount.to_i
hrs = hours.to_i
return false if tid <= 0 || amt <= 0 || hrs <= 0
send_line("mp_slave_loan_request:#{tid}:#{amt}:#{hrs}") if @connected
true
rescue
false
end
def self.slave_accept_loan(offer_id)
id = offer_id.to_i
send_line("mp_slave_loan_accept:#{id}") if @connected
slave_remove_loan_offer(id)
rescue
end
def self.slave_decline_loan(offer_id)
id = offer_id.to_i
send_line("mp_slave_loan_decline:#{id}") if @connected
slave_remove_loan_offer(id)
rescue
end
def self.slave_grant_loan_request(request_id)
id = request_id.to_i
send_line("mp_slave_loan_grant:#{id}") if @connected
slave_remove_loan_request(id)
rescue
end
def self.slave_reject_loan_request(request_id)
id = request_id.to_i
send_line("mp_slave_loan_reject:#{id}") if @connected
slave_remove_loan_request(id)
rescue
end
def self.slave_repay_debt(debt_id, amount)
did = debt_id.to_i
amt = amount.to_i
return if did <= 0 || amt <= 0
send_line("mp_slave_repay:#{did}:#{amt}") if @connected
rescue
end
def self.slave_escape(contract_id=nil)
c = contract_id ? nil : slave_active_contract("slave")
id = contract_id ? contract_id.to_i : (c ? c[:id].to_i : 0)
if id <= 0
slave_notify("Нет активного контракта для побега.", true)
return false
end
unless @connected
slave_notify("Нет соединения с сервером.", true)
return false
end
if defined?(MPSlaveEscapeAction) && MPSlaveEscapeAction.respond_to?(:start_attempt)
return MPSlaveEscapeAction.start_attempt(id)
end
slave_escape_commit(id)
rescue
false
end
# Отправляется только после успешного завершения локальной анимации.
# Если попытку заметит NPC, MPSlaveEscapeAction не вызывает этот метод.
def self.slave_escape_commit(contract_id)
id = contract_id.to_i
return false if id <= 0
unless @connected
slave_notify("Соединение с сервером потеряно. Попытка не засчитана.", true)
return false
end
send_line("mp_slave_escape:#{id}")
true
rescue
false
end
def self.slave_release(contract_id=nil)
c = contract_id ? nil : slave_active_contract("owner")
id = contract_id ? contract_id.to_i : (c ? c[:id].to_i : 0)
return slave_notify("Нет активного контракта для освобождения.", true) if id <= 0
send_line("mp_slave_release:#{id}") if @connected
rescue
end
def self.slave_claim_income
send_line("mp_slave_claim_income") if @connected
rescue
end
def self.slave_work_tick_from_mine(gross)
c = slave_active_contract("slave")
return false unless c
return false unless c[:status].to_s == "ACTIVE"
return false unless mp_player_owned?
amount = gross.to_i
return false if amount <= 0
send_line("mp_slave_work:#{c[:id].to_i}:#{amount}") if @connected
true
rescue
false
end
def self.slave_active_contract(role=nil)
list = @mp_slave_contracts
return nil unless list.is_a?(Array)
list.each do |row|
next unless row.is_a?(Hash)
next unless row[:status].to_s == "ACTIVE"
next if role && row[:role].to_s != role.to_s
return row
end
nil
rescue
nil
end
def self.slave_open_debt_as_debtor
return nil unless @mp_slave_debts.is_a?(Array)
@mp_slave_debts.each do |row|
next unless row.is_a?(Hash)
next unless row[:role].to_s == "debtor"
next unless ["ACTIVE", "OVERDUE", "ENSLAVED"].include?(row[:status].to_s)
return row if row[:amount_due].to_i > row[:amount_paid].to_i
end
nil
rescue
nil
end
def self.mp_player_owned?
c = slave_active_contract("slave")
return false unless c
begin
$story_stats["MPPlayerSlaveContract"].to_i == c[:id].to_i || $story_stats["SlaveOwner"].to_s.start_with?("MP:")
rescue
true
end
rescue
false
end
def self.can_capture_player?(player_id)
pid = player_id.to_i
return false if pid <= 0
return false if @my_id && pid == @my_id.to_i
# Do NOT gate the capture menu by the remote stamina cache. It can lag
# behind what the target actually has right now. The server-side
# SlaveCaptureFreshStaFix asks the TARGET client for actor.sta with a
# one-use nonce and decides the capture from that fresh value.
!!@connected
rescue
false
end
def self.slave_sync_inventory(reason)
begin
if defined?(MPImmediateLiveSync)
MPImmediateLiveSync.trigger(reason.to_s, true, false)
elsif respond_to?(:mp_rt_sync)
mp_rt_sync(reason.to_s, false, false, false)
end
rescue
end
end
def self.slave_gold
return $game_party.gold.to_i if defined?($game_party) && $game_party && $game_party.respond_to?(:gold)
0
rescue
0
end
def self.slave_apply_gold_delta(delta, reason="", ref_id=0)
amount = delta.to_i
return if amount == 0
begin
if amount > 0
$game_party.gain_gold(amount) if $game_party && $game_party.respond_to?(:gain_gold)
slave_notify("Получено золото: #{amount}.")
else
lose = [amount.abs, slave_gold].min
$game_party.lose_gold(lose) if lose > 0 && $game_party && $game_party.respond_to?(:lose_gold)
slave_notify("Списано золото: #{lose}.")
end
slave_sync_inventory("mp_slave_gold_delta")
rescue
end
end
def self.slave_valid_work_map?(work_key)
key = work_key.to_s.strip
return false if key.empty? || key == "0"
begin
ids = $data_tag_maps[key]
return ids && ids.respond_to?(:empty?) && !ids.empty?
rescue
end
false
rescue
false
end
def self.slave_normalize_work_map(work_key)
key = work_key.to_s.strip
return key if slave_valid_work_map?(key)
fallback = SLAVE_DEFAULT_WORK_MAP.to_s
return fallback if slave_valid_work_map?(fallback)
# Keep a non-zero unknown key for diagnostics, but never preserve the
# old sentinel 0 because it creates an endless patrol retry loop.
return key unless key.empty? || key == "0"
fallback
rescue
SLAVE_DEFAULT_WORK_MAP.to_s
end
def self.slave_in_work_map?(work_key)
key = slave_normalize_work_map(work_key)
begin
ids = $data_tag_maps[key]
return ids.include?($game_map.map_id) if ids && $game_map
rescue
end
false
rescue
false
end
def self.slave_bondage_item?(item)
return false if item.nil?
begin
return true if item.respond_to?(:type_tag) && item.type_tag.to_s == "Bondage"
rescue
end
begin
SLAVE_BONDAGE_BY_SLOT.values.flatten.each do |item_name|
obj = slave_item_object(item_name)
return true if obj && item == obj
end
rescue
end
false
rescue
false
end
# Multiplayer player-owned slaves use only SlaveBrand. This method removes
# every equipped bondage item without deleting unrelated inventory items.
def self.slave_apply_brand_only(sync_inventory=true)
actor = nil
begin
actor = $game_player.actor if defined?($game_player) && $game_player
rescue
actor = nil
end
return false unless actor
changed = false
begin
equips = actor.respond_to?(:equips) ? actor.equips : []
equips.each_with_index do |eqp, slot_id|
next unless slave_bondage_item?(eqp)
begin
actor.discard_equip(eqp) if actor.respond_to?(:discard_equip)
rescue
end
begin
still_equipped = actor.respond_to?(:equips) ? actor.equips[slot_id] : nil
actor.force_change_equip(slot_id, nil) if still_equipped && actor.respond_to?(:force_change_equip)
rescue
begin
actor.change_equip(slot_id, nil) if actor.respond_to?(:change_equip)
rescue
end
end
changed = true
end
rescue
end
begin
if actor.respond_to?(:stat) && actor.stat
if actor.stat["SlaveBrand"].to_i != 1
actor.stat["SlaveBrand"] = 1
changed = true
end
end
rescue
end
begin
# Do not let old cuff/collar dialogue state restore physical restraints.
$story_stats["dialog_cuff"] = 0
$story_stats["dialog_collar"] = 0
$story_stats["dialog_cuff_equiped"] = 1
$story_stats["dialog_collar_equiped"] = 1
rescue
end
if changed
begin
actor.refresh_equip_part_covered if actor.respond_to?(:refresh_equip_part_covered)
actor.refresh if actor.respond_to?(:refresh)
actor.update_lonaStat if actor.respond_to?(:update_lonaStat)
actor.actor_ForceUpdate if actor.respond_to?(:actor_ForceUpdate)
rescue
end
begin
$game_player.move_normal if defined?($game_player) && $game_player && $game_player.respond_to?(:move_normal)
$game_player.refresh_chs if defined?($game_player) && $game_player && $game_player.respond_to?(:refresh_chs)
rescue
end
slave_sync_inventory("mp_slave_brand_only") if sync_inventory
end
changed
rescue
false
end
# The existing server-side slave wallet already powers guild collection.
# Reuse the validated contract income channel with one currency unit per
# completed player-vs-NPC sex scene.
def self.slave_npc_sex_income
contract = slave_active_contract("slave")
return false unless contract && contract[:status].to_s == "ACTIVE"
return false unless mp_player_owned?
return false unless @connected
send_line("mp_slave_work:#{contract[:id].to_i}:1")
slave_system_chat("Владельцу начислен 1 медяк за услуги раба. Доход можно забрать в гильдии.")
true
rescue
false
end
def self.slave_apply_force_work(contract_id, owner_profile, owner_nick, origin, work_key, allow_transfer=true)
id = contract_id.to_i
return if id <= 0
work_key = slave_normalize_work_map(work_key)
already = false
begin
already = $story_stats["MPPlayerSlaveContract"].to_i == id
rescue
already = false
end
begin
$story_stats["MPPlayerSlaveContract"] = id
$story_stats["MPPlayerSlaveOwnerProfile"] = owner_profile.to_i
$story_stats["MPPlayerSlaveOwnerNick"] = owner_nick.to_s
$story_stats["MPPlayerSlaveOrigin"] = origin.to_s
$story_stats["MPPlayerSlaveWorkMap"] = work_key.to_s
$story_stats["Captured"] = 1
$story_stats["SlaveOwner"] = "MP:#{owner_profile.to_i}"
$story_stats["OverMapForceTrans"] = work_key.to_s
$story_stats["Captured_PrisonMiningNeed"] = 20 if $story_stats["Captured_PrisonMiningNeed"].to_i <= 0
$story_stats["Captured_PrisonMiningPoint"] = 0 if $story_stats["Captured_PrisonMiningPoint"].nil?
rescue
end
begin
apply_slave_states
rescue
end
begin
# A slave owned by another player is identified only by the slave brand.
# Physical cuffs/collars/chains interfere with normal gameplay and must not
# be equipped or restored by the multiplayer contract.
slave_apply_brand_only(true)
rescue
end
# Do not modify stamina for a player-owned slave. The contract only
# applies the slave brand and ownership rules; stamina continues to change
# exclusively through normal gameplay.
unless already
case origin.to_s
when "debt_overdue"
slave_notify("Коллекторы нашли вас за просроченный долг. Владелец: #{owner_nick}.")
when "ally_sale"
slave_notify("Союзник продал вас в рабство игроку #{owner_nick}.")
when "pvp_capture"
slave_notify("Вас захватил игрок #{owner_nick}, пока вы были без выносливости.")
else
slave_notify("Вы попали в рабство игрока #{owner_nick}.")
end
slave_system_chat("Рабский контракт ##{id}: #{slave_origin_text(origin)}, владелец #{owner_nick}, рабочая локация #{work_key}.")
end
if allow_transfer && work_key.to_s != "" && !slave_in_work_map?(work_key)
begin
change_map_enter_tag(work_key.to_s)
rescue
end
end
end
def self.slave_item_object(item_name)
begin
return $data_ItemName[item_name.to_s] if defined?($data_ItemName) && $data_ItemName
rescue
end
nil
end
def self.slave_equipped_mp_bondage?(eqp, item_names)
return false if eqp.nil?
item_names.each do |item_name|
obj = slave_item_object(item_name)
return true if obj && eqp == obj
end
false
rescue
false
end
def self.slave_clear_mp_bondage_slot(actor, slot_id, item_names)
return false unless actor && actor.respond_to?(:equips)
eqp = actor.equips[slot_id] rescue nil
return false unless slave_equipped_mp_bondage?(eqp, item_names)
begin
actor.discard_equip(eqp) if actor.respond_to?(:discard_equip)
rescue
begin
actor.force_change_equip(slot_id, nil) if actor.respond_to?(:force_change_equip)
rescue
begin
actor.change_equip(slot_id, nil) if actor.respond_to?(:change_equip)
rescue
end
end
end
true
rescue
false
end
def self.slave_clear_local_marks_and_bondage
changed = false
actor = nil
begin
actor = $game_player.actor if defined?($game_player) && $game_player
rescue
actor = nil
end
if actor
begin
SLAVE_BONDAGE_BY_SLOT.each do |slot_id, item_names|
changed = true if slave_clear_mp_bondage_slot(actor, slot_id, item_names)
end
rescue
end
begin
if actor.respond_to?(:stat) && actor.stat && actor.stat["SlaveBrand"].to_i != 0
actor.stat["SlaveBrand"] = 0
changed = true
end
rescue
end
begin
actor.refresh_equip_part_covered if actor.respond_to?(:refresh_equip_part_covered)
actor.refresh if actor.respond_to?(:refresh)
actor.update_lonaStat if actor.respond_to?(:update_lonaStat)
actor.actor_ForceUpdate if actor.respond_to?(:actor_ForceUpdate)
rescue
end
end
# Do not delete bondage items from the inventory. Multiplayer slavery no
# longer grants or requires physical restraints; release only clears items
# that are actually equipped and removes the slave brand below.
begin
$story_stats["dialog_cuff"] = 0
$story_stats["dialog_collar"] = 0
$story_stats["dialog_cuff_equiped"] = 1
$story_stats["dialog_collar_equiped"] = 1
rescue
end
begin
$game_player.move_normal if changed && defined?($game_player) && $game_player && $game_player.respond_to?(:move_normal)
$game_player.refresh_chs if changed && defined?($game_player) && $game_player && $game_player.respond_to?(:refresh_chs)
rescue
end
changed
rescue
false
end
def self.clan_estate_slave_local?
begin
return true if defined?($story_stats) && $story_stats && $story_stats["MPClanEstateSlave"].to_i > 0
rescue
end
begin
return true if defined?(MPClanEstate) && MPClanEstate.respond_to?(:clan_slave?) && MPClanEstate.clan_slave?
rescue
end
false
end
def self.slave_transition_personal_to_clan(contract_id=0)
begin
$story_stats["MPPlayerSlaveContract"] = 0
$story_stats["MPPlayerSlaveOwnerProfile"] = 0
$story_stats["MPPlayerSlaveOwnerNick"] = ""
$story_stats["MPPlayerSlaveOrigin"] = "clan_estate"
$story_stats["MPPlayerSlaveWorkMap"] = ""
$story_stats["MPPlayerSlavePatrolPending"] = 0
$story_stats["MPPlayerSlaveLastSavedDay"] = -1
$story_stats["Captured"] = 1
clan_id = 0
begin
clan_id = $story_stats["MPClanEstateClan"].to_i
clan_id = MPClanEstate.state['clan'].to_i if clan_id <= 0 && defined?(MPClanEstate) && MPClanEstate.respond_to?(:state)
rescue
end
$story_stats["SlaveOwner"] = "CLAN:#{clan_id}" if clan_id > 0
rescue
end
begin
slave_apply_brand_only(false)
rescue
end
true
rescue
false
end
def self.slave_release_local(contract_id=0, status="")
id = contract_id.to_i
# Transfer to a clan closes the old personal contract in the DB, but that is
# NOT liberation. Keep the local slave state/brand and silently switch the
# marker to the persistent clan-estate bond.
if clan_estate_slave_local?
slave_transition_personal_to_clan(id)
return
end
mp_local = false
begin
cur = $story_stats["MPPlayerSlaveContract"].to_i
return if id > 0 && cur > 0 && cur != id
mp_local = cur > 0 || $story_stats["SlaveOwner"].to_s.start_with?("MP:")
$story_stats["MPPlayerSlaveContract"] = 0
$story_stats["MPPlayerSlaveOwnerProfile"] = 0
$story_stats["MPPlayerSlaveOwnerNick"] = ""
$story_stats["MPPlayerSlaveOrigin"] = ""
$story_stats["MPPlayerSlaveWorkMap"] = ""
$story_stats["MPPlayerSlavePatrolPending"] = 0
$story_stats["MPPlayerSlaveLastSavedDay"] = -1
if mp_local
$story_stats["SlaveOwner"] = 0
$story_stats["Captured"] = 0
$story_stats["OverMapForceTrans"] = 0
end
rescue
end
cleared_bondage = mp_local ? slave_clear_local_marks_and_bondage : false
begin
MPSlaveEscapeAction.clear_from_hotkeys if mp_local && defined?(MPSlaveEscapeAction) && MPSlaveEscapeAction.respond_to?(:clear_from_hotkeys)
rescue
end
slave_sync_inventory(cleared_bondage ? "mp_slave_release_clear_bondage" : "mp_slave_release_clear") if mp_local
# state_clear is an internal reconciliation result on login, not a user
# initiated release. Showing "contract closed" here was especially wrong
# for slaves already transferred to a persistent clan-estate bond.
slave_notify("Рабский контракт закрыт: #{status}.") unless status.to_s == "state_clear"
rescue
end
def self.slave_apply_state_end
active = slave_active_contract("slave")
if active && active[:status].to_s == "ACTIVE"
local_id = 0
begin
local_id = $story_stats["MPPlayerSlaveContract"].to_i
rescue
end
slave_apply_force_work(active[:id], active[:other_profile], active[:other_nick], active[:origin], active[:work_map], local_id != active[:id].to_i)
else
begin
# After transfer into a clan estate the original personal MP contract is
# closed in the DB, but the clan bond remains active and persistent.
# Do not interpret an empty personal-contract snapshot as liberation.
if clan_estate_slave_local?
slave_transition_personal_to_clan(0)
return
end
owner = $story_stats["SlaveOwner"].to_s
mp_owner = owner.start_with?("MP:")
mp_contract = $story_stats["MPPlayerSlaveContract"].to_i > 0 && (owner == "" || owner == "0" || mp_owner)
slave_release_local(0, "state_clear") if mp_owner || mp_contract
rescue
end
end
rescue
end
def self.slave_print_state
slave_system_chat("Рабские контракты:")
if @mp_slave_contracts.nil? || @mp_slave_contracts.empty?
slave_system_chat(" активных/исторических контрактов нет.")
else
@mp_slave_contracts.first(10).each do |c|
role = c[:role].to_s == "owner" ? "ты владелец" : "ты раб"
slave_system_chat(" ##{c[:id]} #{role}, #{slave_status_text(c[:status])}, #{slave_origin_text(c[:origin])}, с #{c[:other_nick]}, доход=#{c[:owner_income]}, побег=#{c[:escape_progress]}/#{c[:escape_needed]}")
end
end
slave_system_chat("Долги:")
if @mp_slave_debts.nil? || @mp_slave_debts.empty?
slave_system_chat(" долгов нет.")
else
@mp_slave_debts.first(10).each do |d|
left = slave_debt_left(d)
role = d[:role].to_s == "lender" ? "ты дал займ" : "ты должен"
slave_system_chat(" ##{d[:id]} #{role}, #{slave_status_text(d[:status])}, с #{d[:other_nick]}, осталось=#{left}, #{slave_due_text(d[:due_at_ms])}")
end
end
slave_system_chat("Рынок: #{@mp_slave_listings.size} заявок. Доход к получению: #{@mp_slave_wallet.to_i}.")
rescue
end
def self.slave_print_market
slave_request_state
if @mp_slave_listings.nil? || @mp_slave_listings.empty?
slave_system_chat("На стойке гильдии нет добровольных заявок.")
return
end
slave_system_chat("Добровольные заявки на стойке гильдии:")
@mp_slave_listings.first(12).each do |l|
slave_system_chat(" ##{l[:id]} #{l[:slave_nick]} цена=#{l[:price]}. Купить можно через стойку гильдии.")
end
rescue
end
def self.slave_repay_first_debt
slave_request_state
d = slave_open_debt_as_debtor
return slave_notify("Открытого долга для выплаты не найдено.", true) unless d
left = [d[:amount_due].to_i - d[:amount_paid].to_i, 0].max
return slave_notify("Долг уже закрыт.") if left <= 0
slave_repay_debt(d[:id], left)
rescue
end
def self.slave_error_text(code)
{
"auth_required" => "Нужно войти на сервер.",
"mysql_disabled" => "База сервера недоступна.",
"bad_target" => "Неверная цель.",
"bad_amount" => "Неверная сумма.",
"not_enough_gold" => "Недостаточно золота.",
"target_not_online" => "Игрок должен быть онлайн.",
"not_same_map" => "Нужно стоять на одной карте с целью.",
"target_has_stamina" => "Захват возможен только при выносливости цели 0 или ниже.",
"capture_state_unavailable" => "Не удалось получить актуальную выносливость цели. Повторите захват.",
"capture_check_timeout" => "Цель не подтвердила состояние вовремя. Повторите захват.",
"bad_loan" => "Нельзя оформить такой займ.",
"already_owned" => "У игрока уже есть активный владелец.",
"target_already_owned" => "Цель уже в рабстве.",
"already_listed" => "Заявка уже выставлена.",
"listing_not_found" => "Заявка не найдена.",
"debt_not_open" => "Открытый долг не найден.",
"contract_not_active" => "Активный контракт не найден.",
"offer_expired" => "Предложение займа устарело.",
"request_expired" => "Просьба о займе устарела.",
"lender_offline" => "Кредитор уже не онлайн.",
"borrower_offline" => "Заёмщик уже не онлайн.",
"lender_no_gold" => "У кредитора недостаточно золота.",
"no_income" => "Дохода к получению нет.",
"db_error" => "Ошибка базы данных."
}[code.to_s] || "Ошибка рабских контрактов: #{code}"
rescue
"Ошибка рабских контрактов."
end
def self.slave_ok_text(code)
{
"listed" => "Заявка выставлена на стойке гильдии.",
"listing_cancelled" => "Заявка снята.",
"bought" => "Покупка оформлена.",
"loan_offer_sent" => "Предложение займа отправлено. Долг появится только если игрок согласится.",
"loan_request_sent" => "Просьба о займе отправлена. Долг появится только если игрок даст деньги.",
"debt_created" => "Долг оформлен. При просрочке коллекторы переведут должника в рабство.",
"debt_repaid" => "Платёж по долгу принят.",
"debt_paid" => "Долг полностью закрыт.",
"contract_created" => "Контракт создан.",
"escape_progress" => "Прогресс побега увеличен.",
"escaped" => "Побег успешен.",
"released" => "Раб освобождён.",
"work_paid" => "Доход владельцу начислен.",
"income_claimed" => "Доход получен.",
"loan_declined" => "Займ отклонён.",
"loan_request_declined" => "Просьба о займе отклонена."
}[code.to_s] || "Рабские контракты: #{code}"
rescue
"Готово."
end
def self.slave_notice_text(code, text="")
name = text.to_s
{
"loan_declined" => "#{name} отказался от займа.",
"loan_request_declined" => "#{name} отказал в займе.",
"contract_active" => "#{name} теперь в рабском контракте.",
"contract_closed" => "Рабский контракт с #{name} закрыт."
}[code.to_s] || "Рабские контракты: #{code} #{name}".strip
rescue
"Рабские контракты: #{text}"
end
def self.handle_slave_chat_command(text)
t = text.to_s.strip
return false unless t =~ /\A\/(slave|раб|slavery)(\s+|\z)/i
parts = t.split(/\s+/)
cmd = parts[1].to_s.downcase
case cmd
when "", "state", "статус"
slave_request_state
slave_print_state
when "market", "рынок"
slave_print_market
when "list", "sell", "выставить"
slave_list_self((parts[2] || SLAVE_DEFAULT_LIST_PRICE).to_i)
when "cancel", "снять"
slave_cancel_listing
when "buy", "купить"
slave_buy_listing(parts[2].to_i)
when "loan", "lend", "займ"
slave_loan_offer(parts[2].to_i, parts[3].to_i, (parts[4] || SLAVE_DEFAULT_LOAN_HOURS).to_i)
when "request", "borrow", "просить"
slave_loan_request(parts[2].to_i, parts[3].to_i, (parts[4] || SLAVE_DEFAULT_LOAN_HOURS).to_i)
when "accept", "принять"
slave_accept_loan(parts[2].to_i)
when "decline", "reject", "отклонить"
slave_decline_loan(parts[2].to_i)
when "grant", "дать"
slave_grant_loan_request(parts[2].to_i)
when "refuse", "отказать"
slave_reject_loan_request(parts[2].to_i)
when "repay", "pay", "выплатить"
slave_repay_debt(parts[2].to_i, parts[3].to_i)
when "escape", "побег"
slave_escape(parts[2])
when "release", "free", "освободить"
slave_release(parts[2])
when "claim", "доход"
slave_claim_income
when "capture", "захват"
slave_capture(parts[2].to_i)
when "work", "работа"
slave_work_tick_from_mine((parts[3] || parts[2]).to_i)
else
slave_system_chat("Рабские контракты теперь открываются через меню игрока, стойку гильдии и банк. /slave state оставлен для диагностики.")
end
true
rescue
true
end
class << self
unless method_defined?(:mp_slave_send_chat_without_commands)
alias mp_slave_send_chat_without_commands send_chat
end
def send_chat(text, channel = nil)
return if handle_slave_chat_command(text)
if (method(:mp_slave_send_chat_without_commands).arity rescue -1) == 1
mp_slave_send_chat_without_commands(text)
else
mp_slave_send_chat_without_commands(text, channel)
end
end
unless method_defined?(:mp_slave_parse_without_layer)
alias mp_slave_parse_without_layer parse
end
def parse(msg)
# The capture-fix plugin asks the TARGET client for its current stamina.
# This avoids the server's slower persisted/live-state cache deciding the
# capture from an older positive value. The reply is tied to this target
# connection and a one-use nonce by the plugin.
if msg.start_with?("mp_slave_capture_probe:")
parts = msg.split(":", 3)
if parts.size >= 3
captor_id = parts[1].to_i
nonce = parts[2].to_s
sta = nil
begin
actor = $game_player.actor if defined?($game_player) && $game_player
sta = actor.sta.to_f if actor && actor.respond_to?(:sta)
rescue
sta = nil
end
if !sta.nil? && @connected
send_line("mp_slave_capture_sta:#{captor_id}:#{nonce}:#{sta}")
elsif @connected
send_line("mp_slave_capture_sta:#{captor_id}:#{nonce}:unavailable")
end
end
return
end
if msg == "mp_slave_state_begin"
@mp_slave_contracts = []
@mp_slave_debts = []
@mp_slave_listings = []
@mp_slave_state_loading = true
return
end
if msg == "mp_slave_state_end"
@mp_slave_state_loading = false
slave_apply_state_end
return
end
if msg.start_with?("mp_slave_wallet:")
@mp_slave_wallet = msg.split(":", 2)[1].to_i
return
end
if msg.start_with?("mp_slave_contract:")
parts = msg.split(":", 13)
if parts.size >= 13
@mp_slave_contracts ||= []
@mp_slave_contracts << {
:id => parts[1].to_i,
:role => parts[2].to_s,
:other_profile => parts[3].to_i,
:other_nick => slave_unesc(parts[4]),
:origin => slave_unesc(parts[5]),
:status => slave_unesc(parts[6]),
:debt_id => parts[7].to_i,
:work_map => slave_normalize_work_map(slave_unesc(parts[8])),
:owner_income => parts[9].to_i,
:slave_gross => parts[10].to_i,
:escape_progress => parts[11].to_i,
:escape_needed => parts[12].to_i
}
end
return
end
if msg.start_with?("mp_slave_debt:")
parts = msg.split(":", 10)
if parts.size >= 10
@mp_slave_debts ||= []
@mp_slave_debts << {
:id => parts[1].to_i,
:role => parts[2].to_s,
:other_profile => parts[3].to_i,
:other_nick => slave_unesc(parts[4]),
:principal => parts[5].to_i,
:amount_due => parts[6].to_i,
:amount_paid => parts[7].to_i,
:due_at_ms => parts[8].to_i,
:status => slave_unesc(parts[9])
}
end
return
end
if msg.start_with?("mp_slave_listing:")
parts = msg.split(":", 8)
if parts.size >= 8
@mp_slave_listings ||= []
@mp_slave_listings << {
:id => parts[1].to_i,
:seller_profile => parts[2].to_i,
:seller_nick => slave_unesc(parts[3]),
:slave_profile => parts[4].to_i,
:slave_nick => slave_unesc(parts[5]),
:price => parts[6].to_i,
:status => slave_unesc(parts[7])
}
end
return
end
if msg.start_with?("mp_slave_force_work:")
parts = msg.split(":", 6)
slave_apply_force_work(parts[1].to_i, parts[2].to_i, slave_unesc(parts[3]), slave_unesc(parts[4]), slave_unesc(parts[5]), true) if parts.size >= 6
return
end
if msg.start_with?("mp_slave_release_local:")
parts = msg.split(":", 3)
slave_release_local(parts[1].to_i, slave_unesc(parts[2].to_s)) if parts.size >= 3
return
end
if msg.start_with?("mp_slave_loan_offer:")
parts = msg.split(":", 7)
if parts.size >= 7
offer_id = parts[1].to_i
@mp_slave_loan_offers ||= {}
@mp_slave_loan_offers[offer_id] = {
:from_id => parts[2].to_i,
:from_nick => slave_unesc(parts[3]),
:amount => parts[4].to_i,
:hours => parts[5].to_i,
:due_at_ms => parts[6].to_i
}
slave_notify("Предложение займа от #{@mp_slave_loan_offers[offer_id][:from_nick]}: #{@mp_slave_loan_offers[offer_id][:amount]} золота.")
slave_system_chat("Займ ##{offer_id} от #{@mp_slave_loan_offers[offer_id][:from_nick]}: #{@mp_slave_loan_offers[offer_id][:amount]} золота на #{slave_hours_text(@mp_slave_loan_offers[offer_id][:hours])}. Откроется окно принятия; также можно открыть входящие займы у стойки гильдии.")
MPPlayerSlavery.queue_loan_offer(offer_id) if defined?(MPPlayerSlavery) && MPPlayerSlavery.respond_to?(:queue_loan_offer)
end
return
end
if msg.start_with?("mp_slave_loan_request:")
parts = msg.split(":", 7)
if parts.size >= 7
request_id = parts[1].to_i
@mp_slave_loan_requests ||= {}
@mp_slave_loan_requests[request_id] = {
:from_id => parts[2].to_i,
:from_nick => slave_unesc(parts[3]),
:amount => parts[4].to_i,
:hours => parts[5].to_i,
:due_at_ms => parts[6].to_i
}
slave_notify("#{@mp_slave_loan_requests[request_id][:from_nick]} просит займ: #{@mp_slave_loan_requests[request_id][:amount]} золота.")
slave_system_chat("Просьба о займе ##{request_id} от #{@mp_slave_loan_requests[request_id][:from_nick]}: #{@mp_slave_loan_requests[request_id][:amount]} золота на #{slave_hours_text(@mp_slave_loan_requests[request_id][:hours])}. Откроется окно ответа; также можно открыть просьбы о займе у стойки гильдии.")
MPPlayerSlavery.queue_loan_request(request_id) if defined?(MPPlayerSlavery) && MPPlayerSlavery.respond_to?(:queue_loan_request)
end
return
end
if msg.start_with?("mp_slave_gold_delta:")
parts = msg.split(":", 4)
slave_apply_gold_delta(parts[1].to_i, slave_unesc(parts[2].to_s), parts[3].to_i) if parts.size >= 4
return
end
if msg.start_with?("mp_slave_ok:")
code = slave_unesc(msg.split(":", 2)[1].to_s)
slave_reply(slave_ok_text(code))
slave_request_state if ["escape_progress", "escaped"].include?(code.to_s)
return
end
if msg.start_with?("mp_slave_error:")
code = slave_unesc(msg.split(":", 2)[1].to_s)
slave_reply(slave_error_text(code), true)
return
end
if msg.start_with?("mp_slave_notice:")
parts = msg.split(":", 3)
code = slave_unesc(parts[1].to_s)
text = slave_unesc(parts[2].to_s)
slave_system_chat(slave_notice_text(code, text))
return
end
mp_slave_parse_without_layer(msg)
slave_request_state if msg == "sync_unlocked"
end
if method_defined?(:player_menu_actions) && !method_defined?(:mp_slave_player_menu_actions_without_layer)
alias mp_slave_player_menu_actions_without_layer player_menu_actions
def player_menu_actions(target_id)
actions = mp_slave_player_menu_actions_without_layer(target_id)
actions = [] unless actions.is_a?(Array)
actions << [SLAVE_CONTEXT_TEXT, :slave_context]
actions
rescue
[[SLAVE_CONTEXT_TEXT, :slave_context]]
end
end
unless method_defined?(:mp_slave_disconnect_without_layer)
alias mp_slave_disconnect_without_layer disconnect
def disconnect(*args, &block)
mp_slave_disconnect_without_layer(*args, &block)
ensure
slave_clear_state
end
end
end
end
module MPPlayerSlavery
def self.worker_say(text)
WebSocket.slave_worker_say(text)
rescue
end
def self.worker_command
WebSocket.slave_expect_worker_reply!
yield
rescue
end
def self.call_menu(interpreter, text)
if interpreter && interpreter.respond_to?(:call_msg, true)
interpreter.send(:call_msg, text)
else
call_msg(text)
end
rescue
end
def self.choice(interpreter, text)
call_menu(interpreter, text)
$game_temp.choice.to_i
rescue
-1
ensure
begin
$game_temp.choice = -1
rescue
end
end
def self.option_text(rows)
rows.map{|row| row[0].to_s.gsub(",", " ")}.join(",")
rescue
""
end
def self.connected?
defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
rescue
false
end
def self.ensure_connected
unless connected?
WebSocket.slave_notify("Нет соединения с сервером.", true) if defined?(WebSocket)
return false
end
true
rescue
false
end
def self.queue_loan_offer(offer_id)
@mp_slave_pending_offers ||= []
id = offer_id.to_i
return if id <= 0
@mp_slave_pending_offers << id unless @mp_slave_pending_offers.include?(id)
rescue
end
def self.queue_loan_request(request_id)
@mp_slave_pending_requests ||= []
id = request_id.to_i
return if id <= 0
@mp_slave_pending_requests << id unless @mp_slave_pending_requests.include?(id)
rescue
end
def self.clear_loan_dialog_queues
@mp_slave_pending_offers = []
@mp_slave_pending_requests = []
rescue
end
def self.next_loan_offer
@mp_slave_pending_offers ||= []
until @mp_slave_pending_offers.empty?
id = @mp_slave_pending_offers.shift.to_i
return id if id > 0 && WebSocket.slave_loan_offer_info(id)
end
nil
rescue
nil
end
def self.next_loan_request
@mp_slave_pending_requests ||= []
until @mp_slave_pending_requests.empty?
id = @mp_slave_pending_requests.shift.to_i
return id if id > 0 && WebSocket.slave_loan_request_info(id)
end
nil
rescue
nil
end
def self.open_loan_offer_dialog(interpreter, offer_id)
offer = WebSocket.slave_loan_offer_info(offer_id)
return worker_say("Предложение займа уже недоступно.") unless offer
rows = [["Принять займ", :accept], ["Отказаться", :decline], ["Позже", :later]]
text = "\\CBmp[BankMaani,20]\\prf\\c[4]Займ:\\C[0] #{offer[:from_nick]} предлагает #{offer[:amount]} золота на #{WebSocket.slave_hours_text(offer[:hours])}. Если не вернуть долг через банк до срока, коллекторы отправят должника на работу. \\optB[#{option_text(rows)}]"
selected = rows[choice(interpreter, text)]
case selected && selected[1]
when :accept
worker_command { WebSocket.slave_accept_loan(offer_id) }
when :decline
worker_command { WebSocket.slave_decline_loan(offer_id) }
end
rescue
end
def self.open_loan_request_dialog(interpreter, request_id)
request = WebSocket.slave_loan_request_info(request_id)
return worker_say("Просьба о займе уже недоступна.") unless request
rows = [["Дать займ", :grant], ["Отказать", :reject], ["Позже", :later]]
text = "\\CBmp[BankMaani,20]\\prf\\c[4]Просьба о займе:\\C[0] #{request[:from_nick]} просит #{request[:amount]} золота на #{WebSocket.slave_hours_text(request[:hours])}. Если он не вернет долг через банк до срока, коллекторы отправят его на работу. \\optB[#{option_text(rows)}]"
selected = rows[choice(interpreter, text)]
case selected && selected[1]
when :grant
worker_command { WebSocket.slave_grant_loan_request(request_id) }
when :reject
worker_command { WebSocket.slave_reject_loan_request(request_id) }
end
rescue
end
def self.open_pending_loan_offers(interpreter=nil)
entries = WebSocket.slave_pending_loan_offers.to_a
if entries.empty?
worker_say("Входящих предложений займа нет.")
return
end
rows = entries.first(6).map{|id, offer|
["#{offer[:from_nick]}: #{offer[:amount]} на #{WebSocket.slave_hours_text(offer[:hours])}", :offer, id]
}
rows << ["Назад", :cancel, nil]
selected = rows[choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Входящие займы:\\C[0] Какое предложение открыть? \\optB[#{option_text(rows)}]")]
return unless selected && selected[1] == :offer && selected[2]
open_loan_offer_dialog(interpreter, selected[2].to_i)
rescue
end
def self.open_pending_loan_requests(interpreter=nil)
entries = WebSocket.slave_pending_loan_requests.to_a
if entries.empty?
worker_say("Просьб о займе нет.")
return
end
rows = entries.first(6).map{|id, request|
["#{request[:from_nick]}: #{request[:amount]} на #{WebSocket.slave_hours_text(request[:hours])}", :request, id]
}
rows << ["Назад", :cancel, nil]
selected = rows[choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Просьбы о займе:\\C[0] Кто просит у тебя деньги? \\optB[#{option_text(rows)}]")]
return unless selected && selected[1] == :request && selected[2]
open_loan_request_dialog(interpreter, selected[2].to_i)
rescue
end
def self.open_market(interpreter=nil)
WebSocket.slave_request_state
listings = WebSocket.slave_market_list.select{|row| row.is_a?(Hash) && row[:status].to_s == "ACTIVE"}
if listings.empty?
worker_say("На стойке гильдии нет добровольных заявок.")
return
end
rows = listings.first(6).map{|l| ["#{l[:slave_nick]} за #{l[:price]} золота", :buy, l]}
rows << ["Назад", :cancel, nil]
selected = rows[choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Рынок гильдии:\\C[0] Кого купить дистанционно? \\optB[#{option_text(rows)}]")]
return unless selected && selected[1] == :buy && selected[2]
listing = selected[2]
confirm = choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Покупка:\\C[0] Купить #{listing[:slave_nick]} за #{listing[:price]} золота? Сервер не даст купить уже занятого игрока дважды. \\optB[Купить,Назад]")
worker_command { WebSocket.slave_buy_listing(listing[:id]) } if confirm == 0
rescue
end
def self.open_self_listing(interpreter=nil)
rows = WebSocket::SLAVE_LIST_PRICES.map{|price| ["#{price} золота", :price, price]}
rows << ["Назад", :cancel, nil]
selected = rows[choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Заявка:\\C[0] За какую цену выставить себя на стойку гильдии? \\optB[#{option_text(rows)}]")]
return unless selected && selected[1] == :price
confirm = choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Заявка:\\C[0] Выставить себя на продажу за #{selected[2]} золота? Покупатель сможет оформить контракт дистанционно. \\optB[Выставить,Назад]")
worker_command { WebSocket.slave_list_self(selected[2]) } if confirm == 0
rescue
end
def self.open_escape_or_release(interpreter=nil)
if WebSocket.slave_active_contract("owner")
c = WebSocket.slave_active_contract("owner")
confirm = choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Освобождение:\\C[0] Освободить #{c[:other_nick]} и закрыть доход по контракту? \\optB[Освободить,Назад]")
worker_command { WebSocket.slave_release(c[:id]) } if confirm == 0
elsif WebSocket.slave_active_contract("slave")
worker_say("Побег выполняется навыком «Попытка бегства». Назначьте его на панель навыков.")
else
worker_say("Активного контракта нет.")
end
rescue
end
def self.open(interpreter=nil)
return unless ensure_connected
WebSocket.slave_request_state
rows = [
["Мои долги и контракты", :state],
["Рынок добровольных рабов", :market],
["Выставить себя", :list],
["Снять свою заявку", :cancel_listing],
["Входящие займы", :offers],
["Просьбы о займе", :requests],
["Получить доход", :claim]
]
rows << ["Освободить раба", :escape_release] if WebSocket.slave_active_contract("owner")
rows << ["Назад", :cancel]
selected = rows[choice(interpreter, "\\CBmp[GuildEmpolyee,20]\\prf\\c[4]Стойка гильдии:\\C[0] Рабские контракты и долговые дела. \\optB[#{option_text(rows)}]")]
case selected && selected[1]
when :state
WebSocket.slave_request_state
WebSocket.slave_print_state
when :market
open_market(interpreter)
when :list
open_self_listing(interpreter)
when :cancel_listing
worker_command { WebSocket.slave_cancel_listing }
when :offers
open_pending_loan_offers(interpreter)
when :requests
open_pending_loan_requests(interpreter)
when :claim
worker_command { WebSocket.slave_claim_income }
when :escape_release
open_escape_or_release(interpreter)
end
rescue
end
def self.open_bank(interpreter=nil)
return unless ensure_connected
WebSocket.slave_request_state
debt = WebSocket.slave_open_debt_as_debtor
if debt
left = WebSocket.slave_debt_left(debt)
rows = [["Выплатить #{left} золота", :repay], ["Показать долги", :state], ["Назад", :cancel]]
selected = rows[choice(interpreter, "\\CBmp[BankMaani,20]\\prf\\c[4]Банк:\\C[0] Долг перед #{debt[:other_nick]}: осталось #{left} золота, #{WebSocket.slave_due_text(debt[:due_at_ms])}. \\optB[#{option_text(rows)}]")]
case selected && selected[1]
when :repay
confirm = choice(interpreter, "\\CBmp[BankMaani,20]\\prf\\c[4]Банк:\\C[0] Выплатить #{left} золота по долгу? После полной выплаты рабство по этому долгу закрывается. \\optB[Выплатить,Назад]")
WebSocket.slave_repay_debt(debt[:id], left) if confirm == 0
when :state
WebSocket.slave_print_state
end
else
rows = [["Показать историю", :state], ["Назад", :cancel]]
selected = rows[choice(interpreter, "\\CBmp[BankMaani,20]\\prf\\c[4]Банк:\\C[0] Открытых долгов для выплаты нет. \\optB[#{option_text(rows)}]")]
WebSocket.slave_print_state if selected && selected[1] == :state
end
rescue
end
end
class Scene_Map < Scene_Base
unless method_defined?(:mp_slave_player_menu_open_without_layer)
alias mp_slave_player_menu_open_without_layer mp_open_player_menu
end
unless method_defined?(:mp_slave_scene_update_without_offer_dialog)
alias mp_slave_scene_update_without_offer_dialog update
end
def update(*args, &block)
mp_slave_scene_update_without_offer_dialog(*args, &block)
mp_slave_update_offer_dialog
end
def mp_open_player_menu(target_id)
mp_slave_player_menu_open_without_layer(target_id)
begin
if @mp_player_menu_window
@mp_player_menu_window.set_handler(:slave_context, method(:mp_player_menu_slave_context))
@mp_player_menu_window.set_handler(:slave_capture, method(:mp_player_menu_slave_capture))
@mp_player_menu_window.set_handler(:slave_loan, method(:mp_player_menu_slave_loan))
@mp_player_menu_window.set_handler(:slave_borrow, method(:mp_player_menu_slave_borrow))
end
rescue
end
end
unless method_defined?(:mp_slave_sell_without_confirm)
alias mp_slave_sell_without_confirm mp_player_menu_sell
end
def mp_player_menu_sell
tid = @mp_player_menu_target_id.to_i
mp_slave_open_group_sell_confirm(tid)
rescue
end
def mp_slave_open_window(target_id, actions)
mp_dispose_player_menu
@mp_player_menu_target_id = target_id.to_i
@mp_player_menu_window = Window_MPPlayerMenu.new
@mp_player_menu_window.set_actions(actions)
{
:slave_context => :mp_player_menu_slave_context,
:slave_loan => :mp_player_menu_slave_loan,
:slave_borrow => :mp_player_menu_slave_borrow,
:slave_loan_amount => :mp_player_menu_slave_loan_amount,
:slave_loan_hours => :mp_player_menu_slave_loan_hours,
:slave_loan_send => :mp_player_menu_slave_loan_send,
:slave_request_send => :mp_player_menu_slave_request_send,
:slave_capture => :mp_player_menu_slave_capture,
:slave_capture_send => :mp_player_menu_slave_capture_send,
:slave_group_sell => :mp_player_menu_slave_group_sell,
:slave_group_sell_send => :mp_player_menu_slave_group_sell_send,
:slave_state => :mp_player_menu_slave_state,
:slave_offer_accept => :mp_player_menu_slave_offer_accept,
:slave_offer_decline => :mp_player_menu_slave_offer_decline,
:slave_request_grant => :mp_player_menu_slave_request_grant,
:slave_request_reject => :mp_player_menu_slave_request_reject,
:slave_back_context => :mp_player_menu_slave_context,
:slave_back_amount => :mp_player_menu_slave_back_amount,
:slave_back_hours => :mp_player_menu_slave_back_hours
}.each do |symbol, method_name|
@mp_player_menu_window.set_handler(symbol, method(method_name)) if respond_to?(method_name)
end
@mp_player_menu_window.set_handler(:cancel, method(:mp_close_player_menu))
@mp_player_menu_activate_at = (Graphics.frame_count rescue 0) + 1
rescue => e
puts "[MP_SLAVE_UI] open failed: #{e.class}: #{e.message}"
mp_dispose_player_menu
end
def mp_slave_current_ext
@mp_player_menu_window.current_ext rescue nil
end
def mp_player_menu_slave_context
tid = @mp_player_menu_target_id.to_i
return mp_close_player_menu if tid <= 0
name = WebSocket.slave_player_name(tid)
WebSocket.slave_notify("Дела с #{name}: займ, захват или продажа союзника.")
actions = [[WebSocket::SLAVE_BORROW_TEXT, :slave_borrow], [WebSocket::SLAVE_LOAN_TEXT, :slave_loan]]
actions << [WebSocket::SLAVE_CAPTURE_TEXT, :slave_capture] if WebSocket.can_capture_player?(tid)
actions << ["Продать союзника", :slave_group_sell] if WebSocket.respond_to?(:can_sell_group_member?) && WebSocket.can_sell_group_member?(tid)
actions << ["Мои долги", :slave_state]
actions << ["Назад", :cancel]
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_loan
tid = @mp_player_menu_target_id.to_i
@mp_slave_loan_mode = :lend
gold = WebSocket.slave_gold
if gold <= 0
WebSocket.slave_notify("Нужно золото, чтобы дать займ.", true)
return mp_close_player_menu
end
amounts = WebSocket::SLAVE_LOAN_AMOUNTS.select{|amount| amount.to_i <= gold}
amounts << gold if amounts.empty? && gold > 0
amounts = amounts.uniq.sort
WebSocket.slave_notify("Выбери сумму. Деньги спишутся только если игрок согласится.")
actions = amounts.map{|amount| ["#{amount} золота", :slave_loan_amount, amount]}
actions << ["Назад", :slave_back_context]
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_borrow
tid = @mp_player_menu_target_id.to_i
@mp_slave_loan_mode = :borrow
WebSocket.slave_notify("Выбери сумму, которую хочешь попросить у игрока.")
actions = WebSocket::SLAVE_LOAN_AMOUNTS.map{|amount| ["#{amount} золота", :slave_loan_amount, amount]}
actions << ["Назад", :slave_back_context]
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_back_amount
if @mp_slave_loan_mode.to_s == "borrow"
mp_player_menu_slave_borrow
else
mp_player_menu_slave_loan
end
rescue
end
def mp_player_menu_slave_loan_amount
tid = @mp_player_menu_target_id.to_i
@mp_slave_loan_amount = mp_slave_current_ext.to_i
if @mp_slave_loan_mode.to_s == "borrow"
WebSocket.slave_notify("Выбери срок, до которого обещаешь вернуть деньги.")
else
WebSocket.slave_notify("Выбери срок возврата. После просрочки долг заберут коллекторы.")
end
actions = WebSocket::SLAVE_LOAN_TERMS.map{|hours, label| [label, :slave_loan_hours, hours]}
actions << ["Назад", :slave_back_amount]
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_back_hours
tid = @mp_player_menu_target_id.to_i
amount = @mp_slave_loan_amount.to_i
@mp_slave_loan_amount = amount
actions = WebSocket::SLAVE_LOAN_TERMS.map{|hours, label| [label, :slave_loan_hours, hours]}
actions << ["Назад", :slave_back_amount]
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_loan_hours
tid = @mp_player_menu_target_id.to_i
@mp_slave_loan_hours = mp_slave_current_ext.to_i
amount = @mp_slave_loan_amount.to_i
hours = @mp_slave_loan_hours.to_i
name = WebSocket.slave_player_name(tid)
if @mp_slave_loan_mode.to_s == "borrow"
WebSocket.slave_notify("Просьба к #{name}: #{amount} золота на #{WebSocket.slave_hours_text(hours)}.")
actions = [["Попросить займ", :slave_request_send], ["Назад", :slave_back_hours], ["Отмена", :cancel]]
else
WebSocket.slave_notify("Займ #{name}: #{amount} золота на #{WebSocket.slave_hours_text(hours)}.")
actions = [["Дать в долг", :slave_loan_send], ["Назад", :slave_back_hours], ["Отмена", :cancel]]
end
mp_slave_open_window(tid, actions)
rescue
end
def mp_player_menu_slave_loan_send
tid = @mp_player_menu_target_id.to_i
amount = @mp_slave_loan_amount.to_i
hours = @mp_slave_loan_hours.to_i
mp_close_player_menu
if WebSocket.slave_loan_offer(tid, amount, hours)
WebSocket.slave_notify("Предложение займа отправлено игроку #{WebSocket.slave_player_name(tid)}.")
end
rescue
end
def mp_player_menu_slave_request_send
tid = @mp_player_menu_target_id.to_i
amount = @mp_slave_loan_amount.to_i
hours = @mp_slave_loan_hours.to_i
mp_close_player_menu
if WebSocket.slave_loan_request(tid, amount, hours)
WebSocket.slave_notify("Просьба о займе отправлена игроку #{WebSocket.slave_player_name(tid)}.")
end
rescue
end
def mp_player_menu_slave_capture
tid = @mp_player_menu_target_id.to_i
unless WebSocket.can_capture_player?(tid)
WebSocket.slave_notify("Игрок сейчас недоступен для проверки захвата.", true)
return mp_close_player_menu
end
WebSocket.slave_notify("Сервер проверит текущую выносливость цели. Захват пройдёт только при STA 0 или ниже.")
mp_slave_open_window(tid, [["Проверить и захватить", :slave_capture_send], ["Назад", :slave_back_context]])
rescue
end
def mp_player_menu_slave_capture_send
tid = @mp_player_menu_target_id.to_i
mp_close_player_menu
WebSocket.slave_capture(tid) if defined?(WebSocket) && WebSocket.respond_to?(:slave_capture)
rescue
end
def mp_player_menu_slave_group_sell
tid = @mp_player_menu_target_id.to_i
mp_slave_open_group_sell_confirm(tid)
rescue
end
def mp_slave_open_group_sell_confirm(tid)
unless WebSocket.respond_to?(:can_sell_group_member?) && WebSocket.can_sell_group_member?(tid)
WebSocket.slave_notify("Продать можно только союзника без выносливости.", true)
return mp_close_player_menu
end
WebSocket.slave_notify("Подтверди продажу союзника #{WebSocket.slave_player_name(tid)}.")
mp_slave_open_window(tid, [["Продать союзника", :slave_group_sell_send], ["Назад", :slave_back_context]])
rescue
end
def mp_player_menu_slave_group_sell_send
tid = @mp_player_menu_target_id.to_i
mp_close_player_menu
WebSocket.group_sell_request(tid) if defined?(WebSocket) && WebSocket.respond_to?(:group_sell_request)
rescue
end
def mp_player_menu_slave_state
mp_close_player_menu
WebSocket.slave_request_state if defined?(WebSocket) && WebSocket.respond_to?(:slave_request_state)
WebSocket.slave_print_state if defined?(WebSocket) && WebSocket.respond_to?(:slave_print_state)
rescue
end
def mp_slave_offer_dialog_allowed?
return false if @mp_player_menu_window
return false unless defined?(MPPlayerSlavery) && MPPlayerSlavery.respond_to?(:next_loan_offer) && MPPlayerSlavery.respond_to?(:next_loan_request)
return false if defined?($game_message) && $game_message && ($game_message.busy? || $game_message.visible)
return false if defined?($game_map) && $game_map && $game_map.respond_to?(:interpreter) && $game_map.interpreter && $game_map.interpreter.running?
return false if defined?(WebSocket) && WebSocket.respond_to?(:trade_active?) && WebSocket.trade_active?
true
rescue
false
end
def mp_slave_update_offer_dialog
return unless mp_slave_offer_dialog_allowed?
offer_id = MPPlayerSlavery.next_loan_offer
return mp_slave_open_loan_offer_dialog(offer_id) if offer_id
request_id = MPPlayerSlavery.next_loan_request
return unless request_id
mp_slave_open_loan_request_dialog(request_id)
rescue
end
def mp_slave_open_loan_offer_dialog(offer_id)
offer = WebSocket.slave_loan_offer_info(offer_id)
return unless offer
WebSocket.slave_notify("#{offer[:from_nick]} предлагает займ: #{offer[:amount]} золота на #{WebSocket.slave_hours_text(offer[:hours])}.")
mp_slave_open_window(0, [["Принять займ", :slave_offer_accept, offer_id], ["Отказаться", :slave_offer_decline, offer_id], ["Позже", :cancel]])
rescue
end
def mp_slave_open_loan_request_dialog(request_id)
request = WebSocket.slave_loan_request_info(request_id)
return unless request
WebSocket.slave_notify("#{request[:from_nick]} просит займ: #{request[:amount]} золота на #{WebSocket.slave_hours_text(request[:hours])}.")
mp_slave_open_window(0, [["Дать займ", :slave_request_grant, request_id], ["Отказать", :slave_request_reject, request_id], ["Позже", :cancel]])
rescue
end
def mp_player_menu_slave_offer_accept
offer_id = mp_slave_current_ext.to_i
mp_close_player_menu
WebSocket.slave_accept_loan(offer_id)
rescue
end
def mp_player_menu_slave_offer_decline
offer_id = mp_slave_current_ext.to_i
mp_close_player_menu
WebSocket.slave_decline_loan(offer_id)
rescue
end
def mp_player_menu_slave_request_grant
request_id = mp_slave_current_ext.to_i
mp_close_player_menu
WebSocket.slave_grant_loan_request(request_id)
rescue
end
def mp_player_menu_slave_request_reject
request_id = mp_slave_current_ext.to_i
mp_close_player_menu
WebSocket.slave_reject_loan_request(request_id)
rescue
end
end
#==============================================================================
# Multiplayer slavery — escape skill and struggle animation
#==============================================================================
module MPSlaveEscapeAction
KEY_PATH = 'Graphics/Online/exit_rab.png'
ITEM_NAME = 'mp_slave_escape_skill'
TEXT_NAME = 'mp/slave_escape/name'
TEXT_DESC = 'mp/slave_escape/desc'
LABEL = 'Попытка бегства'
ANIMATION_SECONDS = 5
ANIMATION_FRAMES = ANIMATION_SECONDS * (Graphics.frame_rate rescue 60)
CHAIN_SOUND_FRAMES = [0, 90, 180, 270]
# NPC проверяются на протяжении всей попытки. Радиус задаётся в тайлах.
WITNESS_RANGE = 7
WITNESS_SIGNAL_STRENGTH = 15
WITNESS_CHECK_INTERVAL = 6
WITNESS_AGGRO_FRAMES = 600
class << self
attr_accessor :escape_skill_id
end
@animation_state = nil
def self.assign_attr(obj, attr, value)
return if obj.nil?
setter = (attr.to_s + '=').to_sym
obj.send(setter, value) if obj.respond_to?(setter)
rescue
end
def self.install_text
begin
$game_text[TEXT_NAME] = LABEL
$game_text[TEXT_DESC] = 'Пять секунд скрытно готовить побег. Если NPC заметит попытку, он нападёт, а побег не засчитается.'
rescue
end
end
def self.ensure_escape_skill
return nil unless defined?($data_skills) && $data_skills
if @escape_skill_id && $data_skills[@escape_skill_id] && escape_skill?($data_skills[@escape_skill_id])
install_text
return @escape_skill_id
end
existing = nil
begin
existing = $data_skills.compact.find { |skill| escape_skill?(skill) }
rescue
existing = nil
end
if existing
@escape_skill_id = existing.id rescue nil
install_text
return @escape_skill_id
end
template = nil
begin
template = $data_skills.compact.find { |skill| skill && skill.respond_to?(:item_name) && skill.respond_to?(:id) }
rescue
template = nil
end
return nil unless template
skill = nil
begin
skill = template.clone
rescue
begin
skill = template.dup
rescue
skill = nil
end
end
return nil unless skill
id = $data_skills.length
assign_attr(skill, :id, id)
assign_attr(skill, :item_name, ITEM_NAME)
assign_attr(skill, :name, TEXT_NAME)
assign_attr(skill, :description, TEXT_DESC)
assign_attr(skill, :icon_index, KEY_PATH)
assign_attr(skill, :type, 'other')
begin
$data_skills[id] = skill
rescue
return nil
end
begin
$data_SkillName[ITEM_NAME] = skill if defined?($data_SkillName) && $data_SkillName.respond_to?(:[]=)
rescue
end
@escape_skill_id = id
install_text
id
end
def self.escape_skill
id = ensure_escape_skill
return nil if id.nil?
$data_skills[id] rescue nil
end
def self.escape_skill?(obj)
return false if obj.nil?
begin
return true if obj.respond_to?(:item_name) && obj.item_name.to_s == ITEM_NAME
rescue
end
begin
return true if @escape_skill_id && obj.respond_to?(:id) && obj.id.to_i == @escape_skill_id.to_i
rescue
end
false
end
def self.escape_slot?(slot)
return true if escape_skill?(slot)
sid = nil
begin
sid = slot.id if slot.respond_to?(:id)
rescue
sid = nil
end
sid = slot if sid.nil?
sid = sid.to_i rescue 0
return false if sid <= 0
return true if ensure_escape_skill.to_i == sid
begin
escape_skill?($data_skills[sid])
rescue
false
end
end
def self.active_contract
return nil unless defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract)
WebSocket.slave_active_contract('slave')
rescue
nil
end
def self.local_contract_id
active = active_contract
return active[:id].to_i if active && active[:id].to_i > 0
begin
return $story_stats['MPPlayerSlaveContract'].to_i
rescue
0
end
end
def self.available?
active = active_contract
return true if active && active[:status].to_s == 'ACTIVE'
begin
local_contract_id > 0 && $story_stats['SlaveOwner'].to_s.start_with?('MP:')
rescue
false
end
end
def self.owner_name
active = active_contract
return active[:other_nick].to_s if active && !active[:other_nick].to_s.empty?
begin
name = $story_stats['MPPlayerSlaveOwnerNick'].to_s
return name unless name.empty?
rescue
end
'другого игрока'
end
def self.progress_text
active = active_contract
return 'Состояние побега запрашивается у сервера.' unless active
"Прогресс побега: #{active[:escape_progress].to_i}/#{active[:escape_needed].to_i}."
rescue
'Состояние побега запрашивается у сервера.'
end
def self.animation_busy?
!@animation_state.nil?
rescue
false
end
def self.frame_count
Graphics.frame_count.to_i
rescue
0
end
def self.chain_sound
begin
SndLib.sound_step_chain(100, 90)
rescue
begin
SndLib.sound_step_chain(100)
rescue
end
end
end
def self.pick_animation(player)
[:animation_atk_pray_hold, :animation_mc_pick_up_hold, :animation_hold_sh, :animation_stun].each do |method_name|
begin
next unless player.respond_to?(method_name)
animation = player.send(method_name)
return animation unless animation.nil?
rescue
end
end
nil
rescue
nil
end
def self.npc_event_usable?(event)
return false if event.nil?
return false if event.respond_to?(:erased) && event.erased
return false if event.respond_to?(:deleted?) && event.deleted?
return false if event.respond_to?(:opacity) && event.opacity.to_i < 255
actor = event.actor rescue nil
return false if actor.nil?
state = actor.action_state rescue nil
return false if state == :death
return false if actor.respond_to?(:is_object) && actor.is_object
true
rescue
false
end
# Считываем реальную силу сенсора без IFF-фильтра, чтобы попытку могли
# заметить даже изначально дружелюбные NPC. Препятствия и направление
# взгляда по-прежнему учитываются стандартным сенсором игры.
def self.raw_sensor_strength(sensor, event, player)
return 0.0 if sensor.nil? || event.nil? || player.nil?
if sensor.respond_to?(:mine_number) && sensor.respond_to?(:calc_sight_hp_and_dist) && sensor.respond_to?(:calc_signal_strength)
mine_value = sensor.mine_number(event, player, false)
return 0.0 if mine_value.nil? || mine_value.to_f <= 0.0
visual = sensor.calc_sight_hp_and_dist(event, player)
return 0.0 unless visual.is_a?(Array) && visual[0].to_f >= 0.0
return sensor.calc_signal_strength(event, player, visual[0], mine_value).to_f
end
signal = sensor.get_signal(event, player) if sensor.respond_to?(:get_signal)
return signal[2].to_f if signal.is_a?(Array) && signal.length >= 3
0.0
rescue
0.0
end
def self.npc_already_attacking_player?(actor, player)
target = actor.target rescue nil
target == player
rescue
false
end
def self.npc_sees_escape?(event, player)
return false unless npc_event_usable?(event)
return false if player.nil?
begin
return false unless event.near_the_target?(player, WITNESS_RANGE)
rescue
begin
dx = (event.x.to_i - player.x.to_i).abs
dy = (event.y.to_i - player.y.to_i).abs
return false if Math.sqrt(dx * dx + dy * dy) >= WITNESS_RANGE
rescue
return false
end
end
actor = event.actor rescue nil
return true if actor && npc_already_attacking_player?(actor, player)
sensors = actor.sensors rescue nil
return false unless sensors.respond_to?(:each)
sensors.each do |sensor|
return true if raw_sensor_strength(sensor, event, player) > WITNESS_SIGNAL_STRENGTH
end
false
rescue
false
end
def self.visible_witnesses(player=nil)
player ||= (defined?($game_player) ? $game_player : nil)
return [] if player.nil? || !defined?($game_map) || $game_map.nil?
npcs = $game_map.npcs rescue nil
return [] unless npcs.respond_to?(:each)
result = []
npcs.each do |event|
result << event if npc_sees_escape?(event, player)
end
result
rescue
[]
end
def self.force_witness_attack(witnesses, player=nil)
player ||= (defined?($game_player) ? $game_player : nil)
return 0 if player.nil?
attacker = player.actor rescue nil
skill = nil
begin
skill = $data_arpgskills['BasicNormal'] if defined?($data_arpgskills) && $data_arpgskills
rescue
skill = nil
end
return 0 if attacker.nil? || skill.nil?
count = 0
Array(witnesses).each do |event|
next unless npc_event_usable?(event)
actor = event.actor rescue nil
next if actor.nil? || !actor.respond_to?(:set_aggro)
begin
actor.set_aggro(attacker, skill, WITNESS_AGGRO_FRAMES)
event.turn_toward_character(player) if event.respond_to?(:turn_toward_character)
count += 1
rescue
end
end
count
rescue
0
end
def self.clear_attempt_animation(state, player=nil)
player ||= (defined?($game_player) ? $game_player : nil)
return unless state.is_a?(Hash)
begin
if player && !state[:animation].nil? && player.animation.equal?(state[:animation])
player.animation = nil
end
rescue
begin
player.animation = nil if player
rescue
end
end
end
def self.fail_for_witnesses(witnesses, player=nil, state=nil)
state ||= @animation_state
@animation_state = nil
clear_attempt_animation(state, player)
count = force_witness_attack(witnesses, player)
begin
SndLib.sys_buzzer
rescue
end
if defined?(WebSocket)
text = count > 1 ? "Попытку заметили NPC (#{count}). Они нападают — побег не удался." : 'NPC заметил попытку и нападает — побег не удался.'
WebSocket.slave_notify(text, true)
end
false
rescue
@animation_state = nil
false
end
def self.start_attempt(contract_id=nil)
return false unless available?
if animation_busy?
WebSocket.slave_notify('Попытка бегства уже выполняется.', true) if defined?(WebSocket)
return false
end
id = contract_id.to_i
id = local_contract_id if id <= 0
if id <= 0
WebSocket.slave_notify('Контракт ещё не синхронизирован с сервером.', true) if defined?(WebSocket)
return false
end
player = defined?($game_player) ? $game_player : nil
return false if player.nil?
begin
current_animation = player.animation
unless current_animation.nil?
WebSocket.slave_notify('Сначала завершите текущее действие.', true) if defined?(WebSocket)
return false
end
rescue
end
witnesses = visible_witnesses(player)
return fail_for_witnesses(witnesses, player, nil) unless witnesses.empty?
animation = pick_animation(player)
now = frame_count
@animation_state = {
:contract_id => id,
:started_at => now,
:ends_at => now + ANIMATION_FRAMES,
:next_witness_check => now + WITNESS_CHECK_INTERVAL,
:sound_index => 0,
:animation => animation
}
begin
player.move_normal if player.respond_to?(:move_normal)
rescue
end
begin
player.animation = animation unless animation.nil?
rescue
end
chain_sound
@animation_state[:sound_index] = 1
true
rescue
@animation_state = nil
false
end
def self.update_animation(player=nil)
state = @animation_state
return unless state.is_a?(Hash)
player ||= (defined?($game_player) ? $game_player : nil)
now = frame_count
elapsed = now - state[:started_at].to_i
if now >= state[:next_witness_check].to_i
state[:next_witness_check] = now + WITNESS_CHECK_INTERVAL
witnesses = visible_witnesses(player)
return fail_for_witnesses(witnesses, player, state) unless witnesses.empty?
end
index = state[:sound_index].to_i
while index < CHAIN_SOUND_FRAMES.length && elapsed >= CHAIN_SOUND_FRAMES[index]
chain_sound
index += 1
end
state[:sound_index] = index
if now < state[:ends_at].to_i
begin
if player && !state[:animation].nil? && player.animation.nil?
player.animation = state[:animation]
end
rescue
end
return
end
@animation_state = nil
clear_attempt_animation(state, player)
id = state[:contract_id].to_i
if defined?(WebSocket) && WebSocket.respond_to?(:slave_escape_commit)
ok = WebSocket.slave_escape_commit(id)
WebSocket.slave_notify('Попытка завершена. Ожидается ответ сервера.', false) if ok
end
rescue
@animation_state = nil
end
def self.cancel_animation
state = @animation_state
@animation_state = nil
clear_attempt_animation(state)
rescue
@animation_state = nil
end
def self.consume_as_escape_action(key)
return false if key.nil?
triggered = false
begin
triggered = Input.trigger?(key) || (Input.press?(key) && (($game_player.instance_variable_get(:@prevSkillKey) rescue nil) != key))
rescue
triggered = false
end
return false unless triggered
begin
$game_player.instance_variable_set(:@prevSkillKey, key)
rescue
end
unless available?
begin
SndLib.sys_buzzer
rescue
end
WebSocket.slave_notify('Навык доступен только активному рабу другого игрока.', true) if defined?(WebSocket)
return true
end
id = local_contract_id
if id <= 0
WebSocket.slave_request_state if defined?(WebSocket) && WebSocket.respond_to?(:slave_request_state)
WebSocket.slave_notify('Контракт ещё не синхронизирован с сервером.', true) if defined?(WebSocket)
return true
end
begin
SndLib.sys_ok
rescue
end
WebSocket.slave_escape(id) if defined?(WebSocket) && WebSocket.respond_to?(:slave_escape)
true
rescue
true
end
def self.clear_from_hotkeys
id = ensure_escape_skill.to_i
return false if id <= 0 || !defined?($game_player) || !$game_player
changed = false
player = $game_player
begin
roster = player.slot_RosterArray
if roster.is_a?(Array)
roster.each do |row|
next unless row.is_a?(Array)
row.each_index do |index|
if row[index].to_i == id
row[index] = nil
changed = true
end
end
end
end
rescue
end
if changed
begin
player.update_SkillRoster if player.respond_to?(:update_SkillRoster)
rescue
end
begin
player.actor.skill_changed = true if player.respond_to?(:actor) && player.actor
rescue
end
end
cancel_animation
changed
rescue
false
end
def self.hud_font_name
begin
return MPVoiceAction.hud_font_name if defined?(MPVoiceAction) && MPVoiceAction.respond_to?(:hud_font_name)
return MPChatAction.hud_font_name if defined?(MPChatAction) && MPChatAction.respond_to?(:hud_font_name)
rescue
end
'VL Gothic'
end
def self.skill_font_size
begin
return MPVoiceAction.skill_font_size if defined?(MPVoiceAction) && MPVoiceAction.respond_to?(:skill_font_size)
rescue
end
16
end
def self.skill_info_font_name
begin
return MPVoiceAction.skill_info_font_name if defined?(MPVoiceAction) && MPVoiceAction.respond_to?(:skill_info_font_name)
rescue
end
hud_font_name
end
def self.skill_info_font_size
begin
return MPVoiceAction.skill_info_font_size if defined?(MPVoiceAction) && MPVoiceAction.respond_to?(:skill_info_font_size)
rescue
end
20
end
end
MPSlaveEscapeAction.ensure_escape_skill
class Game_Player < Game_Character
unless method_defined?(:mp_slave_escape_process_hotkey_input_without_skill)
alias mp_slave_escape_process_hotkey_input_without_skill process_hotkey_input
end
def process_hotkey_input(key, slot)
return if MPSlaveEscapeAction.escape_slot?(slot) && MPSlaveEscapeAction.consume_as_escape_action(key)
return if MPSlaveEscapeAction.animation_busy?
mp_slave_escape_process_hotkey_input_without_skill(key, slot)
end
unless method_defined?(:mp_slave_escape_process_skill_roster_input_without_skill)
alias mp_slave_escape_process_skill_roster_input_without_skill process_skill_roster_input
end
def process_skill_roster_input(key, whichroster=0, which_skill=0)
begin
if !key.nil? && @slot_RosterArray && whichroster < @slot_RosterArray.size
skill_id = @slot_RosterArray[whichroster][which_skill]
return if MPSlaveEscapeAction.escape_slot?(skill_id) && MPSlaveEscapeAction.consume_as_escape_action(key)
end
rescue
end
return if MPSlaveEscapeAction.animation_busy?
mp_slave_escape_process_skill_roster_input_without_skill(key, whichroster, which_skill)
end
unless method_defined?(:mp_slave_escape_process_custom_skill_without_skill)
alias mp_slave_escape_process_custom_skill_without_skill process_custom_skill
end
def process_custom_skill(key, skill_id)
return if MPSlaveEscapeAction.escape_slot?(skill_id) && MPSlaveEscapeAction.consume_as_escape_action(key)
return if MPSlaveEscapeAction.animation_busy?
mp_slave_escape_process_custom_skill_without_skill(key, skill_id)
end
unless method_defined?(:mp_slave_escape_update_without_animation)
alias mp_slave_escape_update_without_animation update
end
def update(*args, &block)
result = mp_slave_escape_update_without_animation(*args, &block)
MPSlaveEscapeAction.update_animation(self)
result
end
unless method_defined?(:mp_slave_escape_movable_without_animation)
alias mp_slave_escape_movable_without_animation movable?
end
def movable?
return false if MPSlaveEscapeAction.animation_busy?
mp_slave_escape_movable_without_animation
end
end
class Map_Hud
unless method_defined?(:mp_slave_escape_draw_hotkey_icon_get_icon_index_without_skill)
alias mp_slave_escape_draw_hotkey_icon_get_icon_index_without_skill draw_hotkey_icon_get_icon_index
end
def draw_hotkey_icon_get_icon_index(original_bitmap, hotkey_sprite, skill_id, sort_index, sym)
raw_slot = nil
begin
raw_slot = mp_voice_action_raw_slot_for_hud(hotkey_sprite, sort_index) if respond_to?(:mp_voice_action_raw_slot_for_hud)
rescue
raw_slot = nil
end
return MPSlaveEscapeAction::KEY_PATH if MPSlaveEscapeAction.escape_slot?(raw_slot) || MPSlaveEscapeAction.escape_slot?(skill_id)
mp_slave_escape_draw_hotkey_icon_get_icon_index_without_skill(original_bitmap, hotkey_sprite, skill_id, sort_index, sym)
end
end
class Menu_SkillAndHotkey < Menu_ContentBase
if method_defined?(:mp_special_skill?) && !method_defined?(:mp_slave_escape_special_skill_without_skill)
alias mp_slave_escape_special_skill_without_skill mp_special_skill?
def mp_special_skill?(skill)
return true if MPSlaveEscapeAction.escape_skill?(skill)
mp_slave_escape_special_skill_without_skill(skill)
end
end
if method_defined?(:mp_special_skill_order) && !method_defined?(:mp_slave_escape_special_skill_order_without_skill)
alias mp_slave_escape_special_skill_order_without_skill mp_special_skill_order
def mp_special_skill_order(skill)
return 2 if MPSlaveEscapeAction.escape_skill?(skill)
mp_slave_escape_special_skill_order_without_skill(skill)
end
end
if method_defined?(:mp_special_skill_label) && !method_defined?(:mp_slave_escape_special_skill_label_without_skill)
alias mp_slave_escape_special_skill_label_without_skill mp_special_skill_label
def mp_special_skill_label(skill)
return MPSlaveEscapeAction::LABEL if MPSlaveEscapeAction.escape_skill?(skill)
mp_slave_escape_special_skill_label_without_skill(skill)
end
end
unless method_defined?(:mp_slave_escape_initialize_without_skill)
alias mp_slave_escape_initialize_without_skill initialize
end
def initialize(*args)
MPSlaveEscapeAction.ensure_escape_skill
mp_slave_escape_initialize_without_skill(*args)
end
def mp_slave_escape_skill_selected?
return false if !@skills || @cursor_real_index.nil?
MPSlaveEscapeAction.escape_skill?(@skills[@cursor_real_index])
rescue
false
end
unless method_defined?(:mp_slave_escape_refresh_skill_icons_without_skill)
alias mp_slave_escape_refresh_skill_icons_without_skill refresh_skill_icons
end
def refresh_skill_icons
MPSlaveEscapeAction.ensure_escape_skill
mp_slave_escape_refresh_skill_icons_without_skill
return unless MPSlaveEscapeAction.available?
return if !@skills || !@buff_icons || !@buff_icons.bitmap
skill = MPSlaveEscapeAction.escape_skill
return if skill.nil?
@skills = @skills.dup
@skills << skill unless @skills.any? { |row| MPSlaveEscapeAction.escape_skill?(row) }
if respond_to?(:mp_special_skill?) && respond_to?(:mp_special_skill_order) && respond_to?(:mp_special_redraw_skill_icons!)
specials = @skills.select { |row| mp_special_skill?(row) }.sort_by { |row| mp_special_skill_order(row) }
regulars = @skills.reject { |row| mp_special_skill?(row) }
@skills = specials + regulars
@cursor_real_index = 0 if @cursor_real_index && @cursor_real_index >= @skills.length
mp_special_redraw_skill_icons!
else
index = @skills.length - 1
old_bitmap = @buff_icons.bitmap
new_bitmap = Bitmap.new(old_bitmap.width, old_bitmap.height + 27)
new_bitmap.blt(0, 0, old_bitmap, old_bitmap.rect)
old_bitmap.dispose rescue nil
@buff_icons.bitmap = new_bitmap
@buff_icons.bitmap.blt(0, index * 27, Cache.normal_bitmap(MPSlaveEscapeAction::KEY_PATH), Rect.new(0, 0, 24, 24))
draw_text_on_canvas(@buff_icons, 26, 27 * index, MPSlaveEscapeAction::LABEL, true)
end
rescue
end
unless method_defined?(:mp_slave_escape_refresh_skill_info_without_skill)
alias mp_slave_escape_refresh_skill_info_without_skill refresh_skill_info
end
def refresh_skill_info
if mp_slave_escape_skill_selected?
@reuqest_refresh_info = false
@reuqest_refresh_info_delay = 0
@buff_info.bitmap.dispose if @buff_info.bitmap
@buff_info.bitmap = Bitmap.new(299, 312)
begin
@buff_info.bitmap.font.name = MPSlaveEscapeAction.skill_info_font_name
rescue
end
@buff_info.bitmap.font.size = MPSlaveEscapeAction.skill_info_font_size
@buff_info.bitmap.font.outline = false
draw_text_on_canvas(@buff_info, 13, 13, MPSlaveEscapeAction::LABEL)
@buff_info.bitmap.font.size = MPSlaveEscapeAction.skill_font_size
owner = MPSlaveEscapeAction.owner_name
desc = "Попытаться скрытно сбежать от #{owner}.\n#{MPSlaveEscapeAction.progress_text}\n\nНазначьте навык в слот A/S/D/F/Q/W/E/R/SP.\nНужно пять секунд оставаться незамеченным.\nЕсли NPC увидит попытку, он нападёт, а побег не засчитается."
draw_text_on_canvas(@buff_info, 13, 33, desc)
return
end
mp_slave_escape_refresh_skill_info_without_skill
end
end
#==============================================================================
# Safe map entry for an active multiplayer slave contract.
#
# A contract can arrive while a new-game intro is still running. The original
# enter_static_tag_map routine checks Captured and always requests "WakeUp".
# Intro/service maps such as Map138 only contain "StartPoint", so the request
# raises before the already-reserved transfer to the work map can complete.
#==============================================================================
if defined?(GIM_ADDON)
module GIM_ADDON
unless instance_methods.include?(:mp_slave_safe_enter_static_tag_map_without_guard)
alias mp_slave_safe_enter_static_tag_map_without_guard enter_static_tag_map
end
def enter_static_tag_map(event_id=nil, fadeout=false)
use_mp_slave_fallback = false
fallback_point = nil
begin
owner_key = $story_stats["SlaveOwner"].to_s
contract_id = $story_stats["MPPlayerSlaveContract"].to_i
mp_slave_active = contract_id > 0 || owner_key.index("MP:") == 0
captured = $story_stats["Captured"].to_i == 1
points = $game_map.list_storypoints
wake_up = points["WakeUp"] if points
if event_id.nil? && mp_slave_active && captured && wake_up.nil?
fallback_point = points["StartPoint"] if points
if fallback_point.nil? && points && points.respond_to?(:values)
fallback_point = points.values.find do |row|
row.is_a?(Array) && row.size >= 2
end
end
use_mp_slave_fallback = true
end
rescue
use_mp_slave_fallback = false
end
unless use_mp_slave_fallback
return mp_slave_safe_enter_static_tag_map_without_guard(event_id, fadeout)
end
begin
if fallback_point && defined?($game_player) && $game_player
$game_player.moveto(fallback_point[0].to_i, fallback_point[1].to_i)
end
rescue
end
old_captured = nil
old_rape_loop = nil
begin
old_captured = $story_stats["Captured"]
old_rape_loop = $story_stats["RapeLoop"]
# Skip only the original WakeUp branch. All normal map-entry cleanup
# still runs in the original routine below.
$story_stats["Captured"] = 0
$story_stats["RapeLoop"] = 0
$story_stats["ReRollHalfEvents"] = 0
mp_slave_safe_enter_static_tag_map_without_guard(nil, fadeout)
ensure
begin
$story_stats["Captured"] = old_captured
$story_stats["RapeLoop"] = old_rape_loop
rescue
end
end
end
end
end
#==============================================================================
# Multiplayer slave patrol on the global map.
#
# Leaving the forced-work location normally places the player on OverMap. The
# original OverMapForceTrans path is not reliable for a multiplayer contract,
# because map-entry cleanup can temporarily change Captured. This watcher
# queues a normal interpreter event instead: guards spot the slave brand and send
# the active slave back to the contract work map.
#==============================================================================
module MPSlavePatrolReturn
EVENT_SCRIPT = "Data/HCGframes/event/MPPlayerSlavePatrolReturn.rb"
ENTRY_DELAY_FRAMES = 24
RETRY_DELAY_FRAMES = 90
RETRY_TIMEOUT_FRAMES = 240
@overmap_id = nil
@armed_at = 0
@scheduled = false
@scheduled_at = 0
def self.frame_count
Graphics.frame_count.to_i
rescue
0
end
def self.active_local_contract?
begin
owner = $story_stats["SlaveOwner"].to_s
contract_id = $story_stats["MPPlayerSlaveContract"].to_i
return true if contract_id > 0 && owner.index("MP:") == 0
rescue
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract)
contract = WebSocket.slave_active_contract("slave")
return contract && contract[:status].to_s == "ACTIVE"
end
rescue
end
false
rescue
false
end
def self.work_key
key = ""
begin
key = $story_stats["MPPlayerSlaveWorkMap"].to_s
rescue
key = ""
end
begin
if key.empty? && defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract)
contract = WebSocket.slave_active_contract("slave")
key = contract[:work_map].to_s if contract
end
rescue
end
begin
forced = $story_stats["OverMapForceTrans"]
key = forced.to_s if key.empty? && forced != 0 && !forced.to_s.empty?
rescue
end
if defined?(WebSocket) && WebSocket.respond_to?(:slave_normalize_work_map)
key = WebSocket.slave_normalize_work_map(key)
elsif key.to_s.empty? || key.to_s == "0"
key = "MinerPrison"
end
key
rescue
"MinerPrison"
end
def self.overmap?
defined?($game_map) && $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
rescue
false
end
def self.transfer_pending?
defined?($game_player) && $game_player && $game_player.respond_to?(:transfer?) && $game_player.transfer?
rescue
false
end
def self.interpreter_busy?
return false unless defined?($game_map) && $game_map
interpreter = $game_map.interpreter rescue nil
interpreter && interpreter.respond_to?(:running?) && interpreter.running?
rescue
false
end
def self.common_event_busy?
defined?($game_temp) && $game_temp && $game_temp.respond_to?(:common_event_reserved?) && $game_temp.common_event_reserved?
rescue
false
end
def self.pending_flag
$story_stats["MPPlayerSlavePatrolPending"].to_i
rescue
0
end
def self.reset
@overmap_id = nil
@armed_at = 0
@scheduled = false
@scheduled_at = 0
rescue
end
def self.queue_event(key)
return false if key.to_s.empty?
begin
$story_stats["MPPlayerSlaveWorkMap"] = key.to_s
$story_stats["MPPlayerSlavePatrolWorkMap"] = key.to_s
$story_stats["MPPlayerSlavePatrolPending"] = 1
rescue
end
if defined?($game_temp) && $game_temp
if $game_temp.respond_to?(:loadRB)
$game_temp.loadRB(EVENT_SCRIPT)
else
$game_temp.load_RB_Frame = EVENT_SCRIPT if $game_temp.respond_to?(:load_RB_Frame=)
$game_temp.reserve_common_event(:Load_RubyScript) if $game_temp.respond_to?(:reserve_common_event)
end
return true
end
false
rescue
false
end
def self.update
# Most slave gameplay happens off the OverMap. Test that cheap condition
# first so contract lookup is not performed every rendered frame in mines,
# houses, taverns, etc.
unless overmap? && active_local_contract?
reset
return
end
now = frame_count
map_id = ($game_map.map_id.to_i rescue 0)
if @overmap_id != map_id
@overmap_id = map_id
@armed_at = now + ENTRY_DELAY_FRAMES
@scheduled = false
@scheduled_at = 0
end
if @scheduled
if !transfer_pending? && pending_flag == 0 && now - @scheduled_at.to_i >= RETRY_TIMEOUT_FRAMES
@scheduled = false
@armed_at = now + RETRY_DELAY_FRAMES
end
return
end
return if now < @armed_at.to_i
return if transfer_pending?
return if interpreter_busy?
return if common_event_busy?
key = work_key
return if key.empty?
if queue_event(key)
@scheduled = true
@scheduled_at = now
end
rescue
end
end
class Scene_Map < Scene_Base
unless method_defined?(:mp_slave_patrol_return_update_without_watch)
alias mp_slave_patrol_return_update_without_watch update
end
def update(*args, &block)
result = mp_slave_patrol_return_update_without_watch(*args, &block)
MPSlavePatrolReturn.update if defined?(MPSlavePatrolReturn)
result
end
end
#==============================================================================
# Multiplayer player-owned slave rules
# * slave brand only (no physical cuffs/collars/chains)
# * one coin to the owner for each player/NPC sex scene
# * save after arrival in the mine and once per in-game day
#==============================================================================
module MPPlayerSlaveBrandOnly
# Brand is already applied immediately on contract state/force-work.
# This is only a safety verifier, so running it twice per second is wasteful.
CHECK_INTERVAL = 300
@last_check_frame = -99999
def self.frame_count
Graphics.frame_count.to_i
rescue
0
end
def self.active?
return false unless defined?(WebSocket) && WebSocket.respond_to?(:mp_player_owned?)
WebSocket.mp_player_owned?
rescue
false
end
def self.update
# Check the frame gate first. Previously active? was evaluated every frame
# for the whole duration of slavery even though the real work ran only on
# the interval.
now = frame_count
return if now - @last_check_frame.to_i < CHECK_INTERVAL
@last_check_frame = now
return unless active?
WebSocket.slave_apply_brand_only(true) if WebSocket.respond_to?(:slave_apply_brand_only)
rescue
end
end
module MPPlayerSlaveNpcSexIncome
def self.local_npc?(character)
return false if character.nil?
return false if defined?($game_player) && character.equal?($game_player)
begin
return false if character.instance_variable_defined?(:@net_player_id)
rescue
end
begin
return false unless character.respond_to?(:npc?) && character.npc?
rescue
return false
end
actor = nil
begin
actor = character.actor if character.respond_to?(:actor)
rescue
actor = nil
end
return false if actor.nil?
begin
return false if actor.respond_to?(:is_object) && actor.is_object
return false if actor.respond_to?(:dead?) && actor.dead?
rescue
end
true
rescue
false
end
def self.active_npc_partner?(player)
begin
list = player.respond_to?(:fuckers) ? player.fuckers : nil
return true if list.is_a?(Array) && list.any? { |row| local_npc?(row) }
rescue
end
begin
receiver = player.respond_to?(:receiver) ? player.receiver : nil
if local_npc?(receiver)
actor = receiver.actor rescue nil
state = actor.action_state rescue nil
group = receiver.respond_to?(:fuckers) ? receiver.fuckers : nil
return true if state == :sex
return true if group.is_a?(Array) && group.include?(player)
end
rescue
end
false
rescue
false
end
def self.sex_active?(player)
begin
actor = player.actor
return true if actor && actor.respond_to?(:action_state) && actor.action_state == :sex
rescue
end
begin
state = player.instance_variable_get(:@sex_state)
return true if state && state.to_i >= 1
rescue
end
false
rescue
false
end
def self.begin_session(player)
player.instance_variable_set(:@mp_slave_npc_income_counted, false)
rescue
end
def self.commit(player)
return false if player.nil?
return false if player.instance_variable_get(:@mp_slave_npc_income_counted)
return false unless sex_active?(player)
return false unless active_npc_partner?(player)
return false unless defined?(WebSocket) && WebSocket.respond_to?(:slave_npc_sex_income)
# Mark before network send so recursive cleanup cannot pay twice.
player.instance_variable_set(:@mp_slave_npc_income_counted, true)
paid = WebSocket.slave_npc_sex_income
player.instance_variable_set(:@mp_slave_npc_income_counted, false) unless paid
paid
rescue
false
end
end
if defined?(Game_Player)
class Game_Player
if method_defined?(:set_chs_sex) && !method_defined?(:mp_slave_income_set_chs_sex_without_hook)
alias mp_slave_income_set_chs_sex_without_hook set_chs_sex
def set_chs_sex(*args, &block)
MPPlayerSlaveNpcSexIncome.begin_session(self) if defined?(MPPlayerSlaveNpcSexIncome)
mp_slave_income_set_chs_sex_without_hook(*args, &block)
end
end
if method_defined?(:set_event_chs_sex) && !method_defined?(:mp_slave_income_set_event_chs_sex_without_hook)
alias mp_slave_income_set_event_chs_sex_without_hook set_event_chs_sex
def set_event_chs_sex(*args, &block)
MPPlayerSlaveNpcSexIncome.begin_session(self) if defined?(MPPlayerSlaveNpcSexIncome)
mp_slave_income_set_event_chs_sex_without_hook(*args, &block)
end
end
if method_defined?(:unset_chs_sex) && !method_defined?(:mp_slave_income_unset_chs_sex_without_hook)
alias mp_slave_income_unset_chs_sex_without_hook unset_chs_sex
def unset_chs_sex(*args, &block)
MPPlayerSlaveNpcSexIncome.commit(self) if defined?(MPPlayerSlaveNpcSexIncome)
mp_slave_income_unset_chs_sex_without_hook(*args, &block)
end
end
if method_defined?(:unset_event_chs_sex) && !method_defined?(:mp_slave_income_unset_event_chs_sex_without_hook)
alias mp_slave_income_unset_event_chs_sex_without_hook unset_event_chs_sex
def unset_event_chs_sex(*args, &block)
MPPlayerSlaveNpcSexIncome.commit(self) if defined?(MPPlayerSlaveNpcSexIncome)
mp_slave_income_unset_event_chs_sex_without_hook(*args, &block)
end
end
end
end
module MPPlayerSlavePersistence
# One check per second is enough for map-arrival/daily autosave detection.
CHECK_INTERVAL = 60
STORY_LAST_DAY = "MPPlayerSlaveLastSavedDay"
@last_check_frame = -99999
@last_map_id = nil
@last_save_request_frame = -99999
def self.frame_count
Graphics.frame_count.to_i
rescue
0
end
def self.active?
return false unless defined?(WebSocket) && WebSocket.respond_to?(:mp_player_owned?)
WebSocket.mp_player_owned?
rescue
false
end
def self.current_day_index
units = nil
begin
units = WebSocket.get_current_game_date_units if defined?(WebSocket) && WebSocket.respond_to?(:get_current_game_date_units)
rescue
units = nil
end
begin
units = $game_date.dateAmt if units.nil? && defined?($game_date) && $game_date && $game_date.respond_to?(:dateAmt)
rescue
units = nil
end
return nil if units.nil?
value = units.to_i
value = 1 if value < 1
(value - 1) / 2
rescue
nil
end
def self.current_map_id
return 0 unless defined?($game_map) && $game_map
$game_map.map_id.to_i
rescue
0
end
def self.in_work_map?
return false unless defined?(WebSocket) && WebSocket.respond_to?(:slave_in_work_map?)
key = ""
begin
key = $story_stats["MPPlayerSlaveWorkMap"].to_s
rescue
key = ""
end
WebSocket.slave_in_work_map?(key)
rescue
false
end
def self.request_save(reason)
now = frame_count
return false if now - @last_save_request_frame.to_i < 30
requested = false
begin
if defined?(MP_Save14) && MP_Save14.respond_to?(:request)
requested = !!MP_Save14.request(reason, 0, true)
elsif defined?(MP_ServerSyncSave) && MP_ServerSyncSave.respond_to?(:request_selected_slot_save)
requested = !!MP_ServerSyncSave.request_selected_slot_save(reason)
elsif defined?(MP_AutoSave) && MP_AutoSave.respond_to?(:request_save)
requested = !!MP_AutoSave.request_save(reason)
end
rescue
requested = false
end
if requested
@last_save_request_frame = now
begin
$story_stats["MPPlayerSlaveLastSaveReason"] = reason.to_s
rescue
end
end
requested
rescue
false
end
def self.update
now = frame_count
return if now - @last_check_frame.to_i < CHECK_INTERVAL
@last_check_frame = now
map_id = current_map_id
unless active?
@last_map_id = map_id
return
end
# A completed transfer into the mine is saved only after the destination
# map has actually loaded, so the save contains the mine coordinates.
if @last_map_id != map_id
request_save("mp_slave_enter_work_map") if map_id > 0 && in_work_map?
@last_map_id = map_id
elsif @last_map_id.nil?
@last_map_id = map_id
request_save("mp_slave_enter_work_map") if map_id > 0 && in_work_map?
end
day = current_day_index
return if day.nil?
last_day = nil
begin
raw = $story_stats[STORY_LAST_DAY]
last_day = raw.nil? ? nil : raw.to_i
rescue
last_day = nil
end
if last_day.nil? || last_day < 0
begin
$story_stats[STORY_LAST_DAY] = day
rescue
end
elsif day > last_day
begin
$story_stats[STORY_LAST_DAY] = day
rescue
end
request_save("mp_slave_daily_autosave")
elsif day < last_day
# Server time can be corrected backwards after reconnect. Reset the
# marker without creating an autosave loop.
begin
$story_stats[STORY_LAST_DAY] = day
rescue
end
end
rescue
end
end
if defined?(Scene_Map)
class Scene_Map
unless method_defined?(:mp_slave_rules_update_without_hooks)
alias mp_slave_rules_update_without_hooks update
end
def update(*args, &block)
result = mp_slave_rules_update_without_hooks(*args, &block)
MPPlayerSlaveBrandOnly.update if defined?(MPPlayerSlaveBrandOnly)
MPPlayerSlavePersistence.update if defined?(MPPlayerSlavePersistence)
result
end
end
end