514 lines
16 KiB
Ruby
514 lines
16 KiB
Ruby
#==============================================================================
|
|||
|
|
# CheatConfig
|
||
|
|
#------------------------------------------------------------------------------
|
||
|
|
# Handles config loading, saving, and tracking of hotkeys, variables,
|
||
|
|
# and per-module enable/disable states.
|
||
|
|
#==============================================================================
|
||
|
|
|
||
|
|
class FrameworkConfig
|
||
|
|
attr_reader :mod_ini
|
||
|
|
attr_reader :key_ini
|
||
|
|
attr_reader :var_ini
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Legacy Global Variable Fixes
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Fixes for stale "Global Variables" entries in globals.ini carried over from an older config.
|
||
|
|
# Applied once at startup, before anything else reads globals.ini.
|
||
|
|
# {type: :value, key:, from:, to:} - value "from" -> "to"
|
||
|
|
# {type: :rename, from:, to:} - key "from" -> "to"
|
||
|
|
# {type: :delete, key:} - drop the key
|
||
|
|
LEGACY_GLOBAL_FIXES = [
|
||
|
|
{type: :value, key: "Prevent Discard", from: "true", to: "1"},
|
||
|
|
]
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Initialize and load INI files
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def initialize(config_dir)
|
||
|
|
Dir.mkdir(config_dir) unless Dir.exist?(config_dir)
|
||
|
|
@key_ini = load_or_create(File.join(config_dir, "hotkeys.ini"))
|
||
|
|
@var_ini = load_or_create(File.join(config_dir, "globals.ini"))
|
||
|
|
@mod_ini = load_or_create(File.join(config_dir, "modules.ini"))
|
||
|
|
migrate_legacy_globals
|
||
|
|
end
|
||
|
|
|
||
|
|
def migrate_legacy_globals
|
||
|
|
section = "Global Variables"
|
||
|
|
return unless @var_ini.has_section?(section)
|
||
|
|
data = @var_ini[section]
|
||
|
|
changed = false
|
||
|
|
LEGACY_GLOBAL_FIXES.each do |fix|
|
||
|
|
case fix[:type]
|
||
|
|
when :value
|
||
|
|
next unless data.key?(fix[:key]) && data[fix[:key]].to_s == fix[:from]
|
||
|
|
data[fix[:key]] = fix[:to]
|
||
|
|
changed = true
|
||
|
|
when :rename
|
||
|
|
next unless data.key?(fix[:from])
|
||
|
|
data[fix[:to]] = data[fix[:from]] unless data.key?(fix[:to])
|
||
|
|
data.delete(fix[:from])
|
||
|
|
changed = true
|
||
|
|
when :delete
|
||
|
|
next unless data.key?(fix[:key])
|
||
|
|
data.delete(fix[:key])
|
||
|
|
changed = true
|
||
|
|
end
|
||
|
|
end
|
||
|
|
@var_ini.write if changed
|
||
|
|
end
|
||
|
|
|
||
|
|
def load_or_create(path)
|
||
|
|
ini = IniFile.load(path)
|
||
|
|
unless ini
|
||
|
|
ini = IniFile.new(filename: path)
|
||
|
|
ini.write
|
||
|
|
end
|
||
|
|
return ini
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Read / write helpers
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def read(section, key, default = "", ini)
|
||
|
|
ini.read if ini.respond_to?(:read)
|
||
|
|
if ini.has_section?(section) && ini[section].key?(key)
|
||
|
|
ini[section][key]
|
||
|
|
else
|
||
|
|
default
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def write(section, key, value, ini)
|
||
|
|
ini[section] ||= {}
|
||
|
|
ini[section][key] = value
|
||
|
|
ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Mod override handlers
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def get_enabled(key, default = true)
|
||
|
|
val = read("Module Load Overrides", key, default, @mod_ini).to_s.downcase
|
||
|
|
return true if ["true", "1", "yes"].include?(val)
|
||
|
|
return false if ["false", "0", "no"].include?(val)
|
||
|
|
default
|
||
|
|
end
|
||
|
|
|
||
|
|
def get_load_order(key, default = 999)
|
||
|
|
val = read("Load Order Overrides", key, default, @mod_ini)
|
||
|
|
val.to_i.nonzero? || default
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Global variables handlers
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def read_global(key, default)
|
||
|
|
value = read("Global Variables", key, default, @var_ini)
|
||
|
|
Object.instance_eval("$#{sanitize_key(key)} = #{format_value(value)}")
|
||
|
|
value
|
||
|
|
end
|
||
|
|
|
||
|
|
def write_global(key, value)
|
||
|
|
write("Global Variables", key, value, @var_ini)
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Hotkey handling
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def init_hotkeys
|
||
|
|
compare_hotkeys_to_ini
|
||
|
|
clear_conflicting_hotkeys
|
||
|
|
save_hotkeys_to_ini
|
||
|
|
build_hotkey_map
|
||
|
|
end
|
||
|
|
|
||
|
|
# Self-clears any of our own hotkeys sitting on a key HotkeyReserved flags.
|
||
|
|
# The menu toggle's key never appears in hotkey_defs (see Input::SYM_KEYS[:CF_CHEAT_MENU], scripts/Menu.rb).
|
||
|
|
def clear_conflicting_hotkeys
|
||
|
|
$framework.hotkey_defs.each do |full_key, data|
|
||
|
|
next unless data[:key]
|
||
|
|
next unless HotkeyReserved.info_for_combo(data[:key])
|
||
|
|
data[:key] = "NONE"
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# Drops any "GROUP.Key" mapping whose command no longer exists (renamed, moved to a different
|
||
|
|
# key, or removed entirely) instead of reviving it as a phantom hotkey_defs entry - safer than
|
||
|
|
# guessing what it should remap to. $framework.commands is fully populated by init_modules,
|
||
|
|
# which always runs before this (see __init__.rb), so it's a complete, reliable source of truth.
|
||
|
|
def prune_orphaned_hotkeys(section)
|
||
|
|
@key_ini[section].keys.each do |full_key|
|
||
|
|
group, key = full_key.split('.', 2)
|
||
|
|
# split always yields a String key, but commands can be registered with either
|
||
|
|
# a String or Symbol key (see Controls.rb#resolve_record) - check both.
|
||
|
|
dict = group && key && $framework.commands[group.to_sym]
|
||
|
|
next if dict && (dict.key?(key) || dict.key?(key.to_sym))
|
||
|
|
@key_ini[section].delete(full_key)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def compare_hotkeys_to_ini
|
||
|
|
section = "Cheat Hotkeys"
|
||
|
|
return unless @key_ini.has_section?(section)
|
||
|
|
|
||
|
|
prune_orphaned_hotkeys(section)
|
||
|
|
|
||
|
|
@key_ini[section].each do |full_key, value|
|
||
|
|
next if value.nil?
|
||
|
|
|
||
|
|
# IniFile auto-typecasts a bare digit ("6") into an Integer on read -
|
||
|
|
# a real possibility now that digit keys are assignable hotkeys.
|
||
|
|
value = value.to_s.strip
|
||
|
|
next if value.empty?
|
||
|
|
|
||
|
|
# Handle NONE → disable
|
||
|
|
if value.upcase == "NONE"
|
||
|
|
if $framework.hotkey_defs.key?(full_key)
|
||
|
|
$framework.hotkey_defs[full_key][:key] = "NONE"
|
||
|
|
else
|
||
|
|
$framework.hotkey_defs[full_key] = { key: "NONE", sound: nil }
|
||
|
|
end
|
||
|
|
next
|
||
|
|
end
|
||
|
|
|
||
|
|
# Otherwise, override or add
|
||
|
|
if $framework.hotkey_defs.key?(full_key)
|
||
|
|
$framework.hotkey_defs[full_key][:key] = value
|
||
|
|
else
|
||
|
|
$framework.hotkey_defs[full_key] = { key: value, sound: nil }
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def save_hotkeys_to_ini
|
||
|
|
section = "Cheat Hotkeys"
|
||
|
|
@key_ini[section] ||= {}
|
||
|
|
|
||
|
|
$framework.hotkey_defs.each do |full_key, data|
|
||
|
|
key_name = "#{full_key}"
|
||
|
|
value = data[:key] || "NONE"
|
||
|
|
@key_ini[section][key_name] = value
|
||
|
|
end
|
||
|
|
|
||
|
|
@key_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
def build_hotkey_map
|
||
|
|
$framework.hotkeys = Hash.new { |h, k| h[k] = [] }
|
||
|
|
|
||
|
|
$framework.hotkey_defs.each do |full_key, data|
|
||
|
|
next if data[:key].nil? || data[:key].upcase == "NONE"
|
||
|
|
|
||
|
|
mods, base = parse_hotkey(data[:key])
|
||
|
|
key_const = base
|
||
|
|
|
||
|
|
group, key = full_key.split('.', 2)
|
||
|
|
$framework.hotkeys[key_const] << {
|
||
|
|
group: group.to_sym,
|
||
|
|
key: key,
|
||
|
|
mods: mods,
|
||
|
|
sound: data[:sound]
|
||
|
|
}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Main Menu Toggle key (portable backup)
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Input::SYM_KEYS[:CF_CHEAT_MENU]/$LonaINI (the game's own Key Binds menu)
|
||
|
|
def init_menu_toggle_key
|
||
|
|
if menu_toggle_key_configured_in_game?
|
||
|
|
Input::SYM_KEYS[:CF_CHEAT_MENU] = (0..2).map do |i|
|
||
|
|
val = $LonaINI["Keyboard"]["CF_CHEAT_MENU_#{i}"]
|
||
|
|
(val && val != 0 && val != "0") ? (Input::KEYMAP[val.to_s.to_sym] || 0) : 0
|
||
|
|
end
|
||
|
|
live = FrameworkUtils.current_menu_toggle_key
|
||
|
|
save_menu_toggle_key(live) if live
|
||
|
|
else
|
||
|
|
saved_key = @key_ini["Main Menu Toggle"]["key"]
|
||
|
|
saved_key = "F9" if saved_key.nil? || saved_key.to_s.strip.empty?
|
||
|
|
apply_menu_toggle_key(saved_key)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def menu_toggle_key_configured_in_game?
|
||
|
|
(0..2).any? do |i|
|
||
|
|
val = $LonaINI["Keyboard"]["CF_CHEAT_MENU_#{i}"]
|
||
|
|
val && val != 0 && val != "0"
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def apply_menu_toggle_key(key_str)
|
||
|
|
key_sym = HotkeySymbols.symbol_for(key_str) || key_str.to_sym
|
||
|
|
Input::SYM_KEYS[:CF_CHEAT_MENU] = [Input::KEYMAP[key_sym] || Input::KEYMAP[:F9], 0, 0]
|
||
|
|
save_menu_toggle_key(key_str)
|
||
|
|
save_menu_toggle_key_to_game_ini
|
||
|
|
end
|
||
|
|
|
||
|
|
# hook_vanilla_keybind_menu puts :CF_CHEAT_MENU in InputUtils.keyList, so MouseSupport's
|
||
|
|
# frequent InputUtils.load_input_settings calls reload it from $LonaINI - write it there too
|
||
|
|
# or our default gets overwritten back to unbound the next time the mouse toggles.
|
||
|
|
def save_menu_toggle_key_to_game_ini
|
||
|
|
(0..2).each do |i|
|
||
|
|
code = Input::SYM_KEYS[:CF_CHEAT_MENU][i]
|
||
|
|
$LonaINI["Keyboard"]["CF_CHEAT_MENU_#{i}"] = code != 0 ? InputUtils.reverse_key_map[code].to_s : "0"
|
||
|
|
end
|
||
|
|
$LonaINI.save
|
||
|
|
end
|
||
|
|
|
||
|
|
def save_menu_toggle_key(key_str)
|
||
|
|
@key_ini["Main Menu Toggle"]["key"] = key_str
|
||
|
|
@key_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
# Catches rebinds made through the vanilla Key Binds menu.
|
||
|
|
def sync_menu_toggle_key
|
||
|
|
live = FrameworkUtils.current_menu_toggle_key
|
||
|
|
return unless live
|
||
|
|
return if live == @key_ini["Main Menu Toggle"]["key"]
|
||
|
|
save_menu_toggle_key(live)
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Menu order handling
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def init_order
|
||
|
|
compare_order_to_ini
|
||
|
|
save_order_to_ini
|
||
|
|
end
|
||
|
|
|
||
|
|
def compare_order_to_ini
|
||
|
|
section = "Menu Order Overrides"
|
||
|
|
return unless @mod_ini.has_section?(section)
|
||
|
|
|
||
|
|
@mod_ini[section].each do |full_key, value|
|
||
|
|
next if value.nil? || value.to_s.strip.empty?
|
||
|
|
|
||
|
|
group_key, cmd_key = full_key.split('.', 2)
|
||
|
|
next unless group_key && cmd_key
|
||
|
|
|
||
|
|
dict = $framework.commands[group_key.to_sym]
|
||
|
|
next unless dict
|
||
|
|
|
||
|
|
record = dict[cmd_key] || dict[cmd_key.to_sym]
|
||
|
|
next unless record
|
||
|
|
|
||
|
|
record[:order] = value.to_i
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def save_order_to_ini
|
||
|
|
section = "Menu Order Overrides"
|
||
|
|
@mod_ini[section] ||= {}
|
||
|
|
|
||
|
|
$framework.commands.each do |group, dict|
|
||
|
|
next unless dict.is_a?(Hash)
|
||
|
|
|
||
|
|
dict.each do |key, record|
|
||
|
|
next unless record.is_a?(Hash) && record.key?(:order)
|
||
|
|
@mod_ini[section]["#{group}.#{key}"] = record[:order]
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@mod_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
# Wipes all custom menu ordering back to each command's registered default.
|
||
|
|
def reset_menu_order
|
||
|
|
$framework.commands.each do |_group, dict|
|
||
|
|
next unless dict.is_a?(Hash)
|
||
|
|
dict.each do |_key, record|
|
||
|
|
next unless record.is_a?(Hash) && record.key?(:default_order)
|
||
|
|
record[:order] = record[:default_order]
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@mod_ini.delete_section("Menu Order Overrides")
|
||
|
|
@mod_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
# In-memory session for Edit Menu Order's Save/Discard confirm flow.
|
||
|
|
def start_menu_order_session
|
||
|
|
snapshot = {}
|
||
|
|
$framework.commands.each do |group, dict|
|
||
|
|
next unless dict.is_a?(Hash)
|
||
|
|
dict.each do |key, record|
|
||
|
|
next unless record.is_a?(Hash) && record.key?(:order)
|
||
|
|
snapshot["#{group}.#{key}"] = record[:order]
|
||
|
|
end
|
||
|
|
end
|
||
|
|
$framework.menu_order_snapshot = snapshot
|
||
|
|
$framework.menu_order_dirty = false
|
||
|
|
end
|
||
|
|
|
||
|
|
def mark_menu_order_dirty
|
||
|
|
$framework.menu_order_dirty = true
|
||
|
|
end
|
||
|
|
|
||
|
|
def menu_order_dirty?
|
||
|
|
!!$framework.menu_order_dirty
|
||
|
|
end
|
||
|
|
|
||
|
|
def revert_menu_order_session
|
||
|
|
return unless $framework.menu_order_snapshot
|
||
|
|
$framework.menu_order_snapshot.each do |full_key, order|
|
||
|
|
group_key, cmd_key = full_key.split('.', 2)
|
||
|
|
dict = $framework.commands[group_key.to_sym]
|
||
|
|
next unless dict
|
||
|
|
record = dict[cmd_key] || dict[cmd_key.to_sym]
|
||
|
|
next unless record
|
||
|
|
record[:order] = order
|
||
|
|
end
|
||
|
|
clear_menu_order_session
|
||
|
|
end
|
||
|
|
|
||
|
|
def clear_menu_order_session
|
||
|
|
$framework.menu_order_snapshot = nil
|
||
|
|
$framework.menu_order_dirty = false
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Local/Global override handling (Config > Edit Globals)
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Unlike menu order/hotkeys, these two actively prune stale entries.
|
||
|
|
def init_force_modes
|
||
|
|
compare_force_modes_to_ini
|
||
|
|
save_force_modes_to_ini
|
||
|
|
end
|
||
|
|
|
||
|
|
def compare_force_modes_to_ini
|
||
|
|
section = "Force Mode Overrides"
|
||
|
|
return unless @mod_ini.has_section?(section)
|
||
|
|
|
||
|
|
@mod_ini[section].each do |full_key, value|
|
||
|
|
next if value.nil? || value.to_s.strip.empty?
|
||
|
|
next unless global_override_eligible?(full_key)
|
||
|
|
|
||
|
|
$framework.force_modes[full_key] = coerce_ini_value(value) == true
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def save_force_modes_to_ini
|
||
|
|
section = "Force Mode Overrides"
|
||
|
|
@mod_ini.delete_section(section)
|
||
|
|
@mod_ini[section] = {}
|
||
|
|
|
||
|
|
$framework.force_modes.each do |full_key, mode|
|
||
|
|
@mod_ini[section][full_key] = mode
|
||
|
|
end
|
||
|
|
|
||
|
|
@mod_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
def init_force_values
|
||
|
|
compare_force_values_to_ini
|
||
|
|
save_force_values_to_ini
|
||
|
|
end
|
||
|
|
|
||
|
|
def compare_force_values_to_ini
|
||
|
|
section = "Force Value Overrides"
|
||
|
|
return unless @mod_ini.has_section?(section)
|
||
|
|
|
||
|
|
@mod_ini[section].each do |full_key, value|
|
||
|
|
next if value.nil? || value.to_s.strip.empty?
|
||
|
|
next unless global_override_eligible?(full_key)
|
||
|
|
|
||
|
|
$framework.force_values[full_key] = coerce_ini_value(value)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def save_force_values_to_ini
|
||
|
|
section = "Force Value Overrides"
|
||
|
|
@mod_ini.delete_section(section)
|
||
|
|
@mod_ini[section] = {}
|
||
|
|
|
||
|
|
$framework.force_values.each do |full_key, value|
|
||
|
|
@mod_ini[section][full_key] = value
|
||
|
|
end
|
||
|
|
|
||
|
|
@mod_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
# True if "GROUP.CommandKey" still resolves to a global:-flagged command.
|
||
|
|
def global_override_eligible?(full_key)
|
||
|
|
group_key, cmd_key = full_key.split('.', 2)
|
||
|
|
return false unless group_key && cmd_key
|
||
|
|
|
||
|
|
dict = $framework.commands[group_key.to_sym]
|
||
|
|
return false unless dict
|
||
|
|
|
||
|
|
record = dict[cmd_key] || dict[cmd_key.to_sym]
|
||
|
|
!!(record && !record[:global].nil?)
|
||
|
|
end
|
||
|
|
|
||
|
|
# IniFile typecasts numbers on its own; this adds true/false.
|
||
|
|
def coerce_ini_value(value)
|
||
|
|
return value unless value.is_a?(String)
|
||
|
|
return true if value.downcase == "true"
|
||
|
|
return false if value.downcase == "false"
|
||
|
|
value
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Full reset (Config > Reset All Settings)
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
def reset_all_settings
|
||
|
|
@mod_ini.delete_section("Module Load Overrides")
|
||
|
|
@mod_ini.delete_section("Load Order Overrides")
|
||
|
|
@mod_ini.write
|
||
|
|
|
||
|
|
@var_ini.delete_section("Global Variables")
|
||
|
|
@var_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
def reset_hotkeys_live
|
||
|
|
$framework.hotkey_defs = $framework.hotkey_defaults.each_with_object({}) { |(k, v), h| h[k] = v.dup }
|
||
|
|
clear_conflicting_hotkeys
|
||
|
|
@key_ini.delete_section("Cheat Hotkeys")
|
||
|
|
save_hotkeys_to_ini
|
||
|
|
build_hotkey_map
|
||
|
|
|
||
|
|
apply_menu_toggle_key("F9")
|
||
|
|
end
|
||
|
|
|
||
|
|
def reset_force_overrides
|
||
|
|
$framework.force_modes.clear
|
||
|
|
$framework.force_values.clear
|
||
|
|
@mod_ini.delete_section("Force Mode Overrides")
|
||
|
|
@mod_ini.delete_section("Force Value Overrides")
|
||
|
|
@mod_ini.write
|
||
|
|
end
|
||
|
|
|
||
|
|
def parse_hotkey(hotkey_str)
|
||
|
|
parts = hotkey_str.split('+').map(&:strip)
|
||
|
|
mods = []
|
||
|
|
base = nil
|
||
|
|
|
||
|
|
parts.each do |p|
|
||
|
|
case p.downcase
|
||
|
|
when "shift" then mods << :SHIFT
|
||
|
|
when "ctrl", "control" then mods << :CTRL
|
||
|
|
when "alt" then mods << :ALT
|
||
|
|
else
|
||
|
|
base = HotkeySymbols.symbol_for(p) || p.upcase.to_sym
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
[mods, base]
|
||
|
|
end
|
||
|
|
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
# Special handlers
|
||
|
|
#--------------------------------------------------------------------------
|
||
|
|
private
|
||
|
|
|
||
|
|
def sanitize_key(key)
|
||
|
|
key.to_s.strip.gsub(/\s+/, "_").downcase
|
||
|
|
end
|
||
|
|
|
||
|
|
def format_value(value)
|
||
|
|
return "\"#{value}\"" if value.is_a?(String) && value !~ /^\d+$/
|
||
|
|
value
|
||
|
|
end
|
||
|
|
end
|