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

717 lines
25 KiB
Ruby

module WebSocket
# Networking receive/parse
#--------------------------------------------------------------------------
def self.receive_packets
data = respond_to?(:transport_receive) ? transport_receive : RECEIVE.call
if data == :closed
integrity_debug('parser_transport_closed', 'receive_packets got :closed') if respond_to?(:integrity_debug)
begin
if defined?(MPConnectStatus) && MPConnectStatus.respond_to?(:socket_error!)
MPConnectStatus.socket_error!
else
disconnect
end
rescue
end
return
end
return if data.nil? || data.empty?
begin
MPConnectStatus.note_recv if defined?(MPConnectStatus)
rescue
end
@recv_partial = "" if !instance_variable_defined?(:@recv_partial) || @recv_partial.nil?
chunk = data.to_s
begin
chunk.force_encoding("UTF-8")
rescue
end
@recv_partial << chunk
if !@integrity_attested && @recv_partial.bytesize > 0 && @recv_partial.index("\n").nil?
integrity_debug_once('parser_buffer_pending', "bytes=#{@recv_partial.bytesize}") if respond_to?(:integrity_debug_once)
end
while (nl = @recv_partial.index("\n"))
line = @recv_partial.slice!(0, nl + 1)
line = line.to_s.strip
next if line.empty?
if line == 'version_ok' || line.start_with?('sync_wait:integrity:v2:', 'secure_ready:integrity:v2:', 'auth_error:', 'sync_wait:integrity_attestation', 'sync_ok:integrity_attestation')
descriptor = if line.start_with?('sync_wait:integrity:v2:', 'secure_ready:integrity:v2:')
"challenge_packet length=#{line.length}"
else
line
end
integrity_debug('parser_dispatch', descriptor) if respond_to?(:integrity_debug)
end
parse(line)
end
end
def self.parse(msg)
if respond_to?(:deferable_world_packet?) && deferable_world_packet?(msg) &&
respond_to?(:map_packet_ready?) && !map_packet_ready?
defer_world_packet(msg) if respond_to?(:defer_world_packet)
return
end
if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
map_scoped_prefixes = [
'join:', 'pos:', 'quit:', 'interact:',
'drop:', 'pickup:', 'drop_remove:',
'event_', 'npc_', 'pwo_', 'skill_cast:', 'effect_area:'
]
return if map_scoped_prefixes.any? { |prefix| msg.to_s.start_with?(prefix) }
end
case msg
# --- CAPABILITIES ---
when /^(?:secure_ready|sync_wait):integrity:v2:([0-9a-fA-F]{64})$/
challenge = $1.to_s.downcase
if @integrity_challenge.to_s != challenge
@integrity_challenge = challenge
@integrity_attested = false
@integrity_server_accepted = false
end
integrity_debug('parser_challenge', "challenge_id=#{challenge[0, 8]} version_ok=#{!!@version_ok}") if respond_to?(:integrity_debug)
if @version_ok
send_my_nickname(false) if respond_to?(:send_my_nickname)
end
when /^cap:(.+)/
parts = msg.split(":")
if parts.size >= 3
@caps[parts[1]] = parts[2].to_i
@worldsync = (@caps["worldsync"] == 1)
@proto = (@caps["proto"] == 1)
@anticheat = (@caps["anticheat"] == 1)
end
when /^version_need:(.*)/
@required_version = $1.to_s.strip
@required_version = SERVER_GAME_VERSION if @required_version == ""
send_line("version:#{@required_version}")
when /^version_ok$/
@version_ok = true
integrity_debug('parser_version_ok', "had_challenge=#{!@integrity_challenge.to_s.empty?} attested=#{!!@integrity_attested}") if respond_to?(:integrity_debug)
begin
resend_state_after_version_ok if respond_to?(:resend_state_after_version_ok)
rescue => e
puts "[NET] version_ok resend failed: #{e.class}: #{e.message}"
end
when /^sync_ok:integrity_attestation$/
unless @integrity_server_accepted
@integrity_server_accepted = true
integrity_debug('parser_integrity_accepted', 'server_ack_received') if respond_to?(:integrity_debug)
send_my_nickname(true) if respond_to?(:send_my_nickname)
end
when /^version_bad:(.*)/
need = $1.to_s.strip
@version_ok = false
puts "[NET] version_bad need=#{need}"
begin
msgbox("Нужна версия #{need}")
rescue
end
when /^auth_error:(.*)/
reason = $1.to_s.strip
integrity_debug('parser_auth_error', "reason=#{reason.inspect} attested=#{!!@integrity_attested} version_ok=#{!!@version_ok}") if respond_to?(:integrity_debug)
if reason.start_with?('integrity_') || reason == 'nickname_mismatch'
integrity_debug('parser_native_abort', "reason=#{reason.inspect}") if respond_to?(:integrity_debug)
LonaIntegrity.abort! if defined?(LonaIntegrity) && LonaIntegrity.respond_to?(:abort!)
return
end
text =
case reason
when "wrong_password"
"Пароль неверный."
when "password_unset"
"Игрок уже зарегистрирован. Новый пароль через вход привязать нельзя."
when "profile_race_lost"
"Игрок уже зарегистрирован. Войдите с его паролем."
when "empty_nick"
"Введите имя игрока."
when "db_error"
"Ошибка базы данных авторизации."
when "integrity_changed", "integrity_missing", "integrity_unavailable"
"Проверка целостности обнаружила изменённые или запрещённые файлы."
else
"Ошибка авторизации"
end
if reason == "wrong_password" || reason.start_with?("integrity_")
begin
if defined?(MPWrongPasswordTeller) && MPWrongPasswordTeller.respond_to?(:show!)
return if MPWrongPasswordTeller.show!(reason)
end
rescue => e
puts "[AUTH-TELLER] Handler failed: #{e.class}: #{e.message}" rescue nil
end
end
begin
$mp_pending_auth_error_text = text
$mp_pending_auth_error_lock_frames = 15
rescue
end
begin
disconnect if respond_to?(:disconnect)
rescue
end
begin
$titleCreateActorReq = true if defined?($titleCreateActorReq)
SceneManager.goto(Scene_MapTitle) if defined?(SceneManager) && defined?(Scene_MapTitle)
rescue
end
when /^server_kick:(integrity_changed|integrity_missing|integrity_unavailable)$/
reason = $1.to_s
integrity_debug('parser_server_kick', "reason=#{reason.inspect}") if respond_to?(:integrity_debug)
begin
if defined?(MPWrongPasswordTeller) && MPWrongPasswordTeller.respond_to?(:show!)
return if MPWrongPasswordTeller.show!(reason)
end
rescue => e
puts "[INTEGRITY] Teller handler failed: #{e.class}: #{e.message}" rescue nil
end
when /^auth_ok:(.*)/
reason = $1.to_s.strip
text =
case reason
when "created"
"Игрок зарегистрирован."
when "accepted"
""
when "mysql_disabled"
"Вход выполнен без облачной базы."
else
""
end
unless text.to_s.strip == ""
begin
if defined?(System_NotificationOverlay)
if System_NotificationOverlay.respond_to?(:success)
System_NotificationOverlay.success(text)
elsif System_NotificationOverlay.respond_to?(:notify)
System_NotificationOverlay.notify(text, :success)
end
end
rescue
end
end
when /^bootstrap_mode:(.*)$/
mode = $1.to_s.strip
begin
set_bootstrap_mode(mode) if respond_to?(:set_bootstrap_mode)
rescue => e
puts "[BOOTSTRAP] mode failed: #{e.class}: #{e.message}"
end
when /^bootstrap_map:(-?\d+)$/
begin
set_bootstrap_map($1.to_i) if respond_to?(:set_bootstrap_map)
rescue => e
puts "[BOOTSTRAP] map failed: #{e.class}: #{e.message}"
end
when /^bootstrap_pos:(-?\d+):(-?\d+):(-?\d+)$/
begin
set_bootstrap_position($1.to_i, $2.to_i, $3.to_i) if respond_to?(:set_bootstrap_position)
rescue => e
puts "[BOOTSTRAP] position failed: #{e.class}: #{e.message}"
end
when /^sync_unlocked$/
@live_sync_unlocked = true
when /^bootstrap_body:(.*)$/
begin
queue_bootstrap_body($1.to_s) if respond_to?(:queue_bootstrap_body)
rescue => e
puts "[BOOTSTRAP] body parse failed: #{e.class}: #{e.message}"
end
when /^bootstrap_state:/
parts = msg.split(":", 20)
if parts.size >= 15
begin
payload = {
"map_id" => parts[1].to_i,
"x" => parts[2].to_i,
"y" => parts[3].to_i,
"direction" => parts[4].to_i,
"level" => parts[5].to_i,
"gold" => parts[6].to_i,
"hp" => parts[7].to_i,
"max_hp" => parts[8].to_i,
"sta" => parts[9].to_i,
"sat" => parts[10].to_i,
"items_blob" => parts[11].to_s,
"weapons_blob" => parts[12].to_s,
"armors_blob" => parts[13].to_s,
"equips_blob" => parts[14].to_s,
"skills_csv" => (parts.size >= 16 ? parts[15].to_s : ""),
"stats_blob" => (parts.size >= 17 ? parts[16].to_s : ""),
"states_blob" => (parts.size >= 18 ? parts[17].to_s : ""),
"player_blob" => (parts.size >= 19 ? parts[18].to_s : ""),
"bank_blob" => (parts.size >= 20 ? parts[19].to_s : ""),
"bank_blob_present" => (parts.size >= 20)
}
payload["items"] = bootstrap_parse_blob(payload["items_blob"], true) if respond_to?(:bootstrap_parse_blob)
payload["weapons"] = bootstrap_parse_blob(payload["weapons_blob"], true) if respond_to?(:bootstrap_parse_blob)
payload["armors"] = bootstrap_parse_blob(payload["armors_blob"], true) if respond_to?(:bootstrap_parse_blob)
payload["equips"] = bootstrap_parse_blob(payload["equips_blob"], false) if respond_to?(:bootstrap_parse_blob)
payload["stats_json"] = bootstrap_decode_json_blob(payload["stats_blob"]) if respond_to?(:bootstrap_decode_json_blob) && payload["stats_blob"].to_s != ""
payload["states_json"] = bootstrap_decode_json_blob(payload["states_blob"]) if respond_to?(:bootstrap_decode_json_blob) && payload["states_blob"].to_s != ""
payload["player_json"] = bootstrap_decode_json_blob(payload["player_blob"]) if respond_to?(:bootstrap_decode_json_blob) && payload["player_blob"].to_s != ""
if respond_to?(:bootstrap_decode_json_blob) && payload["bank_blob"].to_s != ""
payload["bank_json"] = bootstrap_decode_json_blob(payload["bank_blob"])
elsif payload["bank_blob_present"] && respond_to?(:bootstrap_empty_bank_json)
payload["bank_json"] = bootstrap_empty_bank_json
end
begin
puts "[BOOTSTRAP] recv map=#{payload['map_id']} x=#{payload['x']} y=#{payload['y']} dir=#{payload['direction']}"
rescue
end
begin
set_bootstrap_mode('load') if respond_to?(:set_bootstrap_mode) && @bootstrap_mode.to_s.strip == ''
rescue
end
queue_bootstrap_state(payload) if respond_to?(:queue_bootstrap_state)
rescue => e
puts "[BOOTSTRAP] parse failed: #{e.class}: #{e.message}"
end
end
when /^bank_state(?::(.*))?$/
begin
blob = $1.to_s
apply_bank_state_packet(blob) if respond_to?(:apply_bank_state_packet)
rescue => e
puts "[BANK] state failed: #{e.class}: #{e.message}"
end
when /^vip_room_ok(?::(.*))?$/
begin
vip_mark_handshake_ready if respond_to?(:vip_mark_handshake_ready)
rescue
end
when /^vip_room_wait:(.*)$/
begin
@vip_handshake_pending = true if instance_variable_defined?(:@vip_handshake_pending)
rescue
end
when /^vip_room_reject:(.*)$/
reason = $1.to_s.strip
text =
case reason
when "code_not_found"
"VIP code not found."
when "vip_only_create"
"Only VIP can create a new VIP code."
when "code_required", "code_empty"
"Enter VIP code."
when "room_closing", "owner_left"
"VIP room is closing."
else
"VIP access denied."
end
begin
vip_mark_handshake_failed(text) if respond_to?(:vip_mark_handshake_failed)
rescue
end
when /^vip_room_closing:(\d+)$/
begin
sec = $1.to_i
if defined?(System_NotificationOverlay) && System_NotificationOverlay.respond_to?(:error)
System_NotificationOverlay.error("VIP owner left. Server will close in #{sec}s.")
end
rescue
end
# --- KEEPALIVE ---
when /^ping:(\d+)/
send_line("pong:#{$1}")
begin
@last_client_pong_at = Time.now.to_f
rescue
@last_client_pong_at = 0.0
end
when /^map_master:(\d+)/
@map_master_id = $1.to_i
@world_event_packets_ready = (@map_master_id > 0)
@remote_static_npc_types = {}
@static_npc_compatibility = {}
begin
if map_master?
@need_master_sync = true
@event_cache = {}
@event_ai_cache = {}
@event_target_cache = {}
@event_dead_cache = {}
@event_type_cache = {}
@map_event_state_cache = {}
end
rescue
end
# --- PORTAL SYNC (random map portals) ---
when /^portal_set:(\d+):(\d+):(\d+):(\d+):(\d+):(\d+):(\d+)/
src_map = $1.to_i
ev_id = $2.to_i
dst_map = $3.to_i
dx = $4.to_i
dy = $5.to_i
dir = $6.to_i
fade = $7.to_i
begin
portal_set_from_server(src_map, ev_id, dst_map, dx, dy, dir, fade)
rescue
end
when /^portal_clear:(\d+):(\d+)/
src_map = $1.to_i
ev_id = $2.to_i
begin
portal_clear_from_server(src_map, ev_id)
rescue
end
# --- DROPS ---
when /^drop:(\d+):(item|weapon|armor):(\d+):(\d+):(\d+):(\d+):(-?\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
drop_id = $1.to_i
item_type = $2
item_id = $3.to_i
x = $4.to_i
y = $5.to_i
qty = $6.to_i
dropped_by = $7.to_i
create_map_drop(drop_id, item_type, item_id, x, y, qty, dropped_by)
when /^pickup:(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
remove_map_drop($1.to_i)
when /^drop_remove:(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
remove_map_drop($1.to_i)
when /^pickup_ok:(\d+):(item|weapon|armor):(\d+):(\d+)/
return unless @worldsync
drop_id = $1.to_i
item_type = $2
item_id = $3.to_i
qty = $4.to_i
apply_pickup_ok(drop_id, item_type, item_id, qty)
puts "[DROP] pickup_ok drop_id=#{drop_id} #{item_type}##{item_id} x#{qty}"
when /^pickup_reject:(.+)/
msg = $1.to_s
puts "[DROP] pickup rejected: #{msg}"
# Снять in-flight: по drop_id если есть в тексте, иначе все — чтобы не залипнуть
if msg =~ /^(\d+)/
clear_pickup_inflight($1.to_i)
else
clear_pickup_inflight
end
when /^drop_reject:(.+)/
puts "[DROP] drop rejected: #{$1}"
# --- EVENTS / NPC ---
when /^event_create:(\d+):(\d+):(\d+):(\d+):(.*)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
template_id = $2.to_i
x = $3.to_i
y = $4.to_i
name = $5.to_s
create_remote_event(server_eid, template_id, x, y, name)
when /^npc_type:(\d+):(.*)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
t = unesc($2.to_s)
apply_npc_type(server_eid, t)
when /^npc_owner:(\d+):(-?\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
owner_id = $2.to_i
set_npc_owner(server_eid, owner_id)
when /^event_ai:(\d+):(.+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
return if respond_to?(:incoming_event_move_allowed?) && !incoming_event_move_allowed?(server_eid)
parts = msg.split(":")
ai = parts[2..-1]
apply_event_ai(server_eid, ai)
when /^npc_hit:(\d+):(\d+):(-?\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
attacker_id = $1.to_i
eid = $2.to_i
delta = $3.to_i
apply_npc_hit(attacker_id, eid, delta) if npc_owned_by_me?(eid)
when /^event_move:(\d+):(\d+):(\d+):(\d+):(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
return if respond_to?(:incoming_event_move_allowed?) && !incoming_event_move_allowed?(server_eid)
x = $2.to_i
y = $3.to_i
dir = $4.to_i
pat = $5.to_i
move_remote_event(server_eid, x, y, dir, pat)
when /^event_state:(\d+):([^:]+):(.*)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
stype = $2.to_s
value = $3.to_s
return if respond_to?(:incoming_event_state_allowed?) && !incoming_event_state_allowed?(server_eid, stype)
apply_event_state(server_eid, stype, value)
when /^event_anim:(\d+):(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
return if respond_to?(:incoming_event_state_allowed?) && !incoming_event_state_allowed?(server_eid, 'anim_id')
anim_id = $2.to_i
play_event_animation(server_eid, anim_id)
when /^event_erase:(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
return if respond_to?(:incoming_event_lifecycle_allowed?) && !incoming_event_lifecycle_allowed?(server_eid)
erase_event(server_eid)
when /^event_respawn:(\d+):(\d+):(\d+)/
return unless @worldsync
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
server_eid = $1.to_i
return if respond_to?(:incoming_event_lifecycle_allowed?) && !incoming_event_lifecycle_allowed?(server_eid)
respawn_event(server_eid, $2.to_i, $3.to_i)
# --- SKILLS / EFFECTS ---
when /^skill_cast:(\d+):(-?\d+):(\d+):(\d+):(-?\d+)/
return unless @worldsync
skill_id = $1.to_i
caster_id = $2.to_i
tx = $3.to_i
ty = $4.to_i
target_id = $5.to_i
show_skill_cast(skill_id, caster_id, tx, ty, target_id)
when /^effect_area:([^:]+):(\d+):(\d+):(\d+):(.*)/
return unless @worldsync
eff_type = $1
x = $2.to_i
y = $3.to_i
radius = $4.to_i
params = $5.to_s
show_area_effect(eff_type, x, y, radius, params)
# --- VARS / SWITCHES ---
when /^sync_var:/
return unless @worldsync
parts = msg.split(":", 4)
if parts.size >= 4
apply_sync_var(parts[1], parts[2], parts[3])
end
when /^sync_switch:(\d+):(\d+)/
return unless @worldsync
apply_sync_switch($1.to_i, $2.to_i)
when /^sync_reject:(.+)/
puts "[SYNC] rejected: #{$1}"
# --- ACTION-STATE (19_deistvia) ---
when /^deistvia:(\d+):([^:]+):([^:]+):(.*)$/
player_id = $1.to_i
action_id = unesc($2.to_s)
phase = unesc($3.to_s)
payload = unesc($4.to_s)
begin
handle_remote_deistvia(player_id, action_id, phase, payload) if respond_to?(:handle_remote_deistvia)
rescue
end
# --- EXISTING ---
# --- NICKNAMES ---
when /^nick:(\d+):(.*)/
pid = $1.to_i
nick = unesc($2.to_s)
set_nickname(pid, nick)
when /^welcome:(\d+)/
@my_id = $1.to_i
puts "[NET] Ваш сетевой ID: #{@my_id}"
# keep own nickname locally + push to server
set_nickname(@my_id, local_nickname)
send_my_nickname(true)
when /^time:([0-9]+(?:\.[0-9]+)?):(\d+):(\d+)/
server_total = $1.to_f
server_date = $2.to_i
steps = $3.to_i
@time_initialized = true
apply_time_snapshot(server_total, server_date, steps)
@last_time_log_date = server_date
@last_time_log_steps = steps
when /^join:(\d+)/
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
id = $1.to_i
puts "[NET] Игрок #{id} присоединился к карте"
create_remote_player(id)
when /^pos:(\d+):(\d+):(\d+):(\d+)(?::([^:]+))?/
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
id, x, y, d = $1.to_i, $2.to_i, $3.to_i, $4.to_i
movement = ($5.nil? ? nil : $5.to_s)
move_remote_player(id, x, y, d, movement)
when /^quit:(\d+)/
return if respond_to?(:world_event_packets_ready?) && !world_event_packets_ready?
id = $1.to_i
puts "[NET] Игрок #{id} покинул карту"
remove_remote_player(id)
@nicknames.delete(id)
when /^interact:(\d+):(\d+):(\d+)/
player_id, x, y = $1.to_i, $2.to_i, $3.to_i
show_interaction_effect(x, y)
when /^pwo_hit:(\d+):(\d+):(\d+):(\d+):(\d+):(\d+)/
attacker_id = $1.to_i
target_id = $2.to_i
object_id = $3.to_i
x, y = $4.to_i, $5.to_i
damage = $6.to_i
if (!@my_id.nil? && target_id == @my_id) || (x == $game_player.x && y == $game_player.y)
handle_being_attacked(attacker_id, damage)
else
begin
if @players && @players[target_id]
@players[target_id].animation_id = 12
end
rescue
end
begin
if respond_to?(:get_remote_player_object)
ev = get_remote_player_object(object_id)
ev.animation_id = 12 if ev && ev.respond_to?(:animation_id=)
end
rescue
end
end
when /^attack:(\d+):(\d+):(\d+):(\d+):(\d+)/
attacker_id = $1.to_i
target_id = $2.to_i
x, y = $3.to_i, $4.to_i
damage = $5.to_i
if (!@my_id.nil? && target_id == @my_id) || (x == $game_player.x && y == $game_player.y)
handle_being_attacked(attacker_id, damage)
else
show_attack_effect(attacker_id, x, y)
end
end
end
#--------------------------------------------------------------------------
end
if defined?(Scene_MapTitle)
class Scene_MapTitle < Scene_Map
unless method_defined?(:mp_auth_error_notice_start)
alias mp_auth_error_notice_start start
end
unless method_defined?(:mp_auth_error_notice_update)
alias mp_auth_error_notice_update update
end
def start
mp_auth_error_notice_start
text = nil
lock_frames = 0
begin
text = $mp_pending_auth_error_text
$mp_pending_auth_error_text = nil
lock_frames = $mp_pending_auth_error_lock_frames.to_i
$mp_pending_auth_error_lock_frames = 0
rescue
text = nil
lock_frames = 0
end
if lock_frames > 0
begin
@mp_auth_error_input_unlock_at = (Graphics.frame_count rescue 0) + lock_frames
@menu.active = false if @menu && @menu.respond_to?(:active=)
rescue
@mp_auth_error_input_unlock_at = nil
end
else
@mp_auth_error_input_unlock_at = nil
end
return if text.to_s.strip == ""
begin
if defined?(System_NotificationOverlay) && System_NotificationOverlay.respond_to?(:error)
System_NotificationOverlay.error(text)
end
rescue
end
end
def update
if @mp_auth_error_input_unlock_at
begin
now = Graphics.frame_count rescue 0
if now >= @mp_auth_error_input_unlock_at
@menu.active = true if @menu && @menu.respond_to?(:active=)
@mp_auth_error_input_unlock_at = nil
else
@menu.active = false if @menu && @menu.respond_to?(:active=)
end
rescue
@mp_auth_error_input_unlock_at = nil
end
end
mp_auth_error_notice_update
end
end
end