2321 lines
80 KiB
Ruby
2321 lines
80 KiB
Ruby
# 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
|