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

3184 lines
107 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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