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

803 lines
22 KiB
Ruby

# encoding: UTF-8
return unless defined?(WebSocket)
module WebSocket
DANCE_MENU_TEXT = "Танец" unless const_defined?(:DANCE_MENU_TEXT)
DANCE_ACCEPT_TEXT = "Принять" unless const_defined?(:DANCE_ACCEPT_TEXT)
DANCE_DECLINE_TEXT = "Отказаться" unless const_defined?(:DANCE_DECLINE_TEXT)
DANCE_DEFAULT_DURATION_MS = 12_000 unless const_defined?(:DANCE_DEFAULT_DURATION_MS)
@dance_pending_offer ||= nil
@dance_local_session ||= nil
@dance_remote_roles ||= {}
class << self
begin
alias_method :mp_dance_parse_without_layer, :parse unless method_defined?(:mp_dance_parse_without_layer)
rescue
end
begin
alias_method :mp_dance_update_without_layer, :update unless method_defined?(:mp_dance_update_without_layer)
rescue
end
begin
alias_method :mp_dance_check_attack_without_layer, :check_attack if method_defined?(:check_attack) && !method_defined?(:mp_dance_check_attack_without_layer)
rescue
end
begin
alias_method :mp_dance_check_interaction_without_layer, :check_interaction if method_defined?(:check_interaction) && !method_defined?(:mp_dance_check_interaction_without_layer)
rescue
end
begin
alias_method :mp_dance_check_pickup_without_layer, :check_pickup_or_interaction if method_defined?(:check_pickup_or_interaction) && !method_defined?(:mp_dance_check_pickup_without_layer)
rescue
end
begin
alias_method :mp_dance_player_menu_actions_without_layer, :player_menu_actions if method_defined?(:player_menu_actions) && !method_defined?(:mp_dance_player_menu_actions_without_layer)
rescue
end
end
def self.dance_unesc(text)
s = text.to_s
begin
return unesc(s) if respond_to?(:unesc)
rescue
end
s
end
def self.dance_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 !error && 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_DANCE] #{msg}")
end
end
def self.dance_now_ms
(Time.now.to_f * 1000.0).to_i
rescue
0
end
def self.dance_player_name(player_id)
pid = player_id.to_i
begin
name = nickname_for(pid).to_s if respond_to?(:nickname_for)
return name unless name.nil? || name.strip.empty?
rescue
end
"Игрок ##{pid}"
rescue
"Игрок"
end
def self.dance_request(target_id)
return false unless @connected
tid = target_id.to_i
return false if tid <= 0
return false if @my_id && tid == @my_id.to_i
send_line("dance_req:#{tid}")
true
rescue
false
end
def self.dance_accept(offer_id=nil)
offer = @dance_pending_offer
id = offer_id ? offer_id.to_i : (offer ? offer[:id].to_i : 0)
return false if id <= 0
send_line("dance_accept:#{id}") if @connected
@dance_pending_offer = nil if offer && offer[:id].to_i == id
true
rescue
false
end
def self.dance_decline(offer_id=nil)
offer = @dance_pending_offer
id = offer_id ? offer_id.to_i : (offer ? offer[:id].to_i : 0)
return false if id <= 0
send_line("dance_decline:#{id}") if @connected
@dance_pending_offer = nil if offer && offer[:id].to_i == id
true
rescue
false
end
def self.dance_pending_offer
offer = @dance_pending_offer
return nil unless offer.is_a?(Hash)
if offer[:expires_at].to_i > 0 && dance_now_ms > offer[:expires_at].to_i
@dance_pending_offer = nil
return nil
end
offer
rescue
nil
end
def self.dance_local_active?
@dance_local_session.is_a?(Hash)
rescue
false
end
def self.dance_notice_text(code, text="")
name = dance_unesc(text)
case code.to_s
when "offer_sent"
"Приглашение на танец отправлено."
when "started", "accepted"
"Танец начался."
when "auto_stamina"
"Танец начался автоматически: цель слишком устала."
when "auto_slave"
"Танец начался автоматически: цель находится в рабском контракте."
when "declined"
"Игрок отказался от танца."
when "cancelled"
"Танец завершён."
when "map_changed"
"Танец завершён: игрок сменил карту."
when "left"
"Танец завершён: игрок вышел."
when "combat"
"Танец завершён: начался бой."
when "target_not_online"
"Игрок уже не в сети."
when "not_same_map"
"Нужно стоять на одной карте."
when "too_far"
"Игрок слишком далеко."
when "busy"
"Один из игроков уже занят."
when "bad_target"
"Неверная цель."
when "offer_expired"
"Приглашение на танец устарело."
when "server_error"
"Ошибка танца: #{name}"
when "only_lead_can_cancel"
"Танец может завершить только ведущий."
else
name.empty? ? "Танец: #{code}" : "Танец: #{name}"
end
rescue
"Танец."
end
def self.dance_role_for(player_id, initiator_id, target_id)
pid = player_id.to_i
return :lead if pid == initiator_id.to_i
return :crawl if pid == target_id.to_i
nil
rescue
nil
end
def self.dance_character_for(player_id)
pid = player_id.to_i
return nil if pid <= 0
return $game_player if @my_id && pid == @my_id.to_i
begin
create_remote_player(pid) unless @players && @players[pid]
rescue
end
@players && @players[pid]
rescue
nil
end
def self.dance_away_direction(lead_ch, crawl_ch)
return nil if lead_ch.nil? || crawl_ch.nil?
lx = lead_ch.x.to_i
ly = lead_ch.y.to_i
cx = crawl_ch.x.to_i
cy = crawl_ch.y.to_i
dx = cx - lx
dy = cy - ly
if dx.abs >= dy.abs && dx != 0
dx > 0 ? 6 : 4
elsif dy != 0
dy > 0 ? 2 : 8
else
lead_ch.respond_to?(:direction) ? lead_ch.direction.to_i : nil
end
rescue
nil
end
def self.dance_set_direction(ch, dir)
d = dir.to_i
return unless d == 2 || d == 4 || d == 6 || d == 8
begin
ch.set_direction(d) if ch.respond_to?(:set_direction)
rescue
end
begin
ch.direction = d if ch.respond_to?(:direction=)
rescue
end
begin
ch.instance_variable_set(:@direction, d)
rescue
end
rescue
end
def self.dance_face_crawler_away(initiator_id, target_id)
lead = dance_character_for(initiator_id)
crawl = dance_character_for(target_id)
dir = dance_away_direction(lead, crawl)
dance_set_direction(crawl, dir) if dir
rescue
end
def self.dance_apply_local_role(session_id, role, ends_at_ms, initiator_id=nil, target_id=nil)
ch = $game_player
return if ch.nil?
prev = {}
begin
prev[:movement] = ch.movement if ch.respond_to?(:movement)
rescue
end
begin
prev[:opacity] = ch.opacity if ch.respond_to?(:opacity)
rescue
end
begin
prev[:direction] = ch.direction if ch.respond_to?(:direction)
rescue
end
@dance_local_session = {
:id => session_id.to_i,
:role => role,
:from_id => initiator_id.to_i,
:target_id => target_id.to_i,
:map_id => ($game_map ? $game_map.map_id.to_i : 0),
:ends_at => ends_at_ms.to_i,
:prev => prev
}
dance_reapply_local_role
rescue
end
def self.dance_reapply_local_role
sess = @dance_local_session
return unless sess.is_a?(Hash)
ch = $game_player
return if ch.nil?
case sess[:role]
when :lead
begin
if ch.respond_to?(:setup_fap_effect)
ch.setup_fap_effect if ch.animation.nil?
elsif ch.respond_to?(:animation_masturbation)
ch.animation = ch.animation_masturbation if ch.animation.nil?
end
rescue
end
when :crawl
begin
ch.movement = :crawl if ch.respond_to?(:movement=)
ch.move_crawl if ch.respond_to?(:move_crawl)
dance_face_crawler_away(sess[:from_id], sess[:target_id])
ch.instance_variable_set(:@stop_count, 0)
@last_pos = nil
rescue
end
end
rescue
end
def self.dance_restore_local(send_cancel=false, reason="cancel")
sess = @dance_local_session
return unless sess.is_a?(Hash)
@dance_local_session = nil
begin
send_line("dance_cancel:#{sess[:id].to_i}") if send_cancel && @connected && sess[:id].to_i > 0
rescue
end
ch = $game_player
return if ch.nil?
prev = sess[:prev].is_a?(Hash) ? sess[:prev] : {}
begin
ch.animation = nil
rescue
end
begin
ch.balloon_id = 0 if ch.respond_to?(:balloon_id=)
rescue
end
begin
if prev.has_key?(:movement) && ch.respond_to?(:movement=)
ch.movement = prev[:movement]
elsif ch.respond_to?(:move_normal)
ch.move_normal
end
rescue
end
begin
ch.opacity = prev[:opacity].to_i if prev.has_key?(:opacity) && ch.respond_to?(:opacity=)
rescue
end
begin
dance_set_direction(ch, prev[:direction]) if prev.has_key?(:direction)
rescue
end
@last_pos = nil
rescue
end
def self.dance_apply_remote_role(session_id, player_id, role, initiator_id=nil, target_id=nil, ends_at_ms=nil)
pid = player_id.to_i
return if pid <= 0
return if @my_id && pid == @my_id.to_i
ch = dance_character_for(pid)
return if ch.nil?
@dance_remote_roles ||= {}
st = @dance_remote_roles[pid]
unless st.is_a?(Hash) && st[:id].to_i == session_id.to_i
st = {
:id => session_id.to_i,
:role => role,
:from_id => initiator_id.to_i,
:target_id => target_id.to_i,
:ends_at => ends_at_ms.to_i,
:prev => {}
}
begin
st[:prev][:movement] = ch.instance_variable_get(:@net_movement)
rescue
end
begin
st[:prev][:opacity] = ch.opacity if ch.respond_to?(:opacity)
rescue
end
begin
st[:prev][:direction] = ch.direction if ch.respond_to?(:direction)
rescue
end
@dance_remote_roles[pid] = st
else
st[:from_id] = initiator_id.to_i if initiator_id
st[:target_id] = target_id.to_i if target_id
st[:ends_at] = ends_at_ms.to_i if ends_at_ms
end
case role
when :lead
begin
if ch.respond_to?(:animation_masturbation)
ch.animation = ch.animation_masturbation
elsif ch.respond_to?(:setup_fap_effect)
ch.setup_fap_effect
end
rescue
end
when :crawl
begin
if respond_to?(:mp_anim_apply_remote_movement_visual)
mp_anim_apply_remote_movement_visual(ch, "crawl_overfatigue")
else
ch.instance_variable_set(:@net_movement, "crawl_overfatigue")
ch.opacity = 125 if ch.respond_to?(:opacity=)
end
dance_face_crawler_away(st[:from_id], st[:target_id])
ch.instance_variable_set(:@stop_count, 0)
rescue
end
end
rescue
end
def self.dance_restore_remote_role(player_id)
pid = player_id.to_i
return if pid <= 0
@dance_remote_roles ||= {}
st = @dance_remote_roles.delete(pid)
return unless st.is_a?(Hash)
ch = dance_character_for(pid)
return if ch.nil?
prev = st[:prev].is_a?(Hash) ? st[:prev] : {}
begin
ch.animation = nil
rescue
end
begin
if prev.has_key?(:movement)
ch.instance_variable_set(:@net_movement, prev[:movement])
else
ch.instance_variable_set(:@net_movement, nil)
end
rescue
end
begin
ch.opacity = prev[:opacity].to_i if prev.has_key?(:opacity) && ch.respond_to?(:opacity=)
rescue
end
begin
dance_set_direction(ch, prev[:direction]) if prev.has_key?(:direction)
rescue
end
rescue
end
def self.dance_reapply_remote_roles
@dance_remote_roles ||= {}
now = dance_now_ms
@dance_remote_roles.keys.each do |pid|
st = @dance_remote_roles[pid]
next unless st.is_a?(Hash)
if st[:ends_at].to_i > 0 && now >= st[:ends_at].to_i
dance_restore_remote_role(pid)
next
end
ch = dance_character_for(pid)
next if ch.nil?
case st[:role]
when :lead
begin
if ch.respond_to?(:animation_masturbation)
ch.animation = ch.animation_masturbation if ch.animation.nil?
elsif ch.respond_to?(:setup_fap_effect)
ch.setup_fap_effect if ch.animation.nil?
end
rescue
end
when :crawl
begin
if respond_to?(:mp_anim_apply_remote_movement_visual)
mp_anim_apply_remote_movement_visual(ch, "crawl_overfatigue")
else
ch.instance_variable_set(:@net_movement, "crawl_overfatigue")
ch.opacity = 125 if ch.respond_to?(:opacity=)
end
dance_face_crawler_away(st[:from_id], st[:target_id])
ch.instance_variable_set(:@stop_count, 0)
rescue
end
end
end
rescue
end
def self.dance_start_session(session_id, initiator_id, target_id, ends_at_ms, mode)
sid = session_id.to_i
from = initiator_id.to_i
target = target_id.to_i
ends = ends_at_ms.to_i
ends = dance_now_ms + DANCE_DEFAULT_DURATION_MS if ends <= 0
[from, target].each do |pid|
role = dance_role_for(pid, from, target)
next if role.nil?
if @my_id && pid == @my_id.to_i
dance_apply_local_role(sid, role, ends, from, target)
else
dance_apply_remote_role(sid, pid, role, from, target, ends)
end
end
case mode.to_s
when "auto_stamina"
dance_notify(dance_notice_text("auto_stamina"))
when "auto_slave"
dance_notify(dance_notice_text("auto_slave"))
else
dance_notify(dance_notice_text("started"))
end
rescue
end
def self.dance_end_session(session_id, reason="")
sid = session_id.to_i
changed = false
if @dance_local_session.is_a?(Hash) && @dance_local_session[:id].to_i == sid
dance_restore_local(false, reason)
changed = true
end
begin
@dance_remote_roles ||= {}
@dance_remote_roles.keys.each do |pid|
st = @dance_remote_roles[pid]
if st.is_a?(Hash) && st[:id].to_i == sid
dance_restore_remote_role(pid)
changed = true
end
end
rescue
end
dance_notify(dance_notice_text(reason)) if changed && reason.to_s != "timeout"
rescue
end
def self.dance_update
begin
offer = @dance_pending_offer
if offer.is_a?(Hash) && offer[:expires_at].to_i > 0 && dance_now_ms > offer[:expires_at].to_i
@dance_pending_offer = nil
end
rescue
end
dance_reapply_remote_roles
sess = @dance_local_session
return unless sess.is_a?(Hash)
begin
if $game_map && sess[:map_id].to_i > 0 && $game_map.map_id.to_i != sess[:map_id].to_i
dance_restore_local(true, "map_changed")
return
end
rescue
end
begin
if sess[:ends_at].to_i > 0 && dance_now_ms >= sess[:ends_at].to_i
dance_restore_local(false, "timeout")
return
end
rescue
end
begin
if Input.trigger?(:B)
if sess[:role] == :lead
dance_restore_local(true, "cancel")
else
dance_notify("Танец может завершить только ведущий.", true)
end
return
end
rescue
end
dance_reapply_local_role
rescue
end
def self.player_menu_actions(target_id)
actions = if respond_to?(:mp_dance_player_menu_actions_without_layer)
mp_dance_player_menu_actions_without_layer(target_id)
else
[]
end
actions = [] unless actions.is_a?(Array)
actions << [DANCE_MENU_TEXT, :dance]
actions
rescue
[[DANCE_MENU_TEXT, :dance]]
end
def self.parse(msg)
line = msg.to_s
if line.start_with?("dance_offer:")
parts = line.split(":", 5)
if parts.size >= 5
@dance_pending_offer = {
:id => parts[1].to_i,
:from_id => parts[2].to_i,
:from_nick => dance_unesc(parts[3]),
:expires_at => parts[4].to_i
}
dance_notify("Игрок #{@dance_pending_offer[:from_nick]} приглашает вас на танец.")
end
return
end
if line.start_with?("dance_start:")
parts = line.split(":", 6)
dance_start_session(parts[1].to_i, parts[2].to_i, parts[3].to_i, parts[4].to_i, dance_unesc(parts[5].to_s)) if parts.size >= 6
return
end
if line.start_with?("dance_end:")
parts = line.split(":", 3)
dance_end_session(parts[1].to_i, dance_unesc(parts[2].to_s)) if parts.size >= 2
return
end
if line.start_with?("dance_ok:")
code = dance_unesc(line.split(":", 2)[1].to_s)
dance_notify(dance_notice_text(code))
return
end
if line.start_with?("dance_error:")
code = dance_unesc(line.split(":", 2)[1].to_s)
dance_notify(dance_notice_text(code), true)
return
end
if line.start_with?("dance_notice:")
parts = line.split(":", 3)
code = dance_unesc(parts[1].to_s)
text = dance_unesc(parts[2].to_s)
dance_notify(dance_notice_text(code, text))
return
end
mp_dance_parse_without_layer(msg)
end
def self.update
mp_dance_update_without_layer if respond_to?(:mp_dance_update_without_layer)
dance_update
end
def self.check_attack
return if dance_local_active?
mp_dance_check_attack_without_layer if respond_to?(:mp_dance_check_attack_without_layer)
end
def self.check_interaction
return if dance_local_active?
mp_dance_check_interaction_without_layer if respond_to?(:mp_dance_check_interaction_without_layer)
end
def self.check_pickup_or_interaction
return if dance_local_active?
mp_dance_check_pickup_without_layer if respond_to?(:mp_dance_check_pickup_without_layer)
end
end
class Window_MPDanceOffer < Window_Command
def initialize(offer)
@mp_dance_offer = offer
super((Graphics.width - window_width) / 2, (Graphics.height - window_height) / 2)
self.z = 10_000
self.openness = 255
self.back_opacity = 220
activate
select(0)
end
def window_width
[320, Graphics.width - 40].min
end
def visible_line_number
2
end
def alignment
1
end
def make_command_list
add_command(WebSocket::DANCE_ACCEPT_TEXT, :accept)
add_command(WebSocket::DANCE_DECLINE_TEXT, :decline)
end
def draw_item(index)
selected = (index == self.index)
change_color(selected ? system_color : normal_color, command_enabled?(index))
begin
contents.font.name = MPSafeFont.name if defined?(MPSafeFont)
rescue
end
contents.font.size = 20
contents.font.bold = false
contents.font.outline = false
contents.font.shadow = true
text = selected ? "> #{command_name(index)}" : command_name(index)
draw_text(item_rect_for_text(index), text, alignment)
end
end
class Scene_Map < Scene_Base
unless method_defined?(:mp_dance_scene_update_without_layer)
alias mp_dance_scene_update_without_layer update
end
def update(*args, &block)
mp_dance_scene_update_without_layer(*args, &block)
mp_dance_update_offer_window
end
unless method_defined?(:mp_dance_scene_terminate_without_layer)
alias mp_dance_scene_terminate_without_layer terminate
end
def terminate(*args, &block)
mp_dance_dispose_offer_window
mp_dance_scene_terminate_without_layer(*args, &block)
end
unless method_defined?(:mp_dance_open_player_menu_without_layer)
begin
alias_method :mp_dance_open_player_menu_without_layer, :mp_open_player_menu if method_defined?(:mp_open_player_menu)
rescue
end
end
def mp_open_player_menu(target_id)
mp_dance_open_player_menu_without_layer(target_id) if respond_to?(:mp_dance_open_player_menu_without_layer)
begin
@mp_player_menu_window.set_handler(:dance, method(:mp_player_menu_dance)) if @mp_player_menu_window
rescue
end
end
def mp_player_menu_dance
tid = @mp_player_menu_target_id.to_i
mp_close_player_menu if respond_to?(:mp_close_player_menu)
begin
WebSocket.dance_request(tid) if defined?(WebSocket) && WebSocket.respond_to?(:dance_request)
rescue => e
puts "[DANCE] request failed: #{e.class}: #{e.message}"
end
end
def mp_dance_update_offer_window
return unless defined?(WebSocket)
offer = WebSocket.dance_pending_offer if WebSocket.respond_to?(:dance_pending_offer)
if offer.nil?
mp_dance_dispose_offer_window
return
end
if @mp_dance_offer_window.nil? || @mp_dance_offer_id.to_i != offer[:id].to_i
mp_dance_dispose_offer_window
@mp_dance_offer_id = offer[:id].to_i
@mp_dance_offer_window = Window_MPDanceOffer.new(offer)
@mp_dance_offer_window.set_handler(:accept, method(:mp_dance_accept_offer))
@mp_dance_offer_window.set_handler(:decline, method(:mp_dance_decline_offer))
@mp_dance_offer_window.set_handler(:cancel, method(:mp_dance_decline_offer))
end
rescue => e
puts "[DANCE] offer window failed: #{e.class}: #{e.message}"
mp_dance_dispose_offer_window
end
def mp_dance_dispose_offer_window
begin
@mp_dance_offer_window.dispose if @mp_dance_offer_window
rescue
end
@mp_dance_offer_window = nil
@mp_dance_offer_id = nil
end
def mp_dance_accept_offer
id = @mp_dance_offer_id.to_i
mp_dance_dispose_offer_window
WebSocket.dance_accept(id) if defined?(WebSocket) && WebSocket.respond_to?(:dance_accept)
rescue
end
def mp_dance_decline_offer
id = @mp_dance_offer_id.to_i
mp_dance_dispose_offer_window
WebSocket.dance_decline(id) if defined?(WebSocket) && WebSocket.respond_to?(:dance_decline)
rescue
end
end
class Game_Player < Game_Character
unless method_defined?(:mp_dance_movable_without_layer)
alias mp_dance_movable_without_layer movable?
end
def movable?
begin
return false if defined?(WebSocket) && WebSocket.respond_to?(:dance_local_active?) && WebSocket.dance_local_active?
rescue
end
mp_dance_movable_without_layer
end
end