3184 lines
107 KiB
Ruby
3184 lines
107 KiB
Ruby
# 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
|