#=============================================================================== # Menu Defaults #------------------------------------------------------------------------------ # Handles default commands structure and interface #=============================================================================== module MenuFramework module ScrollArrows ARROW_SRC_DOWN = Rect.new(0, 0, 19, 12) ARROW_WIDTH = 12 ARROW_HEIGHT = 8 ARROW_Z = 200 JIGGLE_PERIOD = 60 ARROW_UP_Y_OFFSET = 4 # nudge down to re-center against the smaller glyphs ARROW_DOWN_Y_OFFSET = 0 # Cap the cluster at 180px so it doesn't stretch to fill wide windows. def scroll_arrow_span [contents_width, 180].min end # Override to 1 for a single centered arrow instead of a 3-wide cluster. def scroll_arrow_tile_count 3 end def create_scroll_arrows source = Cache.system("Menu/08Items/item_arrow") down_glyph = Bitmap.new(ARROW_WIDTH, ARROW_HEIGHT) down_glyph.stretch_blt(down_glyph.rect, source, ARROW_SRC_DOWN) @scroll_arrow_down = build_scroll_arrow(down_glyph) @scroll_arrow_up = build_scroll_arrow(flip_glyph(down_glyph)) update_scroll_arrows end # Row-by-row reversal instead of a negative sprite zoom (zoom_y = -1 # silently failed to render at all) - keeps up/down pixel-identical. def flip_glyph(glyph) flipped = Bitmap.new(glyph.width, glyph.height) glyph.height.times do |row| flipped.blt(0, glyph.height - 1 - row, glyph, Rect.new(0, row, glyph.width, 1)) end flipped end def build_scroll_arrow(glyph) span = scroll_arrow_span sprite = Sprite.new sprite.z = ARROW_Z sprite.bitmap = Bitmap.new(span, ARROW_HEIGHT) scroll_arrow_tile_positions(span).each do |dest_x| sprite.bitmap.blt(dest_x, 0, glyph, glyph.rect) end sprite.x = self.x + padding + (contents_width - span) / 2 sprite.visible = false sprite end def scroll_arrow_tile_positions(span) count = scroll_arrow_tile_count return [span / 2 - ARROW_WIDTH / 2] if count <= 1 (0...count).map { |i| i * (span - ARROW_WIDTH) / (count - 1) } end def update_scroll_arrows return unless @scroll_arrow_up && @scroll_arrow_down more_rows = page_row_max > 0 && row_max > page_row_max @scroll_arrow_up.visible = more_rows && top_row > 0 @scroll_arrow_down.visible = more_rows && bottom_row < row_max - 1 jiggle = Graphics.frame_count % JIGGLE_PERIOD / (JIGGLE_PERIOD / 3) @scroll_arrow_up.y = self.y + ARROW_UP_Y_OFFSET - jiggle if @scroll_arrow_up.visible @scroll_arrow_down.y = self.y + height - padding_bottom + ARROW_DOWN_Y_OFFSET + jiggle if @scroll_arrow_down.visible end def dispose_scroll_arrows @scroll_arrow_up.dispose if @scroll_arrow_up @scroll_arrow_down.dispose if @scroll_arrow_down end def update super update_scroll_arrows end def dispose dispose_scroll_arrows super end end end #============================================================================== # Action Window Module #============================================================================== module Action_Window_Defaults include MenuFramework::ScrollArrows attr_accessor :dictionary #-------------------------------------------------------------------------- # Initialize #------------------------------------------------------------------------- def initialize super(160, 0) @dictionary = nil @hotkey_capture_mode = false clear_edit create_scroll_arrows end def clear_edit @editing = false @editing_this = nil @editing_number = nil @edit_value = 0 @edit_list = [] @edit_index = 0 @edit_min = 0 @edit_max = 0 end #-------------------------------------------------------------------------- # Window Structure #-------------------------------------------------------------------------- def window_width; return Graphics.width - 160; end def window_height; return Graphics.height - 120; end #-------------------------------------------------------------------------- # Command Initialization #-------------------------------------------------------------------------- def commands_from_group return unless @dictionary FrameworkUtils.sorted_commands(@dictionary).each do |key, record| next if record[:hide].is_a?(Proc) ? record[:hide].call : record[:hide] enable = record[:enable].is_a?(Proc) ? record[:enable].call : record[:enable] add_command( #$framework.txt(record[:label]), added alternative proc handling for testing: record[:label].is_a?(Proc) ? record[:label].call : $framework.txt(record[:label]), :run_default_command, enable, record[:key] ) end end #-------------------------------------------------------------------------- # Command Definition #-------------------------------------------------------------------------- def run_default_command return if @hotkey_capture_mode # assigning a hotkey, not activating the row key = current_ext record = @dictionary[key] return unless record case record[:type] when :edit_num, :edit_list if @editing save_editing(key) else start_editing(key) end refresh else record[:action].call if record[:action] FrameworkUtils.mark_restart_needed(record) SndLib.sys_ok refresh end end def start_editing(key) record = @dictionary[key] return unless record @editing = true @editing_this = key @editing_number = record[:type] == :edit_num @edit_value = record[:state].call rescue 0 if @editing_number @edit_min = record[:min].is_a?(Proc) ? record[:min].call : record[:min] || 0 @edit_max = record[:max].is_a?(Proc) ? record[:max].call : record[:max] || 999 else @edit_list = record[:list] || [] @edit_index = @edit_list.index { |i| i[:key] == record[:state].call rescue 0 } || 0 @edit_value = @edit_list[@edit_index][:label] end end def save_editing(key) record = @dictionary[key] return unless record save_value = if record[:type] == :edit_list save_value = @edit_list[@edit_index][:key] else save_value = @edit_value end if record[:action].arity == 1 #Handle Value (v) entry. record[:action].call(save_value) elsif record[:action].arity == 2 #Handle Key/Value pair - mostly for saving to config. record[:action].call(record[:key],save_value) else #Run the command as-is if nothing required. instance_exec(&record[:action]) end FrameworkUtils.mark_restart_needed(record) SndLib.sys_ok clear_edit end #-------------------------------------------------------------------------- # Draw Setup #-------------------------------------------------------------------------- def draw_item(index) MenuFramework.force_font(contents) if contents rect = item_rect_for_text(index) contents.clear_rect(rect) key = @list[index][:ext] name = command_name(index) enabled = command_enabled?(index) record = @dictionary && key ? @dictionary[key] : nil value = nil right = "" # --- Determine base color --- color = if record && record[:color] c = record[:color] val = c.respond_to?(:call) ? c.call : c val.is_a?(Numeric) ? text_color(val) : val else normal_color end # --- Determine what to display on the right side --- case record && record[:type] when :info right = record[:state].call rescue "" color = text_color(8) when :toggle value = record[:state].call rescue false right = value ? "[#{$framework.txt("menu:cheat_toggle/on")}]" : "[#{$framework.txt("menu:cheat_toggle/off")}]" when :edit_num value = record[:state].call rescue 0 right = value.to_s when :edit_list list = record[:list] || [] value = record[:state].call rescue 0 item = list.find { |i| i[:key] == value } right = item ? item[:label] : value.to_s when :scene right = ">>>" end # --- Adjust display name and color --- hotkey_tag = FrameworkUtils.hotkey_tag_for(@dictionary, key) # edit_list/edit_num rows cannot be assigned a hotkey, so no conflict with restart tag. restart_tag = hotkey_tag ? nil : (FrameworkUtils.restart_mismatch?(record) ? "[#{$framework.txt("menu:commands_status/restart_needed")}]" : nil) tag = hotkey_tag || restart_tag tagged_name = tag ? "#{name} #{tag}" : name display_name = enabled ? tagged_name : "#{tagged_name} (#{$framework.txt("menu:commands_status/locked")})" color = enabled ? color : text_color(8) if @editing && key == @editing_this color = text_color(16) right = @edit_value.to_s end if @hotkey_capture_mode && index == self.index color = text_color(16) end # --- Draw --- change_color(color) draw_text(rect, display_name, 0) draw_text(rect, right, 2) if right && !right.to_s.empty? end #-------------------------------------------------------------------------- # Control Overrides #-------------------------------------------------------------------------- def cursor_left(wrap = false) if @editing SndLib.play_cursor number = @editing_number ? edit_key_multiply : 1 modify_variable(-number) else cursor_pageup end end def cursor_right(wrap = false) if @editing SndLib.play_cursor number = @editing_number ? edit_key_multiply : 1 modify_variable(number) else cursor_pagedown end end def cursor_up(wrap = false) super unless @editing refresh_help_window end def cursor_down(wrap = false) super unless @editing refresh_help_window end def refresh_help_window SceneManager.scene.refresh_help_window if SceneManager.scene.respond_to?(:refresh_help_window) end def override_help_window_text(text) SceneManager.scene.override_help_window_text(text) if SceneManager.scene.respond_to?(:override_help_window_text) end def process_cancel if @hotkey_capture_mode exit_hotkey_capture elsif @editing clear_edit refresh else super end end #-------------------------------------------------------------------------- # Hotkey Capture #-------------------------------------------------------------------------- # LETTER_C arms the row, Shift/Ctrl/Alt+key assigns (F-key or letter/digit/ # punctuation, see HotkeySymbols), Delete/Backspace clears, LETTER_C/Cancel # disarms. Any command can hold a hotkey via hotkey_defs. FKEY_SYMBOLS = (1..12).map { |n| :"F#{n}" } # :edit_num/:edit_list actions need a value argument, which a bare keypress can't supply. CAPTURABLE_TYPES = [:toggle, :action, :scene] def update super return unless active if @hotkey_capture_mode update_hotkey_capture elsif !@editing && current_ext && Input.trigger?(:LETTER_C) if capturable_row? enter_hotkey_capture else SndLib.sys_buzzer end end end def capturable_row? return false unless @dictionary && current_ext record = @dictionary[current_ext] record && CAPTURABLE_TYPES.include?(record[:type]) end # Cursor movement is frozen on the armed row while capturing. def process_cursor_move return if @hotkey_capture_mode super end def enter_hotkey_capture @hotkey_capture_mode = true $framework.hotkey_capture_active = true SndLib.play_cursor refresh_help_window refresh end # Backs out without assigning anything - the only time "C to cancel" is # accurate, since assign/clear below leave on their own once committed. def exit_hotkey_capture SndLib.play_cursor leave_hotkey_capture end def leave_hotkey_capture @hotkey_capture_mode = false $framework.hotkey_capture_active = false refresh_help_window refresh end def update_hotkey_capture if Input.trigger?(:LETTER_C) exit_hotkey_capture return end if Input.trigger?(:BACK) || Input.trigger?(:DELETE) clear_current_hotkey return end (FKEY_SYMBOLS + HotkeySymbols.symbols).each do |key_sym| next unless Input.trigger?(key_sym) assign_current_hotkey(key_sym) return end end def current_hotkey_full_key key = current_ext return nil unless key group = FrameworkUtils.group_for_dictionary(@dictionary) return nil unless group "#{group}.#{key}" end def assign_current_hotkey(key_sym) full_key = current_hotkey_full_key return unless full_key if HotkeyReserved.info_for(key_sym.to_s) SndLib.sys_buzzer # reserved (Main Menu Key and F10 always, F5/F6 while RolePlay-S is active) - refuse, modifiers don't help return end mods = [] mods << "Shift" if Input.press?(:SHIFT) mods << "Ctrl" if Input.press?(:CTRL) mods << "Alt" if Input.press?(:ALT) key_str = (mods + [HotkeySymbols.name_for(key_sym) || key_sym.to_s]).join("+") if $framework.hotkey_defs[full_key] $framework.hotkey_defs[full_key][:key] = key_str else $framework.hotkey_defs[full_key] = { key: key_str, sound: nil } end $framework.ini.save_hotkeys_to_ini $framework.ini.build_hotkey_map # live immediately - no restart needed SndLib.sys_ok leave_hotkey_capture end def clear_current_hotkey full_key = current_hotkey_full_key return unless full_key return unless $framework.hotkey_defs[full_key] $framework.hotkey_defs[full_key][:key] = "NONE" $framework.ini.save_hotkeys_to_ini $framework.ini.build_hotkey_map SndLib.sys_cancel leave_hotkey_capture end def edit_key_multiply multi = 1 multi *= 10 if Input.press?(Input::KEYMAP[:SHIFT]) multi *= 100 if Input.press?(Input::KEYMAP[:CONTROL]) multi end def modify_variable(change) if @editing_number @edit_value += change @edit_value = [[@edit_value, @edit_min].max, @edit_max].min else return unless @edit_list && @edit_list.is_a?(Array) @edit_index = (@edit_index + change) % @edit_list.size # cycles properly @edit_value = @edit_list[@edit_index][:label] end refresh refresh_help_window if live_help_command? end # True if this row's help1-4 is a Proc, so it needs redrawing mid-edit. def live_help_command? record = @dictionary && @editing_this ? @dictionary[@editing_this] : nil record && [:help1, :help2, :help3, :help4].any? { |k| record[k].is_a?(Proc) } end end #============================================================================== # Scene Defaults #============================================================================== module Scene_Defaults attr_accessor :menu_symbol attr_reader :action_window # Online live-map under cheat UI (same host as ESC/storage). if defined?(MPLiveEscMenu) && defined?(MPLiveEscMenu::SpritesetHost) include MPLiveEscMenu::SpritesetHost end CF_LIVE_DIM_Z = 50 CF_LIVE_WINDOW_Z = 2100 def mp_cf_live_online? defined?(MPLiveEscMenu) && MPLiveEscMenu.respond_to?(:online?) && MPLiveEscMenu.online? rescue false end # Soft dim ABOVE the map spriteset, BELOW cheat windows (default Window zā‰ˆ100 # would sit under SCENE_BASE_Z=2000 dim — that was the blackout bug). def mp_cf_create_live_dim @background_sprite = Sprite.new @background_sprite.z = CF_LIVE_DIM_Z w = [(Graphics.width rescue 640).to_i, 1].max h = [(Graphics.height rescue 360).to_i, 1].max bmp = Bitmap.new(w, h) bmp.fill_rect(0, 0, w, h, Color.new(0, 0, 0, 80)) @background_sprite.bitmap = bmp @background_sprite.opacity = 255 @mp_live_owned_bg_sprite_bitmap = true rescue @background_sprite = nil end def create_background if mp_cf_live_online? mp_cf_create_live_dim return end super rescue super end def dispose_background begin if @mp_live_owned_bg_sprite_bitmap if @background_sprite begin bmp = @background_sprite.bitmap @background_sprite.bitmap = nil bmp.dispose if bmp && !bmp.disposed? rescue end begin @background_sprite.dispose unless (@background_sprite.disposed? rescue true) rescue end end @background_sprite = nil @mp_live_owned_bg_sprite_bitmap = false return end rescue end super end def mp_cf_raise_window_z z = CF_LIVE_WINDOW_Z [@command_window, @help_window, @action_window].each do |win| next unless win begin win.z = z if win.respond_to?(:z=) rescue end end rescue end def start super create_command_window create_help_window create_action_window @help_window_text1 = nil @help_window_text2 = nil @help_window_text3 = nil @help_window_text4 = nil begin if mp_cf_live_online? && respond_to?(:mp_live_setup_spriteset) mp_live_setup_spriteset mp_cf_raise_window_z end rescue end end def update begin if mp_cf_live_online? && @mp_live_spriteset && respond_to?(:mp_live_tick_world) if respond_to?(:mp_live_tick_world_or_exit_on_transfer) return if mp_live_tick_world_or_exit_on_transfer else mp_live_tick_world end end rescue end super end def terminate begin (@mp_cf_orphan_windows || []).each do |win| next unless win win.dispose unless (win.disposed? rescue false) end rescue end @mp_cf_orphan_windows = nil begin mp_live_dispose_spriteset if respond_to?(:mp_live_dispose_spriteset) rescue end super end def create_action_window wx = @command_window.width ww = Graphics.width - wx wh = Graphics.height - @help_window.height @action_window = Window_Base.new(wx, 0, ww, wh) mp_cf_raise_window_z if mp_cf_live_online? end def override_action_window @command_window.deactivate # Replacing @action_window without dispose leaked the blank right panel # onto the map after leaving CheatFramework. begin old = @action_window if old && !(old.disposed? rescue false) old.dispose end rescue begin @mp_cf_orphan_windows ||= [] @mp_cf_orphan_windows << @action_window if @action_window rescue end end @action_window = @window.new @action_window.dictionary = @dictionary @action_window.set_handler(:cancel, method(:return_action_scene)) @action_window.set_handler(:run_default_command, method(:default_command)) mp_cf_raise_window_z if mp_cf_live_online? restore_action_window_state refresh_help_window end def default_command @action_window.activate @action_window.dictionary = @dictionary save_action_window_state @action_window.run_default_command refresh_help_window end def return_action_scene save_action_window_state return_scene end def save_action_window_state menu = @menu_symbol $framework.menu_stack.push({ menu: menu, symbol: @action_window.current_ext, index: @action_window.index }) end def save_action_window_state menu = @menu_symbol symbol = @action_window.current_ext rescue nil index = @action_window.index rescue 0 $framework.menu_stack.push({ menu: menu, symbol: @action_window.current_ext, index: @action_window.index }) end def restore_action_window_state menu = @menu_symbol return unless menu && $framework.menu_stack && @action_window.active entry = $framework.menu_stack.reverse.find { |e| e[:menu] == menu } if entry list = @action_window.instance_variable_get(:@list) idx = list.index { |cmd| cmd[:symbol] == entry[:symbol] } || entry[:index] || 0 idx = [[idx, 0].max, list.size - 1].min @action_window.select(idx) end end def menu_has_saved_state?(symbol) $framework.menu_stack.any? { |h| h[:symbol] == symbol } end def create_help_window wx = @command_window.width wy = Graphics.height - 120 ww = Graphics.width - wx wh = 120 @help_window = Window_Base.new(wx, wy, ww, wh) end def override_help_window_text(text) if @help_window && @help_window.contents c = @help_window.contents c.clear MenuFramework.force_font(c) @help_window.draw_text_ex(4, 0, text) end end def refresh_help_window text = "" unless @command_window.active cmd = @action_window.current_ext dict = @action_window.instance_variable_get(:@dictionary) rescue nil record = dict ? dict[cmd] : nil # Build help text help_lines = [] help1 = (record[:help1] rescue nil) #command specific text help1 = help1.call if help1.is_a?(Proc) help2 = (record[:help2] rescue nil) #command specific text help2 = help2.call if help2.is_a?(Proc) help3 = (record[:help3] rescue nil) #command specific text help3 = help3.call if help3.is_a?(Proc) help4 = (record[:help4] rescue nil) #command specific text help4 = help4.call if help4.is_a?(Proc) if help1.nil? && help2.nil? help1 = @help_window_text1 rescue nil #scene specific text help2 = @help_window_text2 rescue nil #scene specific text if help1.nil? && help2.nil? help1 = "" #if neither set, leave blank help2 = "" #if neither set, leave blank end end help_lines << help1 help_lines << help2 # Interface Instructions if help3.nil? && help4.nil? help3 = @help_window_text3 rescue nil #scene specific text help4 = @help_window_text4 rescue nil #scene specific text if help3.nil? && help4.nil? if @action_window && @action_window.instance_variable_get(:@hotkey_capture_mode) help3 = $framework.txt("menu:command_help/hotkey_capture1") help4 = $framework.txt("menu:command_help/hotkey_capture2") elsif @action_window && @action_window.instance_variable_get(:@editing_number) help3 = $framework.txt("menu:command_help/num_edit1") help4 = $framework.txt("menu:command_help/num_edit2") elsif @action_window && @action_window.instance_variable_get(:@editing) help3 = "" help4 = $framework.txt("menu:command_help/num_edit1") else type = record && record[:type] case type when :action then help3 = $framework.txt("menu:command_help/execute") when :scene then help3 = $framework.txt("menu:command_help/scene") when :toggle then help3 = $framework.txt("menu:command_help/toggle") when :edit_num, :edit_list then help3 = $framework.txt("menu:command_help/edit") else help3 = "" end # Only :action/:toggle/:scene rows can carry a hotkey (see # Action_Window_Defaults::CAPTURABLE_TYPES) - :edit_num/:edit_list # get no hint since pressing C there just buzzes. help4 = [:action, :scene, :toggle].include?(type) ? $framework.txt("menu:command_help/set_hotkey_hint") : "" end end end help_lines << help3 help_lines << help4 text = help_lines.join("\n") # Update Help Window if @help_window && @help_window.contents c = @help_window.contents c.clear MenuFramework.force_font(c) @help_window.draw_text_ex(4, 0, text) end end end def create_command_window @command_window = Window_CheatMainMenu.new main_dict = $framework.commands[:MAIN] || {} main_dict.each do |symbol, entry| @command_window.set_handler(:menu_command, method(:menu_command_update)) end # Always restore using the first (root) menu symbol in the stack if $framework.menu_stack && !$framework.menu_stack.empty? first = $framework.menu_stack.first list = @command_window.instance_variable_get(:@list) index = list.index { |cmd| cmd[:ext] == first[:symbol] } @command_window.select(index || 0) else @command_window.select(0) end end def save_command_window_state menu = :MAIN symbol = @command_window.current_ext rescue nil index = @command_window.index rescue 0 return unless symbol $framework.menu_stack.clear $framework.menu_stack.push({ menu: :MAIN, symbol: symbol, index: index }) end def menu_command_update save_command_window_state key = @command_window.current_ext record = $framework.commands[:MAIN][key] return unless record record[:action].call if record[:action] SndLib.sys_ok end # Small fix to prevent crashes when opening the menu during animations. def hud self end end #============================================================================== # Config List Defaults (Edit Menu Order / View Hotkeys / Edit Globals - the # full-width single-window screens in scripts/Controls.rb) #============================================================================== module Window_ConfigList_Defaults include MenuFramework::ScrollArrows def window_width; Graphics.width; end def window_height; Graphics.height - 120; end def initialize(*args) super create_scroll_arrows end def force_content_font MenuFramework.force_font(contents) if contents end end module Scene_ConfigList_Defaults # Breadcrumb save/restore/clamp, keyed by each scene's own menu_key. def save_selection $framework.menu_stack.push({ menu: menu_key, symbol: @command_window.current_ext, index: @command_window.index }) end def restore_selection entry = $framework.menu_stack.reverse.find { |e| e[:menu] == menu_key } return unless entry list = @command_window.instance_variable_get(:@list) idx = list.index { |cmd| cmd[:ext] == entry[:symbol] } || entry[:index] || 0 idx = [[idx, 0].max, list.size - 1].min @command_window.select(idx) end def clamp_selection list = @command_window.instance_variable_get(:@list) return if list.empty? idx = [[@command_window.index, 0].max, list.size - 1].min @command_window.select(idx) end end