# 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