Files
LonaRPG-Online-Games/ModScripts/multiplayer/95_admin_menu.rb
T

2321 lines
80 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# 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:<id> 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