# encoding: UTF-8 module WebSocket @admin_role_name ||= "PLAYER" @admin_role_received ||= false @admin_noclip_enabled ||= false @admin_frozen_by_owner ||= false @admin_frozen_targets ||= {} @admin_see_hidden_enabled ||= false @admin_ghost_enabled ||= false # MODERATOR+; reset on disconnect and role loss # Mega strength is ephemeral, only available for authenticated OWNER. @admin_mega_strength_enabled ||= false @admin_speed_multiplier ||= 1.0 @admin_teleport_to_pending_id ||= nil @admin_teleport_to_pending_at ||= 0.0 @admin_teleport_to_state ||= nil # Prepared OWNER ability. Never serialized: reset on disconnect/role loss. @admin_skill_name ||= nil @admin_skill_target_id ||= nil @admin_skill_target_label ||= nil @admin_skill_last_cast_at ||= 0.0 def self.admin_role_name @admin_role_name ||= "PLAYER" rescue "PLAYER" end def self.admin_role_received? @admin_role_received ? true : false rescue false end def self.admin_mark_role_received(value=true) @admin_role_received = value ? true : false rescue @admin_role_received = false end def self.admin_set_role(role_name) role = role_name.to_s.strip.upcase role = "MODERATOR" if role == "MODERATOT" role = "PLAYER" unless ["PLAYER", "VIP", "MODERATOR", "OWNER"].include?(role) old_role = @admin_role_name.to_s @admin_role_name = role @admin_noclip_enabled = false unless role == "OWNER" if role != "MODERATOR" && role != "OWNER" @admin_ghost_enabled = false @ninja_local_last_active = nil # announce removal through normal stealth sync end @admin_mega_strength_enabled = false unless role == "OWNER" @admin_speed_multiplier = 1.0 unless role == "OWNER" MPMeasurements.clear if role != "OWNER" && defined?(MPMeasurements) if role != "OWNER" @admin_teleport_to_pending_id = nil @admin_teleport_to_pending_at = 0.0 @admin_teleport_to_state = nil admin_owner_skill_clear end # OWNER sees players in stealth by default; the menu can toggle it. if role != "OWNER" @admin_see_hidden_enabled = false elsif old_role != "OWNER" @admin_see_hidden_enabled = true end rescue @admin_role_name = "PLAYER" end # Never enable OWNER-only behaviour based on an offline or stale role. def self.admin_owner_active? connected? && admin_role_received? && admin_role_name == "OWNER" rescue false end def self.admin_see_hidden_enabled? admin_owner_active? && !!@admin_see_hidden_enabled rescue false end def self.admin_mega_strength_enabled? admin_owner_active? && !!@admin_mega_strength_enabled rescue false end def self.admin_toggle_mega_strength return false unless admin_owner_active? @admin_mega_strength_enabled = !@admin_mega_strength_enabled admin_owner_tools_notice(@admin_mega_strength_enabled ? "Мега-сила ВКЛ: удар по здоровью наносит 1 000 000 урона." : "Мега-сила ВЫКЛ: обычный урон восстановлен.") true rescue false end # CLIENT-ONLY movement animation speed; server still validates positions. # Keep this ephemeral and role-checked, never write into save data. SPEED_STEPS = [1.0, 1.5, 2.0, 3.0].freeze def self.admin_speed_multiplier admin_owner_active? ? (@admin_speed_multiplier || 1.0).to_f : 1.0 rescue 1.0 end def self.admin_cycle_speed return false unless admin_owner_active? current = admin_speed_multiplier index = SPEED_STEPS.index(current) || 0 @admin_speed_multiplier = SPEED_STEPS[(index + 1) % SPEED_STEPS.size] admin_owner_tools_notice("Скорость движения: x#{@admin_speed_multiplier}.") true rescue false end def self.admin_toggle_see_hidden return unless admin_owner_active? @admin_see_hidden_enabled = !@admin_see_hidden_enabled admin_owner_tools_notice(@admin_see_hidden_enabled ? "Видеть скрытых: ВКЛ." : "Видеть скрытых: ВЫКЛ.") rescue end def self.admin_role_rank case admin_role_name when "VIP" then 1 when "MODERATOR" then 2 when "OWNER" then 3 else 0 end rescue 0 end def self.admin_can_style? admin_role_received? && connected? && admin_role_rank >= 1 end def self.admin_can_kick? admin_role_received? && connected? && admin_role_rank >= 2 end def self.admin_can_ghost? admin_role_received? && connected? && admin_role_rank >= 2 rescue false end def self.admin_ghost_active? admin_can_ghost? && !!@admin_ghost_enabled rescue false end def self.admin_toggle_ghost return false unless admin_can_ghost? @admin_ghost_enabled = !@admin_ghost_enabled # Force a new packet even if the player was already sneaking/stealthed. @ninja_local_last_active = nil @ninja_local_last_ghost = nil @ninja_local_last_sent_at = 0.0 _ninja_tick_local if respond_to?(:_ninja_tick_local) admin_owner_tools_notice(@admin_ghost_enabled ? "Призрак ВКЛ: другие обновлённые клиенты не видят вас." : "Призрак ВЫКЛ: вы снова видны другим игрокам.") true rescue false end def self.admin_can_ban? admin_role_received? && connected? && admin_role_rank >= 3 end def self.admin_emoji_entries if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:available_entries) return MPNickEmoji.available_entries end [ ["Пусто", ""], ["⭐", "⭐"], ["🔥", "🔥"], ["💀", "💀"], ["👑", "👑"], ["💎", "💎"], ["❤", "❤"], ["☠", "☠"], ["🌙", "🌙"], ["☀", "☀"], ["😈", "😈"], ["😇", "😇"], ["⚔", "⚔"], ["🛡", "🛡"], ] rescue [["Пусто", ""]] end def self.admin_style_entries cfg = {} begin cfg = MPNickStyle.load_config if defined?(MPNickStyle) rescue cfg = {} end styles = (cfg.is_a?(Hash) ? cfg["styles"] : nil) styles = {} unless styles.is_a?(Hash) out = [] styles.keys.map { |k| k.to_i }.sort.each do |sid| style = styles[sid.to_s] next unless style.is_a?(Hash) name = style["name"].to_s.strip name = "Style #{sid}" if name == "" out << [sid, name] end out = [[0, "Classic"], [1, "Rainbow JS"], [2, "Musik"], [3, "BLOOD"], [4, "CONCHA"], [5, "NEON"]] if out.empty? out rescue [[0, "Classic"], [1, "Rainbow JS"], [2, "Musik"], [3, "BLOOD"], [4, "CONCHA"], [5, "NEON"]] end def self.admin_online_targets cur_map = 0 begin cur_map = $game_map.map_id if $game_map rescue cur_map = 0 end entries = [] begin total, list = mp_tab_entries(cur_map) entries = list if list.is_a?(Array) rescue entries = [] end out = [] entries.each do |row| next unless row.is_a?(Array) && row.size >= 4 pid = row[0].to_i next if pid <= 0 next if !@my_id.nil? && pid == @my_id.to_i nick = row[1].to_s.strip nick = "Player #{pid}" if nick == "" map_id = row[2].to_i same_map = !!row[3] label = nick.dup label += " [#{map_id}]" if map_id > 0 && !same_map out << [pid, label] end out rescue [] end def self.admin_request_targets_refresh mp_tab_request_who if respond_to?(:mp_tab_request_who) rescue end def self.admin_change_style(style_id) return unless connected? return unless admin_can_style? send_line("admin_style:#{style_id.to_i}") rescue end def self.admin_change_emoji(side_name, emoji_value) return unless connected? return unless admin_can_style? side = side_name.to_s.strip.downcase return unless side == "front" || side == "back" send_line("admin_emoji:#{side}:#{esc(emoji_value.to_s)}") rescue end def self.admin_kick_player(target_id) return unless connected? return unless admin_can_kick? tid = target_id.to_i return if tid <= 0 send_line("admin_kick:#{tid}") rescue end def self.admin_ban_player(target_id) return unless connected? return unless admin_can_ban? tid = target_id.to_i return if tid <= 0 send_line("admin_ban:#{tid}") rescue end def self.admin_ban_ip_player(target_id) return unless connected? return unless admin_can_ban? tid = target_id.to_i return if tid <= 0 send_line("admin_banip:#{tid}") rescue end def self.admin_noclip_enabled? @admin_noclip_enabled ? true : false rescue false end def self.admin_frozen_by_owner? @admin_frozen_by_owner ? true : false rescue false end def self.admin_target_frozen?(target_id) @admin_frozen_targets ||= {} tid = target_id.is_a?(Integer) ? target_id : target_id.to_i !!@admin_frozen_targets[tid] end def self.admin_toggle_noclip return unless connected? return unless admin_role_rank >= 3 send_line("owner_noclip_toggle") rescue end def self.admin_teleport_player_here(target_id) return unless admin_owner_active? tid = target_id.to_i return if tid <= 0 || tid == my_id.to_i return unless defined?($game_map) && $game_map && defined?($game_player) && $game_player map_id = $game_map.map_id.to_i x = $game_player.x.to_i y = $game_player.y.to_i dir = $game_player.direction.to_i return if map_id <= 0 || x < 0 || y < 0 send_line("owner_teleport_here:#{tid}:#{map_id}:#{x}:#{y}:#{dir}") rescue end # Local warp for a visible player on the same map. No cross-map location # can be inferred from who_list (it contains only map IDs). OWNER_SKILLS = { :teleport_here => "Телепорт: игрок ко мне", :teleport_to => "Телепорт: я к игроку", :freeze => "Заморозить / разморозить", }.freeze def self.admin_owner_skill_entries OWNER_SKILLS.to_a end def self.admin_owner_skill_clear @admin_skill_name = nil @admin_skill_target_id = nil @admin_skill_target_label = nil @admin_skill_last_cast_at = 0.0 end def self.admin_owner_skill_prepared? admin_owner_active? && OWNER_SKILLS.key?(@admin_skill_name) && @admin_skill_target_id.to_i > 0 rescue false end def self.admin_owner_skill_status return "Навык не выбран" unless admin_owner_skill_prepared? "#{OWNER_SKILLS[@admin_skill_name]} — #{@admin_skill_target_label}" rescue "Навык не выбран" end def self.admin_owner_skill_cast_label return "Применить навык [F7]" unless admin_owner_skill_prepared? brief = case @admin_skill_name when :teleport_here then "ТП ко мне" when :teleport_to then "ТП к игроку" when :freeze then "Заморозка" end "[F7] #{brief}: #{@admin_skill_target_label.to_s[0, 18]}" rescue "Применить навык [F7]" end def self.admin_owner_skill_prepare(skill_name, target_id) return false unless admin_owner_active? sym = skill_name.to_sym rescue nil return false unless OWNER_SKILLS.key?(sym) tid = target_id.to_i return false if tid <= 0 || tid == my_id.to_i row = admin_online_targets.find { |pid, label| pid.to_i == tid } unless row admin_owner_tools_notice("Игрок больше не числится онлайн. Обновите список.") return false end @admin_skill_name = sym @admin_skill_target_id = tid # Keep the display label short; player input is never interpolated into a packet. @admin_skill_target_label = row[1].to_s[0, 26] @admin_skill_last_cast_at = 0.0 admin_owner_tools_notice("Навык выбран: #{admin_owner_skill_status}. F7 — применить, либо меню OWNER.") true rescue false end def self.admin_owner_skill_cast return false unless admin_owner_skill_prepared? # Avoid accidental repeated packets from input polling / key repeat. now = Time.now.to_f return false if now - @admin_skill_last_cast_at.to_f < 0.8 tid = @admin_skill_target_id.to_i unless admin_online_targets.any? { |pid, _label| pid.to_i == tid } admin_owner_tools_notice("Цель не в списке онлайн. Выберите игрока заново.") admin_owner_skill_clear return false end return false unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map) @admin_skill_last_cast_at = now case @admin_skill_name when :teleport_here # Existing server packet: only the server may move the remote target. admin_teleport_player_here(tid) admin_owner_tools_notice("Запрос телепорта игрока ##{tid} к вам отправлен.") when :teleport_to admin_teleport_to_player(tid) when :freeze admin_toggle_player_freeze(tid) admin_owner_tools_notice("Запрос изменения заморозки игрока ##{tid} отправлен.") else return false end true rescue admin_owner_tools_notice("Не удалось использовать навык OWNER.") false end # Teleport within an already loaded map. No reload / wrong-map moveto. def self.admin_owner_warp(map_id, x, y, dir=2) return false unless admin_owner_active? return false unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map) return false unless $game_map && $game_player mid, tx, ty = map_id.to_i, x.to_i, y.to_i return false unless mid > 0 && $game_map.map_id.to_i == mid return false unless $game_map.respond_to?(:valid?) && $game_map.valid?(tx, ty) return false if $game_player.respond_to?(:transfer?) && $game_player.transfer? direction = [2, 4, 6, 8].include?(dir.to_i) ? dir.to_i : 2 $game_player.moveto(tx, ty) $game_player.set_direction(direction) if $game_player.respond_to?(:set_direction) @last_pos = "" # publish the new tile to the multiplayer server true rescue false end def self.admin_teleport_to_clear @admin_teleport_to_state = nil @admin_teleport_to_pending_id = nil @admin_teleport_to_pending_at = 0.0 end # Phase 1: load the target's map. Phase 2 is run only after map transfer # AND server-side map registration have completed. def self.admin_teleport_to_enter_map(map_id) state = @admin_teleport_to_state return false unless state && admin_owner_active? mid = map_id.to_i return false if mid <= 0 || !$game_map || !$game_player return false unless respond_to?(:pvp_force_spawn_queue) map_key = pvp_force_spawn_resolve_map_key(mid) return false unless pvp_force_spawn_map_key_valid?(map_key) state[:map_id] = mid if $game_map.map_id.to_i == mid state[:phase] = :wait_position return true end # Do not overwrite another active transfer (reconnect / portal / PvP). return false if pvp_force_spawn_pending? return false if $game_player.respond_to?(:transfer?) && $game_player.transfer? state[:phase] = :load_map # (1,1) is the game's service entry; the spawn handler resolves StartPoint. # NEVER use the other player's coordinates in this first transfer. pvp_force_spawn_queue(map_key, 1, 1, 2, 2) true rescue false end def self.admin_teleport_to_player(target_id) return false unless admin_owner_active? return false unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map) tid = target_id.to_i return false if tid <= 0 || (!@my_id.nil? && tid == @my_id.to_i) return false unless $game_map && $game_player # Already together: jump on this map; do not trigger a map reload. target = @players[tid] if @players.is_a?(Hash) if target && @last_map_id.to_i == $game_map.map_id.to_i && target.respond_to?(:x) && target.respond_to?(:y) direction = target.respond_to?(:direction) ? target.direction : 2 if admin_owner_warp($game_map.map_id, target.x, target.y, direction) admin_teleport_to_clear admin_owner_tools_notice("Телепортация к игроку ##{tid}.") return true end end now = Time.now.to_f @admin_teleport_to_state = { :id => tid, :started_at => now, :phase => :lookup, :map_id => 0, :position => nil, :who_requested_at => now, :verified => false } @admin_teleport_to_pending_id = tid @admin_teleport_to_pending_at = now # A verified server answer supplies both map and position when supported. # who_list supplies the map as fallback; live pos arrives after map join. send_line("owner_teleport_to:#{tid}") mp_tab_request_who if respond_to?(:mp_tab_request_who) admin_owner_tools_notice("Поиск карты игрока ##{tid}...") true rescue admin_teleport_to_clear admin_owner_tools_notice("Телепортация недоступна.") false end # Called from Scene_Map#update, not from the socket parser. No map transfer # may be performed in the middle of processing a network packet. def self.admin_teleport_to_tick state = @admin_teleport_to_state return unless state unless admin_owner_active? admin_teleport_to_clear return end return unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map) if Time.now.to_f - state[:started_at].to_f > 20.0 admin_teleport_to_clear admin_owner_tools_notice("Игрок не найден на карте или не получены его координаты.") return end return unless $game_map && $game_player if state[:phase] == :lookup # Prefer a who_list received AFTER this teleport request, not stale TAB data. snapshot = @mp_tab_server if !state[:verified] && snapshot.is_a?(Hash) && snapshot[:time].to_f >= state[:who_requested_at].to_f list = snapshot[:list] row = list[state[:id]] if list.is_a?(Hash) unless row admin_teleport_to_clear admin_owner_tools_notice("Игрок больше не находится на сервере.") return end mid = (row[:map] || row['map']).to_i if mid > 0 unless admin_teleport_to_enter_map(mid) # Another map transfer can still be finishing; retry next frame. state[:map_id] = mid end end end # Retry after another transfer has released the spawn queue. if state[:phase] == :lookup && state[:map_id].to_i > 0 admin_teleport_to_enter_map(state[:map_id]) end end if state[:phase] == :load_map return unless $game_map.map_id.to_i == state[:map_id].to_i return if pvp_force_spawn_pending? return if $game_player.respond_to?(:transfer?) && $game_player.transfer? # The network must publish map: before accepting positions from it. return unless @last_map_id.to_i == state[:map_id].to_i state[:phase] = :wait_position end if state[:phase] == :wait_position return unless $game_map.map_id.to_i == state[:map_id].to_i return unless @last_map_id.to_i == state[:map_id].to_i pos = state[:position] return unless pos && pos.size == 3 if admin_owner_warp(state[:map_id], pos[0], pos[1], pos[2]) tid = state[:id] admin_teleport_to_clear admin_owner_tools_notice("Телепортация к игроку ##{tid}.") else admin_teleport_to_clear admin_owner_tools_notice("Координаты игрока вне границ карты.") end end rescue admin_teleport_to_clear admin_owner_tools_notice("Ошибка телепортации к игроку.") end def self.admin_toggle_player_freeze(target_id) return unless admin_owner_active? tid = target_id.to_i return if tid <= 0 || tid == my_id.to_i send_line("owner_freeze_toggle:#{tid}") rescue end def self.admin_owner_tools_reset @admin_noclip_enabled = false @admin_frozen_by_owner = false @admin_frozen_targets = {} @admin_see_hidden_enabled = false @admin_ghost_enabled = false @admin_mega_strength_enabled = false @admin_speed_multiplier = 1.0 MPMeasurements.clear if defined?(MPMeasurements) @admin_teleport_to_pending_id = nil @admin_teleport_to_pending_at = 0.0 @admin_teleport_to_state = nil admin_owner_skill_clear rescue end def self.admin_owner_tools_notice(text) message = text.to_s return if message == "" if respond_to?(:chat_local_system) chat_local_system(message) else puts "[OWNER] #{message}" end rescue end class << self alias mp_admin_menu_parse parse def parse(msg) # Reply must be sent by a trusted server after verifying OWNER role, # map ID, and the player's live position. Never accept client relays. if msg =~ /\Aowner_teleport_to_result:(\d+):(\d+):(\d+):(\d+):([2468])\z/ tid, mid, x, y, dir = $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i state = @admin_teleport_to_state if admin_owner_active? && state && state[:id].to_i == tid && (Time.now.to_f - state[:started_at].to_f) <= 20.0 # Server-verified position is accepted, but only used AFTER map load. state[:position] = [x, y, dir] state[:map_id] = mid state[:verified] = true state[:phase] = :lookup admin_teleport_to_enter_map(mid) end return end # The first fresh movement packet after joining the player's map # provides the teleport destination (not a stale cached event position). if msg =~ /\Apos:(\d+):(\d+):(\d+):([2468])(?:\:|\z)/ tid, x, y, dir = $1.to_i, $2.to_i, $3.to_i, $4.to_i state = @admin_teleport_to_state if state && state[:id].to_i == tid && state[:position].nil? && (state[:phase] == :wait_position || state[:phase] == :load_map) && $game_map && $game_map.map_id.to_i == state[:map_id].to_i && @last_map_id.to_i == state[:map_id].to_i && (!respond_to?(:world_event_packets_ready?) || world_event_packets_ready?) state[:position] = [x, y, dir] end end if msg =~ /^owner_noclip_state:([01])$/ @admin_noclip_enabled = ($1 == "1") admin_owner_tools_notice(@admin_noclip_enabled ? "Noclip включён." : "Noclip выключен.") return end if msg =~ /^owner_freeze_state:([01])$/ @admin_frozen_by_owner = ($1 == "1") admin_owner_tools_notice(@admin_frozen_by_owner ? "Вы заморожены OWNER." : "Заморозка снята.") return end if msg =~ /^owner_freeze_result:(\d+):([01])$/ @admin_frozen_targets ||= {} @admin_frozen_targets[$1.to_i] = ($2 == "1") admin_owner_tools_notice($2 == "1" ? "Игрок заморожен." : "Игрок разморожен.") return end if msg =~ /^owner_teleport_result:(\d+):1$/ admin_owner_tools_notice("Игрок телепортирован к вам.") return end if msg =~ /^owner_tools_error:(.*)$/ detail = $1.to_s begin detail = unesc(detail) rescue end admin_owner_tools_notice("OWNER: #{detail}") return end if msg =~ /^player_role:([A-Z_]+)$/ admin_set_role($1) admin_mark_role_received(true) return end if msg =~ /^server_kick:(.*)$/ reason = $1.to_s begin reason = unesc(reason) rescue end MPAdminMenu.request_forced_exit(reason) return end mp_admin_menu_parse(msg) end alias mp_admin_menu_disconnect disconnect def disconnect admin_set_role("PLAYER") admin_mark_role_received(false) admin_owner_tools_reset mp_admin_menu_disconnect end end end module MPAdminMenu OPEN_VK = 0xBF # / (VK_OEM_2) OPEN_VK_NUMPAD = 0x6F # numpad / OPEN_VK_LEGACY = 0xDC # keep old backslash hotkey ROOT_EMOJI_TEXT = "Эмодзи" EMOJI_FRONT_TEXT = "Спереди" EMOJI_BACK_TEXT = "Сзади" ROOT_STYLE_TEXT = "Стиль ника" ROOT_MODERATION_TEXT = "Выгнать" ROOT_KICK_TEXT = "Кик игрока" ROOT_BAN_TEXT = "Бан игрока" ROOT_BANIP_TEXT = "Бан IP игрока" ROOT_NOCLIP_TEXT = "Noclip" ROOT_GHOST_TEXT = "Призрак" ROOT_CHEAT_TEXT = "Чит-фреймворк" ROOT_TELEPORTATION_TEXT = "Передвижение" ROOT_TELEPORT_TEXT = "Телепортировать игрока ко мне" ROOT_TELEPORT_TO_TEXT = "Телепортироваться к игроку" ROOT_SEE_HIDDEN_TEXT = "Видеть скрытых" ROOT_FREEZE_TEXT = "Заморозить / разморозить игрока" ROOT_SPEED_TEXT = "Скорость передвижения" ROOT_MEASUREMENTS_TEXT = "Измерения" ROOT_COORDINATES_TEXT = "Координаты" ROOT_SKILLS_TEXT = "Навыки OWNER" ROOT_MEGA_TEXT = "Мега-сила: 1 000 000 урона" ROOT_SKILL_CAST_TEXT = "Применить навык [F7]" ROOT_SKILL_CLEAR_TEXT = "Сбросить выбранный навык" SKILL_HOTKEY_VK = 0x76 # F7 on PC; menu command also works without this key EMPTY_TEXT = "Нет игроков онлайн" @forced_exit_reason = nil def self.request_forced_exit(reason) @forced_exit_reason = reason.to_s rescue @forced_exit_reason = "" end def self.consume_forced_exit reason = @forced_exit_reason @forced_exit_reason = nil return nil if reason.nil? reason.to_s rescue nil end # Use the active RUS2 menu font for this overlay. System fonts such as # Arial are rasterized differently by each runtime and look blurred after # the game's integer scaling. def self.menu_font_name return @ui_menu_font if @ui_menu_font begin if defined?(MPSafeFont) && MPSafeFont.respond_to?(:rus2_active?) && MPSafeFont.rus2_active? name = MPSafeFont.rus2_font(:MENU_L, :TITLE_MENU, :CHOICE) return @ui_menu_font = name if name && Font.exist?(name) end rescue end candidates = ["Arial", "DejaVu Sans", "Noto Sans", "VL Gothic"] if defined?(Font) && Font.respond_to?(:exist?) @ui_menu_font = candidates.find { |f| Font.exist?(f) } || "VL Gothic" else @ui_menu_font = "Arial" end @ui_menu_font rescue "VL Gothic" end # Capture only gameplay input; menu navigation still uses the real Input. def self.captures_gameplay_input? return false unless defined?(SceneManager) && defined?(Scene_Map) scene = SceneManager.scene scene.is_a?(Scene_Map) && ( (scene.respond_to?(:mp_admin_menu_active?) && scene.mp_admin_menu_active?) || (scene.respond_to?(:mp_admin_input_frame_locked?) && scene.mp_admin_input_frame_locked?) ) rescue false end # Input is masked only during Scene_Map's game simulation phase, not # while Window_Selectable processes arrows/Enter/Esc in update_basic. def self.gameplay_keys_locked? !!@gameplay_keys_locked end def self.lock_gameplay_keys(value) @gameplay_keys_locked = value ? true : false end def self.style_preview_name nick = (NicknameInput.nickname.to_s rescue "") nick = "LonaRPG" if nick.strip.empty? nick rescue "LonaRPG" end def self.style_preview_font return NicknameInput.ui_font_name if defined?(NicknameInput) && NicknameInput.respond_to?(:ui_font_name) return MPSafeFont.nick_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:nick_name) menu_font_name rescue menu_font_name end def self.emoji_font_name return MPNickEmoji.font_name if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:font_name) menu_font_name rescue menu_font_name end def self.skill_triggered? return false unless defined?(MPKeyboard) && MPKeyboard.respond_to?(:trigger?) MPKeyboard.trigger?(SKILL_HOTKEY_VK) rescue false end def self.open_triggered? return false unless defined?(MPKeyboard) && MPKeyboard.respond_to?(:trigger?) MPKeyboard.trigger?(OPEN_VK) || MPKeyboard.trigger?(OPEN_VK_NUMPAD) || MPKeyboard.trigger?(OPEN_VK_LEGACY) rescue false end def self.blocked_by_other_ui? return true if defined?(MPChat) && MPChat.respond_to?(:active?) && MPChat.active? return true if defined?(WebSocket) && WebSocket.respond_to?(:trade_active?) && WebSocket.trade_active? return true if defined?(WebSocket) && WebSocket.respond_to?(:player_menu_open?) && WebSocket.player_menu_open? return true if defined?(MPCompanionSync) && MPCompanionSync.respond_to?(:ui_active?) && MPCompanionSync.ui_active? false rescue false end # Icons are loaded only from this folder, never shipped with the patch. ICON_ROOT = "Graphics/Online/menu/" ICON_NAMES = { :style_root => "style", :emoji_root => "emoji", :moderation_root => "kick", :kick_root => "kick", :teleportation_root => "teleport_to", :ghost_toggle => "casper", :ban_root => "ban", :banip_root => "banip", :owner_noclip => "noclip", :owner_see_hidden => "see_hidden", :owner_teleport_root => "teleport_here", :owner_teleport_to_root => "teleport_to", :owner_freeze_root => "freeze", :owner_speed => "speed", :measurements_root => "measurements", :coordinates_toggle => "coordinates", :owner_skills_root => "owner_skills", :owner_mega_strength => "mega_strength", :owner_skill_cast => "skill_cast", :owner_skill_clear => "skill_clear", :god_toggle => "god", :cheat_menu_root => "cheat_menu", :mp_back => "back", :noop => "empty" }.freeze def self.grid_title(state) case state when :root then "LonaRPG | Меню #{WebSocket.admin_role_name}" when :moderation then "Выгнать | Кик и баны" when :teleportation then "Передвижение | Выбор действия" when :measurements then "Измерения | Выбор действия" when :owner_teleport then "Передвижение | Игрок ко мне" when :owner_teleport_to then "Передвижение | Я к игроку" when :owner_freeze then "Передвижение | Заморозка игрока" when :kick then "Выгнать | Выбор для кика" when :ban then "Выгнать | Выбор для бана" when :banip then "Выгнать | Выбор для IP-бана" when :style then "Стиль ника" when :emoji_side then "Эмодзи | Расположение" when :emoji_pick then "Эмодзи | Выбор" when :owner_skills then "Навыки OWNER" else "Выбор игрока" end rescue "Меню" end def self.entry_icon_candidates(state, symbol, ext) symbol = symbol.to_sym case symbol when :style_pick ["style_#{ext.to_i}", "style"] when :emoji_side_pick ["emoji_#{ext.to_s == 'front' ? 'front' : 'back'}", "emoji"] when :emoji_pick if ext.to_s.empty? ["emoji_clear", "emoji"] else slug = (MPNickEmoji.slug_for(ext.to_s) rescue nil) slug ? ["emoji_#{slug}", "@nick_emoji/#{slug}", "emoji"] : ["emoji"] end when :owner_skill_pick ["skill_#{ext.to_s}", ext.to_s, "owner_skills"] when :cheat_menu_root ["cheat_menu", "cheatmenu"] when :target_pick ["player_#{ext.to_i}", "player"] else [ICON_NAMES[symbol] || symbol.to_s] end rescue ["empty"] end def self.icon_bitmap_for(state, symbol, ext) entry_icon_candidates(state, symbol, ext).each do |entry| root, name = entry.start_with?("@nick_emoji/") ? ["Graphics/Online/nick_emoji/", entry.sub("@nick_emoji/", "")] : [ICON_ROOT, entry] next unless name =~ /\A[a-zA-Z0-9_\-]+\z/ next unless File.exist?(root + name + ".png") begin bmp = Cache.load_bitmap(root, name) return bmp if bmp && !bmp.disposed? rescue begin bmp = Bitmap.new(root + name + ".png") return bmp rescue end end end nil rescue nil end def self.inactive_icon?(symbol, enabled) return true unless enabled case symbol.to_sym when :owner_noclip then !WebSocket.admin_noclip_enabled? when :owner_see_hidden then !WebSocket.admin_see_hidden_enabled? when :ghost_toggle then !WebSocket.admin_ghost_active? when :owner_mega_strength then !WebSocket.admin_mega_strength_enabled? when :owner_speed then WebSocket.admin_speed_multiplier == 1.0 when :coordinates_toggle then !defined?(MPMeasurements) || !MPMeasurements.enabled? when :god_toggle then !defined?(MPGodMode) || !MPGodMode.active? || MPGodMode.pending? else false end rescue !enabled end def self.gray_icon(bitmap, size) return nil if bitmap.nil? @gray_cache ||= {} key = [bitmap.object_id, size.to_i] bmp = @gray_cache[key] return bmp if bmp && !bmp.disposed? s = [[size.to_i, 16].max, 64].min bmp = Bitmap.new(s, s) bmp.stretch_blt(Rect.new(0, 0, s, s), bitmap, bitmap.rect) # Compute gray shades on a small cached icon, not per frame. s.times do |y| s.times do |x| c = bmp.get_pixel(x, y) next if c.alpha == 0 g = ((c.red * 30 + c.green * 59 + c.blue * 11) / 100).to_i bmp.set_pixel(x, y, Color.new(g, g, g, c.alpha)) end end @gray_cache[key] = bmp bmp rescue nil end def self.entry_hint(state, row) label, symbol, enabled, ext = row return "Ожидание подтверждения GOD от сервера." if symbol == :god_toggle && !enabled return "Нет доступных игроков. Попробуйте позже." unless enabled case symbol when :style_root then "Выбрать цвет и оформление никнейма." when :emoji_root then "Добавить эмодзи перед ником или после него." when :moderation_root then "Кик и блокировка игроков. Открыть подменю наказаний." when :teleportation_root then "Телепортация, заморозка игроков и изменение скорости движения." when :measurements_root then "Измерения: отображение координат персонажа и ID карты." when :coordinates_toggle then "Включить или выключить координаты X/Y и ID карты внизу слева." when :owner_speed then "Переключение скорости: x1 → x1.5 → x2 → x3 → x1." when :ghost_toggle then "Скрыть персонажа и ник от других игроков. Переключатель ВКЛ/ВЫКЛ." when :kick_root then "Отключить выбранного игрока от сервера." when :ban_root then "Заблокировать аккаунт выбранного игрока." when :banip_root then "Заблокировать IP-адрес выбранного игрока." when :god_toggle then "Режим бессмертия GOD: включить или выключить (подтверждает сервер)." when :cheat_menu_root then "Чит-фреймворк" when :owner_noclip then "Проходить сквозь препятствия. Нажмите для смены режима." when :owner_see_hidden then "Показывать игроков в скрытом режиме. Нажмите для смены." when :owner_teleport_root then "Переместить выбранного игрока к себе." when :owner_teleport_to_root then "Переместиться к выбранному игроку." when :owner_freeze_root then "Ограничить движение игрока или снять заморозку." when :owner_skills_root then "Выбрать специальный навык OWNER и цель." when :owner_mega_strength then "Урон 1 000 000. Нажмите для включения или выключения." when :owner_skill_cast then "Применить подготовленный навык. Горячая клавиша F7." when :owner_skill_clear then "Сбросить выбранный навык и цель." when :owner_skill_pick then "Выбрать цель для навыка: #{label}." when :style_pick then "Установить стиль: #{label}." when :emoji_side_pick then "Выбрать расположение: #{label}." when :emoji_pick then ext.to_s == "" ? "Убрать эмодзи с ника." : "Установить эмодзи: #{label}." when :target_pick then "Выбрать игрока: #{label}." when :mp_back then "Вернуться в предыдущее меню." else label.to_s end rescue "Выберите действие." end def self.see_hidden_label ROOT_SEE_HIDDEN_TEXT + ": " + (WebSocket.admin_see_hidden_enabled? ? "ВКЛ" : "ВЫКЛ") rescue ROOT_SEE_HIDDEN_TEXT end def self.ghost_label ROOT_GHOST_TEXT + ": " + (WebSocket.admin_ghost_active? ? "ВКЛ" : "ВЫКЛ") rescue ROOT_GHOST_TEXT end def self.mega_strength_label ROOT_MEGA_TEXT + ": " + (WebSocket.admin_mega_strength_enabled? ? "ВКЛ" : "ВЫКЛ") rescue ROOT_MEGA_TEXT end def self.speed_label ROOT_SPEED_TEXT + ": x" + WebSocket.admin_speed_multiplier.to_s rescue ROOT_SPEED_TEXT end def self.coordinates_label ROOT_COORDINATES_TEXT + ": " + (defined?(MPMeasurements) && MPMeasurements.enabled? ? "ВКЛ" : "ВЫКЛ") rescue ROOT_COORDINATES_TEXT end def self.noclip_label ROOT_NOCLIP_TEXT + ": " + (WebSocket.admin_noclip_enabled? ? "ВКЛ" : "ВЫКЛ") rescue ROOT_NOCLIP_TEXT end end # Grid is a transparent selectable overlay over a TAB-like Window_Base. # No icon packs are included: user supplies individual PNG files in # Graphics/Online/menu/. All submenus share the same widget. class Window_MPAdminIconGrid < Window_Selectable CELL_HEIGHT = 58 # Reserve room for cursor border above and below the 45px icon ICON_SIZE = 45 COL_SPACING = 6 HEADER_HEIGHT = 30 FOOTER_HEIGHT = 72 # Three clear lines of readable help text. GRID_TOP_PAD = 5 # Keep selection border clear of the menu title def initialize(commands, state) @mp_state = state @mp_entries = normalize_entries(commands) @mp_last_index = -2 w = [[(Graphics.width * 0.79).to_i, 440].max, Graphics.width - 16].min h = [[(Graphics.height * 0.91).to_i, 318].max, Graphics.height - 12].min w = [w, 190].max h = [h, 170].max x = (Graphics.width - w) / 2 y = (Graphics.height - h) / 2 @mp_frame = Window_Base.new(x, y, w, h) @mp_frame.opacity = 180 @mp_frame.back_opacity = 210 @mp_frame.z = 9997 grid_x = x + 6 grid_y = y + HEADER_HEIGHT + GRID_TOP_PAD grid_w = w - 12 # Keep the grid clear of the footer text inside Window_Base padding. grid_h = h - HEADER_HEIGHT - FOOTER_HEIGHT - GRID_TOP_PAD - 12 # Style entries are actual nickname previews; give each enough width. @mp_cols = if state == :style grid_w >= 250 ? 2 : 1 else grid_w >= 370 ? 4 : (grid_w >= 250 ? 3 : 2) end super(grid_x, grid_y, grid_w, grid_h) self.z = 9999 self.opacity = 0 self.back_opacity = 0 self.openness = 255 @mp_frame.openness = 255 @mp_pointer = nil begin @mp_pointer = Sprite.new @mp_pointer.bitmap = Cache.system("Menu/cursor") @mp_pointer.z = 10000 rescue @mp_pointer.dispose if @mp_pointer @mp_pointer = nil end refresh activate select(0) end def normalize_entries(commands) rows = [] if commands.is_a?(Array) commands.each do |row| next unless row.is_a?(Array) && row.size >= 2 rows << [row[0].to_s, row[1].to_sym, row.size < 3 ? true : !!row[2], row[3]] end end rows = [[MPAdminMenu::EMPTY_TEXT, :noop, false, nil]] if rows.empty? rows rescue [[MPAdminMenu::EMPTY_TEXT, :noop, false, nil]] end def col_max @mp_cols || 4 end def spacing COL_SPACING end def item_max @mp_entries ? @mp_entries.size : 0 end def item_height @mp_state == :style ? 66 : CELL_HEIGHT end def current_ext row = @mp_entries[self.index] row ? row[3] : nil end def current_symbol row = @mp_entries[self.index] row ? row[1] : :noop end def current_item_enabled? row = @mp_entries[self.index] row && !!row[2] end # Window_Selectable normally enables OK only when :ok is registered. # Here each icon is registered under its individual action symbol. def ok_enabled? true end def call_ok_handler call_handler(current_symbol) if handle?(current_symbol) activate unless disposed? || !handle?(current_symbol) end def refresh create_contents contents.clear draw_all_items mp_redraw_frame end def select(index) super(index) mp_redraw_frame if @mp_frame && !@mp_frame.disposed? mp_move_pointer end def update_cursor super return if @index.nil? || @index < 0 cell = item_rect(@index) # The entire highlight must fit inside its cell to avoid clipping. if @mp_state == :style # A wide, unscaled preview gets a whole-cell selection border. cursor_rect.set(cell.x + 3, cell.y + 3, [cell.width - 6, 1].max, [cell.height - 6, 1].max) else iw = [[ICON_SIZE + 8, cell.width - 6, cell.height - 6].min, 12].max ix = cell.x + (cell.width - iw) / 2 iy = cell.y + (cell.height - iw) / 2 cursor_rect.set(ix, iy, iw, iw) end mp_move_pointer rescue end def mp_move_pointer return unless @mp_pointer && !@mp_pointer.disposed? return unless @index && @index >= 0 cell = item_rect(@index) # Align to the actual rendered icon size (which can shrink on small screens). size = [ICON_SIZE, cell.width - 4, cell.height - 4].min cx = self.x + standard_padding + cell.x - self.ox + (cell.width - size) / 2 cy = self.y + standard_padding + cell.y - self.oy + (cell.height - size) / 2 # Leave a clear gap between the arrow tip and the selected icon. if @mp_state == :style # Arrow stays inside its own gutter, separate from the preview text. cx = self.x + standard_padding + cell.x - self.ox + 4 cy = self.y + standard_padding + cell.y - self.oy + cell.height / 2 @mp_pointer.x = cx @mp_pointer.y = cy - @mp_pointer.bitmap.height / 2 else @mp_pointer.x = cx - @mp_pointer.bitmap.width - 6 @mp_pointer.y = cy + size / 2 - @mp_pointer.bitmap.height / 2 end visible_top = self.y + standard_padding visible_bottom = self.y + height - standard_padding @mp_pointer.visible = cell.y - self.oy >= 0 && cell.y - self.oy + cell.height <= height - 2 * standard_padding rescue end def mp_redraw_frame return if @mp_frame.nil? || @mp_frame.disposed? b = @mp_frame.contents b.clear b.font.name = MPAdminMenu.menu_font_name b.font.bold = true b.font.outline = false b.font.shadow = false b.font.size = 19 b.font.color = Color.new(255, 225, 155) b.draw_text(0, 0, b.width, 24, MPAdminMenu.grid_title(@mp_state), 1) row = (@mp_entries && @mp_entries[@index]) || nil return unless row footer_y = b.height - FOOTER_HEIGHT b.fill_rect(2, footer_y, [b.width - 4, 1].max, 1, Color.new(235, 166, 82, 160)) b.font.color = row[2] ? Color.new(255, 232, 160) : Color.new(175, 175, 175) b.font.size = 18 b.draw_text(0, footer_y + 3, b.width, 24, row[0].to_s, 1) b.font.bold = true b.font.size = 16 b.font.color = Color.new(240, 240, 240) b.draw_text(0, footer_y + 29, b.width, 22, MPAdminMenu.entry_hint(@mp_state, row), 1) b.font.size = 14 b.font.color = Color.new(195, 195, 195) b.draw_text(0, footer_y + 53, b.width, 17, "← ↑ ↓ → — выбор • Enter/нажатие — открыть • Esc — назад", 1) rescue end def draw_item(index) row = @mp_entries[index] return unless row cell = item_rect(index) if @mp_state == :style && row[1] == :style_pick draw_style_preview(row, cell) return end size = [ICON_SIZE, cell.width - 4, cell.height - 4].min dx = cell.x + (cell.width - size) / 2 dy = cell.y + (cell.height - size) / 2 image = MPAdminMenu.icon_bitmap_for(@mp_state, row[1], row[3]) inactive = MPAdminMenu.inactive_icon?(row[1], row[2]) if image if inactive gray = MPAdminMenu.gray_icon(image, size) if gray contents.blt(dx, dy, gray, gray.rect) else contents.stretch_blt(Rect.new(dx, dy, size, size), image, image.rect, 110) end else contents.stretch_blt(Rect.new(dx, dy, size, size), image, image.rect) end else # Missing PNG is not a fatal error; reserve a cell for icons the user adds later. bg = inactive ? Color.new(52, 52, 52, 200) : Color.new(94, 48, 27, 210) edge = inactive ? Color.new(140, 140, 140) : Color.new(222, 111, 55) contents.fill_rect(dx, dy, size, size, edge) contents.fill_rect(dx + 2, dy + 2, size - 4, size - 4, bg) contents.font.name = MPAdminMenu.menu_font_name contents.font.size = 15 contents.font.bold = true contents.font.outline = false contents.font.shadow = false contents.font.color = inactive ? Color.new(180, 180, 180) : Color.new(255, 218, 120) contents.draw_text(dx, dy, size, size, "?", 1) end rescue end # Render real nickname styles instead of style_N.png tiles. # Uses precisely the same MPNickStyle renderer as above players' heads. def draw_style_preview(row, cell) # Reserve enough space for the full game's cursor sprite, with a gap. pointer_width = @mp_pointer && @mp_pointer.bitmap ? @mp_pointer.bitmap.width : 30 left_gutter = [[pointer_width + 12, 44].max, cell.width / 2].min x = cell.x + left_gutter width = [cell.width - left_gutter - 8, 1].max contents.fill_rect(x, cell.y + 5, width, 52, Color.new(20, 20, 20, 165)) sid = row[3].to_i label = row[0].to_s # Prefer player's nickname, clipping to the available width without # stretching the pixels or distorting the actual style appearance. nick = MPAdminMenu.style_preview_name nick = nick[0, 18] if nick.length > 18 if defined?(MPNickStyle) && MPNickStyle.respond_to?(:redraw_sprite) sprite = nil begin sprite = Sprite.new font_name = MPAdminMenu.style_preview_font loop do MPNickStyle.redraw_sprite(sprite, nick, font_name, sid, 16, sid) break unless sprite.bitmap && sprite.bitmap.width > width - 8 && nick.length > 3 nick = nick[0, nick.length - 2] + "…" end if sprite.bitmap && !sprite.bitmap.disposed? bmp = sprite.bitmap pos_x = x + (width - bmp.width) / 2 pos_y = cell.y + 6 + (33 - bmp.height) / 2 contents.blt(pos_x, [pos_y, cell.y + 3].max, bmp, bmp.rect) end ensure if sprite sprite.bitmap.dispose if sprite.bitmap && !sprite.bitmap.disposed? sprite.dispose end end else contents.font.name = MPAdminMenu.menu_font_name contents.font.size = 16 contents.font.bold = true contents.font.outline = false contents.font.shadow = false contents.font.color = Color.new(255, 238, 170) contents.draw_text(x, cell.y + 8, width, 28, nick, 1) end contents.font.name = MPAdminMenu.menu_font_name contents.font.bold = true contents.font.shadow = false contents.font.outline = false contents.font.size = 13 contents.font.color = Color.new(220, 220, 220) contents.draw_text(x, cell.y + 43, width, 19, label, 1) rescue # Faulty user style definition must not close the admin menu. contents.font.name = MPAdminMenu.menu_font_name contents.font.size = 16 contents.font.bold = true contents.font.outline = false contents.font.shadow = false contents.font.color = Color.new(255, 255, 255) contents.draw_text(x, cell.y + 15, width, 24, label, 1) end # Mouse/touch (the game's Android touch bridge generates MZ_LINK). def update super # A noclip toggle is server-confirmed asynchronously, so refresh icon tones. flags = [WebSocket.admin_noclip_enabled?, WebSocket.admin_see_hidden_enabled?, WebSocket.admin_ghost_active?, WebSocket.admin_mega_strength_enabled?, (defined?(MPGodMode) ? [MPGodMode.active?, MPGodMode.pending?] : nil)] rescue nil if flags && flags != @mp_icon_flags @mp_icon_flags = flags refresh end # Update animated nickname previews at 5fps, without rebuilding on every # game frame. Static styles are still rendered by the same renderer. if @mp_state == :style && defined?(Graphics) tick = Graphics.frame_count / 12 if @mp_style_render_tick != tick @mp_style_render_tick = tick refresh end end mp_move_pointer mp_update_mouse rescue end def mp_update_mouse return unless active && defined?(Mouse) && Mouse.respond_to?(:enable?) && Mouse.enable? return unless defined?(Input) && Input.trigger?(:MZ_LINK) item_max.times do |i| cell = item_rect(i) ax = self.x + standard_padding + cell.x - self.ox ay = self.y + standard_padding + cell.y - self.oy next if ay < self.y + standard_padding || ay + cell.height > self.y + height - standard_padding next unless Mouse.within_XYWH?(ax, ay, cell.width, cell.height) select(i) process_ok if current_item_enabled? break end rescue end def dispose if @mp_pointer @mp_pointer.dispose rescue nil # cached source bitmap belongs to Cache @mp_pointer = nil end if @mp_frame @mp_frame.dispose rescue nil @mp_frame = nil end super end end class Window_MPEmojiGrid < Window_Selectable CELL_SIZE = 20 MAX_COLS = 20 MAX_ROWS = 20 def initialize(entries = [], font_name = nil) @entries = normalize_entries(entries) @mp_font_name = font_name @mp_cols = [[((Graphics.width - 48) / CELL_SIZE).to_i, 1].max, MAX_COLS].min @mp_rows = [[((Graphics.height - 72) / CELL_SIZE).to_i, 4].max, MAX_ROWS].min pad = 12 width = @mp_cols * CELL_SIZE + pad * 2 + 8 height = @mp_rows * CELL_SIZE + pad * 2 + 8 super((Graphics.width - width) / 2, (Graphics.height - height) / 2, width, height) self.z = 9999 self.openness = 255 self.back_opacity = 220 refresh activate select(0) end def normalize_entries(entries) rows = [] if entries.is_a?(Array) entries.each do |row| next unless row.is_a?(Array) && row.size >= 2 rows << [row[0].to_s, row[1].to_s] end end rows = [["X", ""]] if rows.empty? rows rescue [["X", ""]] end def col_max @mp_cols end def item_max @entries.size end def item_width CELL_SIZE end def item_height CELL_SIZE end def spacing 0 end def line_height CELL_SIZE end def contents_width [col_max * item_width, 1].max end def contents_height rows = [[(item_max + col_max - 1) / col_max, 1].max, 1].max [rows * item_height, 1].max end def current_ext row = @entries[self.index] row ? row[1] : "" rescue "" end def refresh create_contents contents.clear draw_all_items rescue end def draw_item(index) row = @entries[index] return if row.nil? rect = item_rect(index) if row[1].to_s == "" contents.font.name = MPAdminMenu.menu_font_name contents.font.size = 16 contents.font.bold = true contents.font.outline = false contents.font.shadow = false draw_text(rect, row[0].to_s, 1) return end ok = false if defined?(MPNickEmoji) && MPNickEmoji.respond_to?(:draw_icon) ok = MPNickEmoji.draw_icon(contents, rect, row[1].to_s, CELL_SIZE - 4) end unless ok contents.font.name = (@mp_font_name || MPAdminMenu.emoji_font_name) contents.font.size = 16 contents.font.bold = true contents.font.outline = false contents.font.shadow = false draw_text(rect, row[0].to_s, 1) end rescue end end class Scene_Base unless method_defined?(:mp_admin_force_exit_update) alias mp_admin_force_exit_update update end def update(*args, &block) mp_admin_force_exit_update(*args, &block) mp_process_admin_forced_exit end def mp_process_admin_forced_exit reason = MPAdminMenu.consume_forced_exit return if reason.nil? begin WebSocket.disconnect if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected? rescue end begin SceneManager.exit return rescue end begin exit rescue end rescue end end class Scene_Map < Scene_Base unless method_defined?(:mp_admin_menu_start) alias mp_admin_menu_start start end def start(*args, &block) mp_admin_menu_start(*args, &block) mp_admin_dispose_menu end unless method_defined?(:mp_admin_menu_update) alias mp_admin_menu_update update end # Let the icon window read actual keys, then mask gameplay keystrokes # for map/player/spriteset processing in the same frame. unless method_defined?(:mp_admin_input_orig_update_basic) alias mp_admin_input_orig_update_basic update_basic end def update_basic(*args, &block) MPAdminMenu.lock_gameplay_keys(false) mp_admin_input_orig_update_basic(*args, &block) ensure MPAdminMenu.lock_gameplay_keys(mp_admin_input_frame_locked? || mp_admin_menu_active?) end def mp_admin_input_frame_locked? !!@mp_admin_input_frame_locked end def update(*args, &block) @mp_admin_input_frame_locked = mp_admin_menu_active? mp_admin_menu_update(*args, &block) # Original map update has finished; hotkeys for the admin UI work as normal. MPAdminMenu.lock_gameplay_keys(false) mp_admin_validate_menu_role mp_admin_update_hotkey mp_admin_update_skill_hotkey ensure MPAdminMenu.lock_gameplay_keys(false) @mp_admin_input_frame_locked = false end unless method_defined?(:mp_admin_menu_terminate) alias mp_admin_menu_terminate terminate end def terminate(*args, &block) mp_admin_dispose_menu mp_admin_menu_terminate(*args, &block) end # Immediately close/redraw menus if the server changes the role during use. def mp_admin_validate_menu_role return unless mp_admin_menu_active? if !WebSocket.connected? || !WebSocket.admin_role_received? || WebSocket.admin_role_rank <= 0 mp_admin_dispose_menu elsif @mp_admin_shown_role != WebSocket.admin_role_name mp_admin_open_root end rescue mp_admin_dispose_menu end def mp_admin_menu_active? return false if @mp_admin_window.nil? !@mp_admin_window.disposed? rescue false end def mp_admin_update_hotkey return unless defined?(WebSocket) return unless WebSocket.respond_to?(:connected?) && WebSocket.connected? return unless WebSocket.respond_to?(:admin_role_received?) && WebSocket.admin_role_received? return unless WebSocket.respond_to?(:admin_role_rank) && WebSocket.admin_role_rank > 0 return if MPAdminMenu.blocked_by_other_ui? return unless MPAdminMenu.open_triggered? if mp_admin_menu_active? mp_admin_dispose_menu else mp_admin_open_root end rescue end # F7 executes the prepared skill without reopening the OWNER menu. def mp_admin_update_skill_hotkey return unless defined?(WebSocket) && WebSocket.admin_owner_skill_prepared? return if mp_admin_menu_active? || MPAdminMenu.blocked_by_other_ui? return unless MPAdminMenu.skill_triggered? WebSocket.admin_owner_skill_cast rescue end def mp_admin_dispose_menu if @mp_admin_window @mp_admin_window.dispose rescue nil @mp_admin_window = nil end @mp_admin_state = nil @mp_admin_pending_action = nil @mp_admin_pending_emoji_side = nil @mp_admin_pending_skill = nil @mp_admin_shown_role = nil rescue @mp_admin_window = nil @mp_admin_state = nil @mp_admin_pending_action = nil @mp_admin_pending_emoji_side = nil @mp_admin_pending_skill = nil @mp_admin_shown_role = nil end def mp_admin_open_root return mp_admin_dispose_menu unless WebSocket.connected? && WebSocket.admin_role_received? commands = [] commands << [MPAdminMenu::ROOT_STYLE_TEXT, :style_root, true, nil] if WebSocket.admin_can_style? commands << [MPAdminMenu::ROOT_EMOJI_TEXT, :emoji_root, true, nil] if WebSocket.admin_can_style? commands << [MPAdminMenu::ROOT_MODERATION_TEXT, :moderation_root, true, nil] if WebSocket.admin_can_kick? commands << [MPAdminMenu.ghost_label, :ghost_toggle, true, nil] if WebSocket.admin_can_ghost? if WebSocket.admin_can_ban? commands << [MPAdminMenu.noclip_label, :owner_noclip, true, nil] commands << [MPAdminMenu.see_hidden_label, :owner_see_hidden, true, nil] commands << [MPAdminMenu::ROOT_TELEPORTATION_TEXT, :teleportation_root, true, nil] commands << [MPAdminMenu::ROOT_MEASUREMENTS_TEXT, :measurements_root, true, nil] if WebSocket.admin_owner_active? if WebSocket.admin_owner_active? commands << [MPAdminMenu::ROOT_SKILLS_TEXT, :owner_skills_root, true, nil] commands << [MPAdminMenu.mega_strength_label, :owner_mega_strength, true, nil] if WebSocket.admin_owner_skill_prepared? commands << [WebSocket.admin_owner_skill_cast_label, :owner_skill_cast, true, nil] commands << [MPAdminMenu::ROOT_SKILL_CLEAR_TEXT, :owner_skill_clear, true, nil] end end end if WebSocket.admin_owner_active? && defined?(MPGodMode) commands << [MPGodMode.label, :god_toggle, !MPGodMode.pending?, nil] end if WebSocket.admin_owner_active? && defined?(Scene_CheatMainMenu) && defined?($framework) && $framework commands << [MPAdminMenu::ROOT_CHEAT_TEXT, :cheat_menu_root, true, nil] end return if commands.empty? mp_admin_show_commands(commands, :root, WebSocket.admin_can_ban? ? 430 : 320) @mp_admin_window.set_handler(:style_root, method(:mp_admin_open_style_menu)) @mp_admin_window.set_handler(:emoji_root, method(:mp_admin_open_emoji_side_menu)) @mp_admin_window.set_handler(:moderation_root, method(:mp_admin_open_moderation_menu)) @mp_admin_window.set_handler(:ghost_toggle, method(:mp_admin_toggle_ghost)) @mp_admin_window.set_handler(:teleportation_root, method(:mp_admin_open_teleportation_menu)) @mp_admin_window.set_handler(:measurements_root, method(:mp_admin_open_measurements_menu)) @mp_admin_window.set_handler(:kick_root, method(:mp_admin_open_kick_targets)) @mp_admin_window.set_handler(:ban_root, method(:mp_admin_open_ban_targets)) @mp_admin_window.set_handler(:banip_root, method(:mp_admin_open_banip_targets)) @mp_admin_window.set_handler(:god_toggle, method(:mp_god_toggle)) if defined?(MPGodMode) && respond_to?(:mp_god_toggle) @mp_admin_window.set_handler(:cheat_menu_root, method(:mp_admin_open_cheatframework)) @mp_admin_window.set_handler(:owner_noclip, method(:mp_admin_toggle_owner_noclip)) @mp_admin_window.set_handler(:owner_see_hidden, method(:mp_admin_toggle_owner_see_hidden)) @mp_admin_window.set_handler(:owner_teleport_root, method(:mp_admin_open_owner_teleport_targets)) @mp_admin_window.set_handler(:owner_teleport_to_root, method(:mp_admin_open_owner_teleport_to_targets)) @mp_admin_window.set_handler(:owner_skills_root, method(:mp_admin_open_owner_skills)) @mp_admin_window.set_handler(:owner_mega_strength, method(:mp_admin_toggle_owner_mega_strength)) @mp_admin_window.set_handler(:owner_skill_cast, method(:mp_admin_cast_owner_skill)) @mp_admin_window.set_handler(:owner_skill_clear, method(:mp_admin_clear_owner_skill)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_dispose_menu)) rescue mp_admin_dispose_menu end # Enter CheatFramework without leaving the old overlay behind. def mp_admin_open_cheatframework return mp_admin_open_root unless WebSocket.admin_owner_active? return mp_admin_open_root unless defined?(Scene_CheatMainMenu) && defined?($framework) && $framework mp_admin_dispose_menu SceneManager.call(Scene_CheatMainMenu) rescue mp_admin_dispose_menu end def mp_admin_open_style_menu entries = [] begin WebSocket.admin_style_entries.each do |sid, name| entries << ["#{sid} - #{name}", :style_pick, true, sid.to_i] end rescue entries = [] end mp_admin_show_commands(entries, :style, 360) @mp_admin_window.set_handler(:style_pick, method(:mp_admin_apply_style)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end def mp_admin_open_emoji_side_menu entries = [ [MPAdminMenu::EMOJI_FRONT_TEXT, :emoji_side_pick, true, "front"], [MPAdminMenu::EMOJI_BACK_TEXT, :emoji_side_pick, true, "back"], ] mp_admin_show_commands(entries, :emoji_side, 260) @mp_admin_window.set_handler(:emoji_side_pick, method(:mp_admin_open_emoji_list)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end def mp_admin_open_emoji_list return unless @mp_admin_window side = @mp_admin_window.current_ext.to_s return unless side == "front" || side == "back" entries = [] begin WebSocket.admin_emoji_entries.each do |name, emoji| entries << [name.to_s, :emoji_pick, true, emoji.to_s] end rescue entries = [] end mp_admin_show_commands(entries, :emoji_pick) # mp_admin_show_commands resets pending values; assign after creating the window. @mp_admin_pending_emoji_side = side @mp_admin_window.set_handler(:emoji_pick, method(:mp_admin_apply_emoji)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_emoji_side_menu)) rescue mp_admin_open_root end # Moderation actions share the same grid UI and always respect role access. def mp_admin_open_moderation_menu return mp_admin_open_root unless WebSocket.admin_can_kick? entries = [[MPAdminMenu::ROOT_KICK_TEXT, :kick_root, true, nil]] if WebSocket.admin_can_ban? entries << [MPAdminMenu::ROOT_BAN_TEXT, :ban_root, true, nil] entries << [MPAdminMenu::ROOT_BANIP_TEXT, :banip_root, true, nil] end mp_admin_show_commands(entries, :moderation, 360) @mp_admin_window.set_handler(:kick_root, method(:mp_admin_open_kick_targets)) @mp_admin_window.set_handler(:ban_root, method(:mp_admin_open_ban_targets)) @mp_admin_window.set_handler(:banip_root, method(:mp_admin_open_banip_targets)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end def mp_admin_open_teleportation_menu return mp_admin_open_root unless WebSocket.admin_owner_active? entries = [ [MPAdminMenu::ROOT_TELEPORT_TEXT, :owner_teleport_root, true, nil], [MPAdminMenu::ROOT_TELEPORT_TO_TEXT, :owner_teleport_to_root, true, nil], [MPAdminMenu::ROOT_FREEZE_TEXT, :owner_freeze_root, true, nil], [MPAdminMenu.speed_label, :owner_speed, true, nil], ] mp_admin_show_commands(entries, :teleportation, 360) @mp_admin_window.set_handler(:owner_teleport_root, method(:mp_admin_open_owner_teleport_targets)) @mp_admin_window.set_handler(:owner_teleport_to_root, method(:mp_admin_open_owner_teleport_to_targets)) @mp_admin_window.set_handler(:owner_freeze_root, method(:mp_admin_open_owner_freeze_targets)) @mp_admin_window.set_handler(:owner_speed, method(:mp_admin_cycle_speed)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end # Measurements is a top-level submenu, and the shared menu prepends "Назад". def mp_admin_open_measurements_menu return mp_admin_open_root unless WebSocket.admin_owner_active? entries = [[MPAdminMenu.coordinates_label, :coordinates_toggle, true, nil]] mp_admin_show_commands(entries, :measurements, 360) @mp_admin_window.set_handler(:coordinates_toggle, method(:mp_admin_toggle_coordinates)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end def mp_admin_toggle_coordinates return mp_admin_open_root unless WebSocket.admin_owner_active? MPMeasurements.toggle if defined?(MPMeasurements) mp_admin_open_measurements_menu rescue mp_admin_open_root end def mp_admin_cycle_speed WebSocket.admin_cycle_speed if WebSocket.admin_owner_active? mp_admin_open_teleportation_menu rescue mp_admin_open_root end def mp_admin_toggle_ghost return mp_admin_open_root unless WebSocket.admin_can_ghost? WebSocket.admin_toggle_ghost mp_admin_open_root rescue mp_admin_dispose_menu end def mp_admin_open_kick_targets return mp_admin_open_root unless WebSocket.admin_can_kick? mp_admin_open_target_menu(:kick) end def mp_admin_open_ban_targets return mp_admin_open_moderation_menu unless WebSocket.admin_can_ban? mp_admin_open_target_menu(:ban) end def mp_admin_open_banip_targets return mp_admin_open_moderation_menu unless WebSocket.admin_can_ban? mp_admin_open_target_menu(:banip) end def mp_admin_open_owner_skills return mp_admin_open_root unless WebSocket.admin_owner_active? entries = WebSocket.admin_owner_skill_entries.map do |sym, name| [name.to_s, :owner_skill_pick, true, sym] end entries << [MPAdminMenu.mega_strength_label, :owner_mega_strength, true, nil] mp_admin_show_commands(entries, :owner_skills, 410) @mp_admin_window.set_handler(:owner_skill_pick, method(:mp_admin_pick_owner_skill)) @mp_admin_window.set_handler(:owner_mega_strength, method(:mp_admin_toggle_owner_mega_strength)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_open_root)) rescue mp_admin_open_root end def mp_admin_toggle_owner_mega_strength return mp_admin_dispose_menu unless WebSocket.admin_owner_active? WebSocket.admin_toggle_mega_strength mp_admin_open_root rescue mp_admin_dispose_menu end def mp_admin_pick_owner_skill return unless @mp_admin_window && WebSocket.admin_owner_active? sym = @mp_admin_window.current_ext return unless WebSocket::OWNER_SKILLS.key?(sym) mp_admin_open_target_menu(:owner_skill_select) # mp_admin_show_commands destroys transient menu state. Save it AFTER. @mp_admin_pending_skill = sym rescue mp_admin_open_root end def mp_admin_cast_owner_skill WebSocket.admin_owner_skill_cast if WebSocket.admin_owner_active? mp_admin_dispose_menu rescue mp_admin_dispose_menu end def mp_admin_clear_owner_skill WebSocket.admin_owner_skill_clear if WebSocket.admin_owner_active? mp_admin_open_root rescue mp_admin_dispose_menu end def mp_admin_open_owner_teleport_targets mp_admin_open_target_menu(:owner_teleport) end def mp_admin_open_owner_teleport_to_targets mp_admin_open_target_menu(:owner_teleport_to) end def mp_admin_toggle_owner_see_hidden WebSocket.admin_toggle_see_hidden mp_admin_open_root rescue mp_admin_dispose_menu end def mp_admin_open_owner_freeze_targets mp_admin_open_target_menu(:owner_freeze) end def mp_admin_toggle_owner_noclip WebSocket.admin_toggle_noclip mp_admin_open_root rescue mp_admin_dispose_menu end def mp_admin_open_target_menu(action_kind) WebSocket.admin_request_targets_refresh commands = [] begin WebSocket.admin_online_targets.each do |pid, label| if action_kind.to_sym == :owner_freeze && WebSocket.admin_target_frozen?(pid) label = label.to_s + " [заморожен]" end commands << [label.to_s, :target_pick, true, pid.to_i] end rescue commands = [] end commands = [[MPAdminMenu::EMPTY_TEXT, :noop, false, nil]] if commands.empty? mp_admin_show_commands(commands, action_kind.to_sym, 360) # mp_admin_show_commands calls mp_admin_dispose_menu, so assign AFTER it. @mp_admin_pending_action = action_kind.to_sym @mp_admin_window.set_handler(:target_pick, method(:mp_admin_apply_target)) back_handler = case action_kind.to_sym when :owner_skill_select then method(:mp_admin_open_owner_skills) when :kick, :ban, :banip then method(:mp_admin_open_moderation_menu) when :owner_teleport, :owner_teleport_to, :owner_freeze then method(:mp_admin_open_teleportation_menu) else method(:mp_admin_open_root) end @mp_admin_window.set_handler(:cancel, back_handler) rescue mp_admin_open_root end def mp_admin_apply_style return unless @mp_admin_window && WebSocket.admin_can_style? && WebSocket.admin_role_received? WebSocket.admin_change_style(@mp_admin_window.current_ext.to_i) mp_admin_dispose_menu rescue mp_admin_dispose_menu end def mp_admin_apply_emoji return unless @mp_admin_window && WebSocket.admin_can_style? && WebSocket.admin_role_received? side = @mp_admin_pending_emoji_side.to_s return unless side == "front" || side == "back" WebSocket.admin_change_emoji(side, @mp_admin_window.current_ext.to_s) mp_admin_dispose_menu rescue mp_admin_dispose_menu end def mp_admin_apply_target return unless @mp_admin_window return mp_admin_dispose_menu unless WebSocket.connected? && WebSocket.admin_role_received? pid = @mp_admin_window.current_ext.to_i return if pid <= 0 case @mp_admin_pending_action when :kick WebSocket.admin_kick_player(pid) when :ban WebSocket.admin_ban_player(pid) when :banip WebSocket.admin_ban_ip_player(pid) when :owner_teleport WebSocket.admin_teleport_player_here(pid) when :owner_teleport_to WebSocket.admin_teleport_to_player(pid) when :owner_freeze WebSocket.admin_toggle_player_freeze(pid) when :owner_skill_select WebSocket.admin_owner_skill_prepare(@mp_admin_pending_skill, pid) end mp_admin_dispose_menu rescue mp_admin_dispose_menu end def mp_admin_back case @mp_admin_state when :root then mp_admin_dispose_menu when :emoji_pick then mp_admin_open_emoji_side_menu when :owner_skill_select then mp_admin_open_owner_skills when :kick, :ban, :banip then mp_admin_open_moderation_menu when :owner_teleport, :owner_teleport_to, :owner_freeze then mp_admin_open_teleportation_menu when :measurements then mp_admin_open_root else mp_admin_open_root end rescue mp_admin_dispose_menu end def mp_admin_show_commands(commands, state_name, width = 320, font_name = nil) # Root shows only actions allowed by the current server-provided role. # Back always occupies the first cell, even in long player/emoji lists. # It remains reachable without scrolling through every entry. unless state_name == :root commands = [["Назад", :mp_back, true, nil]] + commands end mp_admin_dispose_menu @mp_admin_state = state_name @mp_admin_shown_role = WebSocket.admin_role_name @mp_admin_window = Window_MPAdminIconGrid.new(commands, state_name) @mp_admin_window.set_handler(:mp_back, method(:mp_admin_back)) @mp_admin_window.set_handler(:cancel, method(:mp_admin_back)) @mp_admin_window.activate @mp_admin_window.select(state_name == :root || commands.size == 1 ? 0 : 1) rescue mp_admin_dispose_menu end end # Server-authorized OWNER tools. The flags are runtime-only and reset on # disconnect, so they never leak into a save or an offline game. class Game_Player # Do not alter the per-turn overmap logic; this scales local tile interpolation. unless method_defined?(:mp_owner_tools_original_distance_per_frame) alias mp_owner_tools_original_distance_per_frame distance_per_frame def distance_per_frame(*args, &block) normal = mp_owner_tools_original_distance_per_frame(*args, &block) multiplier = (defined?(WebSocket) && WebSocket.respond_to?(:admin_speed_multiplier)) ? WebSocket.admin_speed_multiplier : 1.0 normal * multiplier rescue mp_owner_tools_original_distance_per_frame(*args, &block) end end unless method_defined?(:mp_owner_tools_base_debug_through) alias mp_owner_tools_base_debug_through debug_through? def debug_through? return true if defined?(WebSocket) && WebSocket.respond_to?(:admin_noclip_enabled?) && WebSocket.admin_noclip_enabled? mp_owner_tools_base_debug_through end end # The vanilla overmap hook has its own passability check and teleports the # player to LastOverMapX/Y even when debug_through? deliberately allows the # tile. Skip only that anti-stuck correction while server-authorized OWNER # noclip is active. Game_CharacterBase#passable? still checks map.valid? # before debug_through?, so noclip cannot move outside the real map bounds. if method_defined?(:overmap_anti_stuck) && !method_defined?(:mp_owner_tools_base_overmap_anti_stuck) alias mp_owner_tools_base_overmap_anti_stuck overmap_anti_stuck def overmap_anti_stuck if defined?(WebSocket) && WebSocket.respond_to?(:admin_noclip_enabled?) && WebSocket.admin_noclip_enabled? return end mp_owner_tools_base_overmap_anti_stuck end end unless method_defined?(:mp_owner_tools_base_movable) alias mp_owner_tools_base_movable movable? def movable?(*args, &block) if defined?(WebSocket) && WebSocket.respond_to?(:admin_frozen_by_owner?) && WebSocket.admin_frozen_by_owner? return false end mp_owner_tools_base_movable(*args, &block) end end end # OWNER cannot be stunned. Scope all hooks to the locally controlled actor; # remote avatars and NPCs must keep their ordinary stun mechanics. module MPOwnerStunImmunity def self.protects?(actor) return false if actor.nil? return false unless defined?(WebSocket) && WebSocket.respond_to?(:admin_owner_active?) return false unless WebSocket.admin_owner_active? return false unless defined?($game_player) && $game_player && $game_player.respond_to?(:actor) actor.equal?($game_player.actor) rescue false end def self.stun_state?(state) s = state.to_s.downcase s == "stun" || s.include?("stun_") || s.include?("_stun") || s.include?("оглуш") || s == "dazed" rescue false end end if defined?(Game_Actor) class Game_Actor if method_defined?(:apply_stun_effect) && !method_defined?(:mp_owner_original_apply_stun_effect) alias mp_owner_original_apply_stun_effect apply_stun_effect def apply_stun_effect(*args, &block) return if MPOwnerStunImmunity.protects?(self) mp_owner_original_apply_stun_effect(*args, &block) end end # force_shock/fap/cuming/pindown call setup_* AFTER super(apply_stun). # OWNER blocks apply_stun but setup_* still ran → CharsetAnimation stuck forever # (cancel_stun_effect only clears when action_state == :stun). if method_defined?(:apply_shock_effect) && !method_defined?(:mp_owner_original_apply_shock_effect) alias mp_owner_original_apply_shock_effect apply_shock_effect def apply_shock_effect(*args, &block) return if MPOwnerStunImmunity.protects?(self) mp_owner_original_apply_shock_effect(*args, &block) end end if method_defined?(:apply_fap_effect) && !method_defined?(:mp_owner_original_apply_fap_effect) alias mp_owner_original_apply_fap_effect apply_fap_effect def apply_fap_effect(*args, &block) return if MPOwnerStunImmunity.protects?(self) mp_owner_original_apply_fap_effect(*args, &block) end end if method_defined?(:apply_cuming_effect) && !method_defined?(:mp_owner_original_apply_cuming_effect) alias mp_owner_original_apply_cuming_effect apply_cuming_effect def apply_cuming_effect(*args, &block) return if MPOwnerStunImmunity.protects?(self) mp_owner_original_apply_cuming_effect(*args, &block) end end if method_defined?(:apply_pindown_effect) && !method_defined?(:mp_owner_original_apply_pindown_effect) alias mp_owner_original_apply_pindown_effect apply_pindown_effect def apply_pindown_effect(*args, &block) return if MPOwnerStunImmunity.protects?(self) mp_owner_original_apply_pindown_effect(*args, &block) end end if method_defined?(:set_action_state) && !method_defined?(:mp_owner_original_set_action_state) alias mp_owner_original_set_action_state set_action_state def set_action_state(state, *args, &block) return if MPOwnerStunImmunity.protects?(self) && MPOwnerStunImmunity.stun_state?(state) mp_owner_original_set_action_state(state, *args, &block) end end if method_defined?(:add_state) && !method_defined?(:mp_owner_original_add_state) alias mp_owner_original_add_state add_state def add_state(state, *args, &block) return if MPOwnerStunImmunity.protects?(self) && MPOwnerStunImmunity.stun_state?(state) mp_owner_original_add_state(state, *args, &block) end end if method_defined?(:update_stun) && !method_defined?(:mp_owner_original_update_stun) alias mp_owner_original_update_stun update_stun def update_stun(*args, &block) if MPOwnerStunImmunity.protects?(self) && @action_state == :stun begin remove_stun_effect if respond_to?(:remove_stun_effect) rescue end begin set_action_state(:none, true) rescue @action_state = :none end return end mp_owner_original_update_stun(*args, &block) end end end end # --------------------------------------------------------------------------- # Admin grid input capture: never move, attack, cast, interact, or open the # ordinary game menu while navigating / (including every submenu). # Keep character/scene updates alive so multiplayer and animations continue. # --------------------------------------------------------------------------- if defined?(Game_Player) class Game_Player if method_defined?(:update_movement) && !method_defined?(:mp_admin_capture_orig_update_movement) alias mp_admin_capture_orig_update_movement update_movement def update_movement(*args, &block) return if MPAdminMenu.captures_gameplay_input? mp_admin_capture_orig_update_movement(*args, &block) end end if method_defined?(:update_skill_input) && !method_defined?(:mp_admin_capture_orig_update_skill_input) alias mp_admin_capture_orig_update_skill_input update_skill_input def update_skill_input(*args, &block) return if MPAdminMenu.captures_gameplay_input? mp_admin_capture_orig_update_skill_input(*args, &block) end end if method_defined?(:update_nonmoving) && !method_defined?(:mp_admin_capture_orig_update_nonmoving) alias mp_admin_capture_orig_update_nonmoving update_nonmoving def update_nonmoving(*args, &block) return if MPAdminMenu.captures_gameplay_input? mp_admin_capture_orig_update_nonmoving(*args, &block) end end end end if defined?(Scene_Map) class Scene_Map if method_defined?(:update_call_menu) && !method_defined?(:mp_admin_capture_orig_update_call_menu) alias mp_admin_capture_orig_update_call_menu update_call_menu def update_call_menu(*args, &block) return if mp_admin_menu_active? mp_admin_capture_orig_update_call_menu(*args, &block) end end end end # Mask keyboard/controller reads only between the menu's window update and # gameplay simulation. Window_Selectable keeps receiving full navigation input. if defined?(Input) class << Input [:press?, :trigger?, :repeat?, :double?, :skillKeyPressed?, :checkHoldCancel?, :checkHoldAllFunctionKeys?].each do |key_method| original = ("mp_admin_menu_real_" + key_method.to_s).to_sym next unless method_defined?(key_method) && !method_defined?(original) alias_method original, key_method define_method(key_method) do |*args, &block| if defined?(MPAdminMenu) && MPAdminMenu.gameplay_keys_locked? false else __send__(original, *args, &block) end end end [:dir4, :dir8, :numpad_dir4, :numpad_dir8].each do |key_method| original = ("mp_admin_menu_real_" + key_method.to_s).to_sym next unless method_defined?(key_method) && !method_defined?(original) alias_method original, key_method define_method(key_method) do |*args, &block| if defined?(MPAdminMenu) && MPAdminMenu.gameplay_keys_locked? 0 else __send__(original, *args, &block) end end end end end # OWNER teleport is a two-phase transaction. Update it only on the map scene. class Scene_Map < Scene_Base unless method_defined?(:mp_admin_owner_teleport_original_update) alias mp_admin_owner_teleport_original_update update def update(*args, &block) result = mp_admin_owner_teleport_original_update(*args, &block) WebSocket.admin_teleport_to_tick if defined?(WebSocket) result end end end