Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==============================================================================
- # ** TDS Lufia Rise of the Sinistrals CMS
- # Version: 1.2
- #------------------------------------------------------------------------------
- # This script allows for the creation of objects trough a menu using other
- # objects and alchemic methods as the base for their creation.
- #==============================================================================
- # WARNING:
- #
- # Do not release, distribute or change my work without my expressed written
- # consent, doing so violates the terms of use of this work.
- #
- # * Not Knowing English or understanding these terms will not excuse you in any
- # way from the consequenses.
- #
- # * This applies to all of my work whether they have thiss notice or not.
- #
- # Contact Email: Sephirothtds@hotmail.com
- #==============================================================================
- # This is a system replication in no way meant to be used or distributed in any
- # game or for any profit monetary or other.
- #==============================================================================
- #==============================================================================
- # ** Window_Base
- #------------------------------------------------------------------------------
- # This is a superclass of all windows in the game.
- #==============================================================================
- class Window_Base < Window
- #--------------------------------------------------------------------------
- # * Constants
- #--------------------------------------------------------------------------
- WLH = 24 # Window Line Height
- #--------------------------------------------------------------------------
- # * Draw HP
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # width : Width
- # no_bar : drawing bar flag
- #--------------------------------------------------------------------------
- def draw_actor_hp(actor, x, y, width = 120, no_bar = false)
- if no_bar == false
- draw_actor_hp_gauge(actor, x, y, width)
- end
- self.contents.font.color = system_color
- self.contents.draw_text(x, y, 30, WLH, Vocab::hp_a)
- self.contents.font.color = hp_color(actor)
- last_font_size = self.contents.font.size
- xr = x + width
- if width < 120
- self.contents.draw_text(xr - 44, y, 44, WLH, actor.hp, 2)
- else
- self.contents.draw_text(xr - 99, y, 44, WLH, actor.hp, 2)
- self.contents.font.color = normal_color
- self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
- self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxhp, 2)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw MP
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # width : Width
- # no_bar : drawing bar flag
- #--------------------------------------------------------------------------
- def draw_actor_mp(actor, x, y, width = 120, no_bar = false)
- if no_bar == false
- draw_actor_mp_gauge(actor, x, y, width)
- end
- self.contents.font.color = power_up_color
- self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)
- self.contents.font.color = mp_color(actor)
- last_font_size = self.contents.font.size
- xr = x + width
- if width < 120
- self.contents.draw_text(xr - 44, y, 44, WLH, actor.mp, 2)
- else
- self.contents.draw_text(xr - 99, y, 44, WLH, actor.mp, 2)
- self.contents.font.color = normal_color
- self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
- self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxmp, 2)
- end
- end
- end
- #==============================================================================
- # ** Window_Selectable
- #------------------------------------------------------------------------------
- # This window contains cursor movement and scroll functions.
- #==============================================================================
- class Window_Selectable < Window_Base
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :item_max # item count
- attr_reader :column_max # digit count
- attr_reader :index # cursor position
- attr_reader :help_window # help window
- # Custom cursor values
- attr_accessor :use_custom_cursor # Custom cursor flag
- attr_accessor :cursor_visible # Cursor visibility flag
- attr_accessor :cursor_offsets # Cursor offsets values
- attr_accessor :wait_cursor_offsets # Cursor offsets values
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y coordinate
- # width : window width
- # height : window height
- # spacing : width of empty space when items are arranged horizontally
- #--------------------------------------------------------------------------
- def initialize(x, y, width, height, spacing = 32)
- @item_max = 1
- @column_max = 1
- @index = -1
- @spacing = spacing
- # Cursor variables
- @use_custom_cursor = false #true
- @cursor_offsets = [0, 0]
- @wait_cursor_offsets = [0, 0]
- @cursor_visible = nil
- super(x, y, width, height)
- create_custom_cursor
- end
- #--------------------------------------------------------------------------
- # * Dispose
- #--------------------------------------------------------------------------
- def dispose
- self.contents.dispose
- @sprite.bitmap.dispose
- @sprite.dispose
- super
- end
- #--------------------------------------------------------------------------
- # * Create Custom Cursor
- #--------------------------------------------------------------------------
- def create_custom_cursor
- @sprite = Sprite.new
- @sprite.bitmap = Cache.system("Cursor")
- @sprite.src_rect.width = @sprite.bitmap.width / 6
- @sprite.x = self.x + 16
- @sprite.y = self.y + 16 + 4
- @sprite.visible = @use_custom_cursor
- @sprite.z = 9999
- update_cursor_graphic
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- super
- if cursor_movable?
- last_index = @index
- if Input.repeat?(Input::DOWN)
- cursor_down(Input.trigger?(Input::DOWN))
- end
- if Input.repeat?(Input::UP)
- cursor_up(Input.trigger?(Input::UP))
- end
- if Input.repeat?(Input::RIGHT)
- cursor_right(Input.trigger?(Input::RIGHT))
- end
- if Input.repeat?(Input::LEFT)
- cursor_left(Input.trigger?(Input::LEFT))
- end
- if Input.repeat?(Input::R)
- cursor_pagedown
- end
- if Input.repeat?(Input::L)
- cursor_pageup
- end
- if @index != last_index
- Sound.play_cursor
- end
- end
- update_cursor
- call_update_help
- if @use_custom_cursor == true
- update_cursor_graphic
- end
- end
- #--------------------------------------------------------------------------
- # * Change cursor visibility
- # value : true or false visibility
- #--------------------------------------------------------------------------
- def change_cursor_visibility(value)
- @sprite.visible = value
- end
- #--------------------------------------------------------------------------
- # * Update Cursor Graphic
- #--------------------------------------------------------------------------
- def update_cursor_graphic
- @sprite.visible = @use_custom_cursor if @cursor_visible == nil
- @sprite.visible = @cursor_visible if @cursor_visible != nil
- if @use_custom_cursor == true
- if self.visible == false or @index < 0
- @sprite.opacity = 0
- elsif self.visible == true or @index >= 0
- @sprite.opacity = 255
- end
- if self.active
- @sprite.bitmap = Cache.system("Cursor")
- @sprite.src_rect.width = @sprite.bitmap.width / 6
- else
- @sprite.bitmap = Cache.system("Wait Cursor")
- @sprite.src_rect.width = @sprite.bitmap.width / 7
- end
- if self.active
- dx = self.x + self.cursor_rect.x + 16 + @cursor_offsets[0]
- dy = self.y + self.cursor_rect.y + self.cursor_rect.height / 2 + 3 + @cursor_offsets[1]
- else
- dx = self.x + self.cursor_rect.x + 16 + @wait_cursor_offsets[0]
- dy = self.y + self.cursor_rect.y + self.cursor_rect.height / 2 + 3 + @wait_cursor_offsets[1]
- end
- @sprite.x = dx
- @sprite.y = dy
- update_cursor_animation
- end
- end
- #--------------------------------------------------------------------------
- # * Update Cursor Animation
- #--------------------------------------------------------------------------
- def update_cursor_animation
- @duration = -1 if @duration == nil
- if self.active
- @duration += 1
- @duration %= 8
- if @duration == 8 -1
- @sprite.src_rect.x += 24
- @sprite.src_rect.x %= 6 * 24
- end
- else
- @duration += 1
- @duration %= 8
- if @duration == 8 - 1
- @sprite.src_rect.x -= 24
- @sprite.src_rect.x %= 7 * 24
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Dispose
- #--------------------------------------------------------------------------
- def dispose
- self.contents.dispose
- @sprite.dispose if @sprite != nil
- super
- end
- #--------------------------------------------------------------------------
- # * Update cursor
- #--------------------------------------------------------------------------
- def update_cursor
- if @index < 0 # If the cursor position is less than 0
- self.cursor_rect.empty # Empty cursor
- else # If the cursor position is 0 or more
- row = @index / @column_max # Get current row
- if row < top_row # If before the currently displayed
- self.top_row = row # Scroll up
- end
- if row > bottom_row # If after the currently displayed
- self.bottom_row = row # Scroll down
- end
- rect = item_rect(@index) # Get rectangle of selected item
- rect.y -= self.oy # Match rectangle to scroll position
- self.cursor_rect = rect # Refresh cursor rectangle
- end
- end
- #--------------------------------------------------------------------------
- # * Call help window update method
- #--------------------------------------------------------------------------
- def call_update_help
- if self.active and @help_window != nil
- update_help
- end
- end
- #--------------------------------------------------------------------------
- # * Update help window (contents are defined by the subclasses)
- #--------------------------------------------------------------------------
- def update_help
- end
- end
- #==============================================================================
- # ** Window_Command
- #------------------------------------------------------------------------------
- # This window deals with general command choices.
- #==============================================================================
- class TDS_Window_Command < Window_Selectable
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :commands # command
- #--------------------------------------------------------------------------
- # * Object Initialization
- # width : window width
- # commands : command string array
- # column_max : digit count (if 2 or more, horizontal selection)
- # row_max : row count (0: match command count)
- # spacing : blank space when items are arrange horizontally
- #--------------------------------------------------------------------------
- def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32)
- if row_max == 0
- row_max = (commands.size + column_max - 1) / column_max
- end
- super(0, 0, width, row_max * WLH + 32, spacing)
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.back_opacity = 255
- @use_custom_cursor = true
- @cursor_offsets = [-4, 0]
- @commands = commands
- @item_max = commands.size
- @column_max = column_max
- refresh
- self.index = 0
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- self.contents.clear
- for i in 0...@item_max
- draw_item(i)
- end
- end
- #--------------------------------------------------------------------------
- # * Return_Command_Name
- #--------------------------------------------------------------------------
- def return_command_name(index)
- return @commands[index]
- end
- #--------------------------------------------------------------------------
- # * Draw Item
- # index : item number
- # enabled : enabled flag. When false, draw semi-transparently.
- #--------------------------------------------------------------------------
- def draw_item(index, enabled = true)
- rect = item_rect(index)
- rect.x += 26
- rect.width -= 8
- self.contents.clear_rect(rect)
- self.contents.font.color = normal_color
- self.contents.font.color.alpha = enabled ? 255 : 128
- self.contents.draw_text(rect, @commands[index])
- end
- end
- #============== ================================================================
- # ** TDS Lufia Menu
- #------------------------------------------------------------------------------
- # This class performs the menu screen processing.
- #==============================================================================
- class Scene_Menu < Scene_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # menu_index : command cursor's initial position
- #--------------------------------------------------------------------------
- def initialize(menu_index = 0)
- @menu_index = menu_index
- # Flag variables
- @viewing_spell_information_window = false
- @viewing_item_information_window = false
- @viewing_scenario_information_window = false
- end
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- super
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- # Create Scene Header
- @scene_header = Window_Base.new(20, 198, 140, 56)
- @scene_header.windowskin = Cache.system("TDS-Lufia Window")
- @scene_header.back_opacity = 255
- @scene_header.contents = Bitmap.new(140-32,56-32)
- @scene_header.contents.font.color = @scene_header.text_color(0)
- @scene_header.contents.draw_text(0,0,140-32, 24, "ITEM",1)
- @scene_header.visible = false
- # Create Dummy Help Window
- @dummy_help_window = Window_Base.new(20, 305, 505, 101)
- @dummy_help_window.windowskin = Cache.system("TDS-Lufia Window")
- @dummy_help_window.contents = Bitmap.new(505-32,56-32)
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.draw_text(0, 0 , 505-32, 24, "HELP",1)
- @dummy_help_window.back_opacity = 255
- @dummy_help_window.visible = false
- # Create Help Window Header
- @scene_help_header = Window_Base.new(20, 254, 505, 56)
- @scene_help_header.windowskin = Cache.system("TDS-Lufia Window")
- @scene_help_header.back_opacity = 255
- @scene_help_header.contents = Bitmap.new(505-32,56-32)
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, "Item name",1)
- @scene_help_header.visible = false
- # Create Scenario header
- @scenario_header = Window_Base.new(20, 198, 300, 56)
- @scenario_header.windowskin = Cache.system("TDS-Lufia Window")
- @scenario_header.back_opacity = 255
- @scenario_header.contents = Bitmap.new(300-32,56-32)
- @scenario_header.contents.font.color = @scene_header.text_color(0)
- @scenario_header.contents.draw_text(0,0,300-32, 24, "SCENARIO ITEMS",1)
- @scenario_header.visible = false
- # Create command windows
- create_command_window
- # Create Gold Window
- @gold_time_window = Window_Gold_Time.new(265, 326)
- # Create Main Status Window
- @status_window = Window_MenuStatus.new(0, 0)
- @status_window.active = false
- # Activate main status window normal mode
- @status_window.change_mode(0, true)
- # Create Item Window
- @item_window = TDS_Lufia_Window_Item.new(20, 254, 505, 152)
- @item_window.index = 0
- @item_window.active = false
- @item_window.visible = false
- # Create Skill Window
- @skill_window = TDS_Lufia_Window_Skill.new(20, 254, 505, 152, $game_party.members[0])
- @skill_window.active = false
- @skill_window.visible = false
- # Flag variables
- @viewing_item_information_window = false
- @viewing_spell_information_window = false
- @viewing_scenario_information_window = false
- # Update flag values
- @update_item_processing = false
- @update_spell_processing = false
- @update_scenario_mode_processing = false
- end
- #--------------------------------------------------------------------------
- # * Create Command Window
- #--------------------------------------------------------------------------
- def create_command_window
- # Create Command Window
- @command_window = TDS_Window_Command.new(390, ["ITEM", "STATUS", "SPELL",
- "EQUIP", "SCENARIO", "SAVE", "END"], 2)
- # Set command window x position
- @command_window.x = 135
- # Set command window y position
- @command_window.y = 198
- # Set command window index
- @command_window.index = @menu_index
- # If game party size is 0
- if $game_party.members.size == 0 # If number of party members is 0
- @command_window.draw_item(0, false) # Disable item
- @command_window.draw_item(1, false) # Disable skill
- @command_window.draw_item(2, false) # Disable equipment
- @command_window.draw_item(3, false) # Disable status
- end
- # If saving disable
- if $game_system.save_disabled # If save is forbidden
- @command_window.draw_item(5, false) # Disable save
- end
- # Create Item Command Window
- @item_command_window = TDS_Window_Command.new(365, ["USE", "ALL", "DROP"],3)
- # Set item command window x
- @item_command_window.x = 160
- # Set item command window y
- @item_command_window.y = 198
- # Set item command visibility
- @item_command_window.visible = false
- # Set item command window active to false
- @item_command_window.active = false
- # Create Spell Command Window
- @spell_command_window = TDS_Window_Command.new(365, ["USE", "ALL"],2)
- # Set spell command window x
- @spell_command_window.x = 160
- # Set spell command window y
- @spell_command_window.y = 198
- # Set spell command window visible to false
- @spell_command_window.visible = false
- # Set Spell command window active to false
- @spell_command_window.active = false
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- super
- # Update command windows
- @command_window.update
- @spell_command_window.update
- @item_command_window.update
- # Update windows
- @gold_time_window.update
- @status_window.update
- @item_window.update
- @skill_window.update
- # If command window active
- if @command_window.active
- update_command_selection
- end
- # If status window is active and it's on normal mode
- if @status_window.active and @status_window.normal_mode
- # Update main menu actor selection
- update_main_actor_selection
- end
- # If item processing flag is true update item methods
- if @update_item_processing
- # Update Item Choosing if Item window is active or viewing item information
- if @item_window.active == true or @viewing_item_information_window
- update_item_choosing
- end
- # Update Item Command Arrange Choosing if Item Command window is active
- if @item_command_window.active
- update_item_command_choosing
- end
- # If status window is active and it's on item mode
- if @status_window.active and @status_window.item_mode
- update_item_target_choosing
- end
- end
- # If skill prcoessing flag is true update skill methods
- if @update_spell_processing
- # Update skill arrange choosing if spell command window is active
- if @spell_command_window.active
- update_skill_command_choosing
- end
- # Update skill choosing if skill window is active or viewing skill information
- if @skill_window.active or @viewing_spell_information_window
- update_skill_choosing
- end
- # If status window is active and it's on skill mode
- if @status_window.active and @status_window.skill_mode
- update_skill_target_choosing
- end
- end
- # If scenario processing flag is true update Scenario methods
- if @update_scenario_mode_processing
- # Update sceneario item viewing pro
- update_scenario_item_choosing
- end
- end
- #--------------------------------------------------------------------------
- # * Update Command Selection
- #--------------------------------------------------------------------------
- def update_command_selection
- if Input.trigger?(Input::B)
- Sound.play_cancel
- $scene = Scene_Map.new
- return
- end
- # If Input trigger Confirm
- if Input.trigger?(Input::C)
- case @command_window.return_command_name(@command_window.index)
- when "ITEM"
- # Play desicion sound
- Sound.play_decision
- # Start item scene processing
- start_item_scene
- # Update input
- Input.update
- return
- when "STATUS"
- start_main_actor_selection
- when "SPELL"
- start_main_actor_selection
- when "EQUIP"
- start_main_actor_selection
- when "SCENARIO"
- # Play desicion sound
- Sound.play_decision
- # Start scenario scene processing
- start_scenario_mode
- return
- when "SAVE"
- if $game_system.save_disabled
- Sound.play_buzzer
- return
- end
- # Play desicion sound
- Sound.play_decision
- $scene = Scene_File.new(true, false, false)
- return
- when "END"
- # Play desicion sound
- Sound.play_decision
- $scene = Scene_End.new
- return
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Start Main Actor Selection
- #--------------------------------------------------------------------------
- def start_main_actor_selection
- if $game_party.members.size == 0
- Sound.play_buzzer
- return
- end
- # Play desicion sound
- Sound.play_decision
- # Deactivate command window
- @command_window.active = false
- # Activate status window and make cursor visible
- @status_window.active = true
- @status_window.index = 0
- # Input update
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * End Main Actor Selection
- #--------------------------------------------------------------------------
- def end_main_actor_selection
- # Deactivate status window and make cursor invisible
- @status_window.active = false
- @status_window.index = -1
- # Activate command window
- @command_window.active = true
- return
- end
- #--------------------------------------------------------------------------
- # * Update Actor Selection
- #--------------------------------------------------------------------------
- def update_main_actor_selection
- # If input trigger is cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # End main actor selection
- end_main_actor_selection
- return
- end
- # If input trigger confirm
- if Input.trigger?(Input::C)
- # Play desicion sound
- Sound.play_decision
- case @command_window.return_command_name(@command_window.index)
- when "STATUS"
- # Change scene to Scene Status
- $scene = Scene_Status.new(@status_window.index)
- return
- when "SPELL"
- # Start skill methods
- start_skill_scene
- when "EQUIP"
- # Change scene to Scene Equip
- $scene = Scene_Equip.new(@status_window.index)
- return
- end
- end
- end
- #==============================================================================
- # ** Item Methods
- #------------------------------------------------------------------------------
- # These methods performs the item screen processing.
- #==============================================================================
- #--------------------------------------------------------------------------
- # * Start Item Scene
- #--------------------------------------------------------------------------
- def start_item_scene
- # Start updating item processing
- @update_item_processing = true
- # Set intial value for item for information
- @item = nil
- # Activate main status window normal mode
- @status_window.change_mode(1, true)
- # Deactivate status window
- @status_window.active = false
- # Set Old Index initial value
- @old_item_command_index = 0
- # Change item status window visibility
- @command_window.visible = false
- @command_window.active = false
- # Changing visibily of gold window
- @gold_time_window.visible = false
- # Change scene header text color, text and visibility
- @scene_header.contents.font.color = @scene_header.text_color(0)
- @scene_header.contents.clear
- @scene_header.contents.draw_text(0,0,140-32,56-32, "ITEM",1)
- @scene_header.visible = true
- # Activate the item command window
- @item_command_window.visible = true
- @item_command_window.index = 0
- # Determining item index and activity
- if @item_window.item_max == 0
- @item_window.index = -1
- @item_window.active = false
- @item_command_window.active = true
- else
- @item_window.index = 0
- @item_window.active = true
- @item_command_window.active = false
- end
- # Changing command window visibility
- @item_window.visible = true
- end
- #--------------------------------------------------------------------------
- # * End Item Scene
- #--------------------------------------------------------------------------
- def end_item_scene
- # Set value for item for information
- @item = nil
- # Activate main status window normal mode
- @status_window.change_mode(0, true)
- # Set Old Index value
- @old_item_command_index = 0
- # Changing item window visibility and active
- @item_command_window.visible = false
- @item_window.active = false
- # Changing command window visibility and active
- @item_window.visible = false
- @item_window.active = false
- # Change scene header visibility
- @scene_header.contents.clear
- @scene_header.visible = false
- # Activating command window
- @command_window.visible = true
- @command_window.active = true
- # Changing visibily of gold window
- @gold_time_window.visible = true
- # Deactivate status window and change index
- @status_window.active = false
- @status_window.index = -1
- # Change viewing item information flag to false
- @viewing_item_information_window = false
- # End item processing
- @update_item_processing = false
- # Update Input
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * Update Item Command Choosing
- #--------------------------------------------------------------------------
- def update_item_command_choosing
- # If old index is not equal to item command window idex
- if @old_item_command_index != @item_command_window.index
- # Update window display mode
- update_item_window_display_mode
- end
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # End item processing
- end_item_scene
- # Update Input
- Input.update
- return
- end
- # If Input trigger Confirm
- if Input.trigger?(Input::C)
- # If item window item max is 0
- if @item_window.item_max == 0
- # Play buzzer sound
- Sound.play_buzzer
- # Activate item command window
- @item_command_window.active = true
- # Deactivate item window
- @item_window.active = false
- # Update input
- Input.update
- return
- end
- # PLay desicion sound
- Sound.play_decision
- # Deactivate the command window
- @item_command_window.active = false
- # Activate the item window
- @item_window.active = true
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Item Choosing
- #--------------------------------------------------------------------------
- def update_item_choosing
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # If viewing item information flag is true
- if @viewing_item_information_window == true
- # View item information
- view_item_information(@item_window.item)
- return
- end
- # Deactivate the item window
- @item_window.active = false
- # Set old index value to the item window index value
- @old_item_window_index = @item_window.index
- # Activate the command window
- @item_command_window.active = true
- # If item quantity is 0
- if $game_party.item_number(@item) == 0
- # Refresh item window
- @item_window.refresh
- end
- # Update Input
- Input.update
- return
- end
- # If Input trigger Confirm not viewing item information
- if Input.trigger?(Input::C) and @viewing_item_information_window == false
- # Item command window index
- case @item_command_window.index
- when 0, 1 # Use or all items
- use_item
- when 2 # Drop
- drop_item
- end
- end
- # If Input Trigger CTRL
- if Input.trigger?(Input::CTRL)
- # PLay desicion sound
- Sound.play_decision
- # View item information
- view_item_information(@item_window.item)
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Item Target Choosing
- #--------------------------------------------------------------------------
- def update_item_target_choosing
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # Deactivate status window
- @status_window.active = false
- # Change status window index making it invisible
- @status_window.index = -1
- # Activate the command window
- @item_window.active = true
- # If item quantity is 0
- if $game_party.item_number(@item) == 0
- # Refresh item window
- @item_window.refresh
- # Activate item command window
- @item_command_window.active = true
- # Deactivate item window
- @item_window.active = false
- end
- # Set value for item for information
- @item = nil
- return
- end
- # If Input trigger Confirm
- if Input.trigger?(Input::C)
- if $game_party.item_can_use?(@item) == false
- Sound.play_buzzer
- else
- determine_item_target
- end
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Item Window Display Mode
- #--------------------------------------------------------------------------
- def update_item_window_display_mode
- case @item_command_window.index
- when 0
- # Change item window mode to true and to display only use items
- @item_window.only_items_mode(true)
- # Change item window mode to false and to display all items
- @item_window.all_items_mode(false)
- # Change item window mode to drop items to false
- @item_window.drop_items_mode(false)
- # Refresh item window
- @item_window.refresh
- # Change cursor index to 0
- @item_window.index = 0
- when 1, 2
- # Set old mode value for refresh
- old_mode_value = @item_window.all_mode
- # Change item window mode to false and to display only use items
- @item_window.only_items_mode(false)
- # Change item window mode to true and to display all items
- @item_window.all_items_mode(true)
- # Set item window index to 0 if the items in the window are more
- if old_mode_value == false
- # Refresh item window
- @item_window.refresh
- # Change cursor index to 0
- @item_window.index = 0
- end
- end
- # Set old command index to be the same as the
- @old_item_command_index = @item_command_window.index
- end
- #--------------------------------------------------------------------------
- # * Use Item
- #--------------------------------------------------------------------------
- def use_item
- # Set item variable information
- @item = @item_window.item
- return Sound.play_buzzer if $game_party.item_can_use?(@item) == false
- # PLay desicion sound
- Sound.play_decision
- # Deactivate the item window
- @item_window.active = false
- # Activate status window
- @status_window.active = true
- # Change status window index making it visible depending on the item scope
- if @item.scope == 8 and $game_party.members.size > 1
- @status_window.index = 100
- else
- @status_window.index = 0
- end
- # Update input
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * Drop Item
- #--------------------------------------------------------------------------
- def drop_item
- # If Item window Item max is 0
- if @item_window.item_max == 0
- # Activate item command window
- @item_command_window.active = true
- # Deactivate item window
- @item_window.active = false
- else
- # Set old item index
- old_index = @item_window.index
- # Play equip sound
- Sound.play_equip
- # Drop item
- @item_window.drop_item(@item_window.item)
- # Refresh item window
- @item_window.refresh
- # Set old index to the item window index if it's not 0
- old_index %= @item_window.item_max if @item_window.item_max != 0
- # Set item window index to old index
- @item_window.index = old_index
- # If item window item max is not 0
- if @item_window.item_max == 0
- # Play cancel sound
- Sound.play_cancel
- # Activate item command window
- @item_command_window.active = true
- end
- # Update input
- Input.update
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Confirm Item Target
- # If there is no effect (such as using a potion on an incapacitated
- # character), play a buzzer SE.
- #--------------------------------------------------------------------------
- def determine_item_target
- # Item used is set to false
- used = false
- # if item is for all
- if @item.for_all?
- for target in $game_party.members
- target.item_effect(target, @item)
- used = true unless target.skipped
- end
- else
- $game_party.last_target_index = @status_window.index
- target = $game_party.members[@status_window.index]
- target.item_effect(target, @item)
- used = true unless target.skipped
- end
- # If use is true
- if used
- # Use item
- use_item_nontarget
- else
- # Play buzzer sound
- Sound.play_buzzer
- end
- end
- #--------------------------------------------------------------------------
- # * Use Item (apply effects to non-ally targets)
- #--------------------------------------------------------------------------
- def use_item_nontarget
- # Play item use sound
- Sound.play_use_item
- # Consume item
- $game_party.consume_item(@item)
- # Draw used item
- @item_window.draw_item(@item_window.index)
- # Refresh status window
- @status_window.refresh
- # If the party is all dead
- if $game_party.all_dead?
- # Change to scene game over
- $scene = Scene_Gameover.new
- # If item common event ID is more than 0
- elsif @item.common_event_id > 0
- $game_temp.common_event_id = @item.common_event_id
- $scene = Scene_Map.new
- end
- end
- #--------------------------------------------------------------------------
- # * View Item Information
- # item : item from which to read data from
- #--------------------------------------------------------------------------
- def view_item_information(item)
- # If viewing item information flag is false
- if @viewing_item_information_window == false
- item_info = item
- # Change item window visibility and active
- @item_window.visible = false
- @item_window.active = false
- # Change scene help header visibility, add text and change text color
- @scene_help_header.visible = true
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, item_info.name,1)
- # Change dummy help window visibility, add text and color
- @dummy_help_window.visible = true
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32, item_info.description.capitalize)
- # Change viewing item information flag to true
- @viewing_item_information_window = true
- else
- # Change item window visibility and active
- @item_window.visible = true
- @item_window.active = true
- # Change help header window visibilty and clear text
- @scene_help_header.visible = false
- @scene_help_header.contents.clear
- # Change dummy help window visibily and clear text
- @dummy_help_window.visible = false
- @dummy_help_window.contents.clear
- # Change viewing item information flag to false
- @viewing_item_information_window = false
- return
- end
- end
- #==============================================================================
- # ** Skill Methods
- #------------------------------------------------------------------------------
- # These methods performs the Spell screen processing.
- #==============================================================================
- #--------------------------------------------------------------------------
- # * Start Skill Scene
- #--------------------------------------------------------------------------
- def start_skill_scene
- # Start updating spell processing
- @update_spell_processing = true
- # Set initial value for skill information
- @skill = nil
- # Activate main status window spell mode
- @status_window.change_mode(2, true)
- # Set old index initia value
- @old_spell_value_command_index = 0
- # Change command window visibility and active
- @command_window.visible = false
- @command_window.active = false
- # Deactivate status window
- @status_window.active = false
- # Change spell command window visibility and active
- @spell_command_window.visible = true
- @spell_command_window.active = true
- # Change spell command window to 0
- @spell_command_window.index = 0
- # Change skill window mode to show only usable skills
- @skill_window.only_use_skill_mode(true)
- # Change scene header text, color, visibility and add text
- @scene_header.contents.font.color = @scene_header.text_color(0)
- @scene_header.contents.clear
- @scene_header.contents.draw_text(0,0,140-32,56-32, "SPELL",1)
- @scene_header.visible = true
- # Changing visibily of gold window
- @gold_time_window.visible = false
- # Refresh window contents
- @skill_window.refresh($game_party.members[@status_window.index])
- # Change skill window visibility
- @skill_window.visible = true
- # Change skill window index to 0
- @skill_window.index = 0
- # Input update
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * End Skill Scene
- #--------------------------------------------------------------------------
- def end_skill_scene
- # End updating spell processing
- @update_spell_processing = false
- # Set value for skill information
- @skill = nil
- # Activate main status window normal mode
- @status_window.change_mode(0, true)
- # Set old index initia value
- @old_spell_value_command_index = 0
- # Deactivate status window and change index
- @status_window.active = false
- @status_window.index = -1
- # Change skill window visibility
- @skill_window.visible = false
- # Change spell command window visibility and active
- @spell_command_window.visible = false
- @spell_command_window.active = false
- # Change spell command window to 0
- @spell_command_window.index = 0
- # Change scene header visibility
- @scene_header.contents.clear
- @scene_header.visible = false
- # Change command window visibility and active
- @command_window.visible = true
- @command_window.active = true
- # Changing visibily of gold window
- @gold_time_window.visible = true
- # Update Input
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * Update Skill Command Choosing
- #--------------------------------------------------------------------------
- def update_skill_command_choosing
- # If old index is not equal to item command window idex
- if @old_spell_value_command_index != @spell_command_window.index
- # Update window display mode
- update_skill_window_display_mode
- end
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # End spell processing
- end_skill_scene
- # Update Input
- Input.update
- return
- end
- # If not viewing spell information window
- if @viewing_spell_information_window == false
- # If Input trigger R
- if Input.trigger?(Input::R)
- # Play cursor sound
- Sound.play_cursor
- # Next actor
- next_spell_actor
- # If Input trigger L
- elsif Input.trigger?(Input::L)
- # Play cursor sound
- Sound.play_cursor
- # Previous actor
- prev_spell_actor
- end
- end
- # If Input trigger Confirm
- if Input.trigger?(Input::C)
- # If item window item max is 0
- if @skill_window.item_max == 0
- # Play buzzer sound
- Sound.play_buzzer
- # Activate spell command window
- @spell_command_window.active = true
- # Deactivate skill window
- @skill_window.active = false
- # Update input
- Input.update
- return
- end
- # Change skill window index to 0 if skill window index is more than skill window item max
- @skill_window.index = 0 if @skill_window.index > @skill_window.item_max
- # PLay desicion sound
- Sound.play_decision
- # Deactivate the command window
- @spell_command_window.active = false
- # Activate the skill window
- @skill_window.active = true
- # Update input
- Input.update
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Skill Choosing
- #--------------------------------------------------------------------------
- def update_skill_choosing
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- if @viewing_spell_information_window == true
- # View skill information
- view_skill_information(@skill_window.skill)
- return
- end
- # Deactivate the skill window
- @skill_window.active = false
- # Activate spell command window
- @spell_command_window.active = true
- # Update Input
- Input.update
- return
- end
- # If not viewing spell information window
- if @viewing_spell_information_window == false
- # If Input trigger R
- if Input.trigger?(Input::R)
- # Play cursor sound
- Sound.play_cursor
- # Next actor
- next_spell_actor
- # If Input trigger L
- elsif Input.trigger?(Input::L)
- # Play cursor sound
- Sound.play_cursor
- # Previous actor
- prev_spell_actor
- end
- end
- # If Input trigger Confirm and not viewing skill information
- if Input.trigger?(Input::C) and @viewing_spell_information_window == false
- # Use skill
- use_skill
- # Update Input
- Input.update
- return
- end
- # If Input Trigger CTRL
- if Input.trigger?(Input::CTRL)
- # PLay desicion sound
- Sound.play_decision
- # View skill information
- view_skill_information(@skill_window.skill)
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Skill Target Choosing
- #--------------------------------------------------------------------------
- def update_skill_target_choosing
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # Deactivate status window
- @status_window.active = false
- # Change status window index to the return index
- @status_window.index = @return_status_index
- # Activate the skill window
- @skill_window.active = true
- # Set value for skill information
- @skill = nil
- # Update input
- Input.update
- return
- end
- # If input trigger confirm
- if Input.trigger?(Input::C)
- # If actor can use skill
- if @skill_window.actor.skill_can_use?(@skill)
- # Determine if skill further usable
- determine_skill
- else
- # Play buzzer sound
- Sound.play_buzzer
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Update Skill Window Display Mode
- #--------------------------------------------------------------------------
- def update_skill_window_display_mode
- case @spell_command_window.index
- when 0
- # Change skill window mode to show only usable skills
- @skill_window.only_use_skill_mode(true)
- # Change display of all skills mode to false
- @skill_window.all_skill_display_mode(false)
- when 1
- # Change display of only usable skills to false
- @skill_window.only_use_skill_mode(false)
- # Change skill window mode to show all skills
- @skill_window.all_skill_display_mode(true)
- end
- # Change old spell index value to spell window command index
- @old_spell_value_command_index = @spell_command_window.index
- # Refresh command window
- @skill_window.refresh(@skill_window.actor)
- # Change skill window index to 0 if skill window index is more than skill window item max
- @skill_window.index = 0 if @skill_window.index > @skill_window.item_max
- return
- end
- #--------------------------------------------------------------------------
- # * Next Spell Actor
- #--------------------------------------------------------------------------
- def next_spell_actor
- @actor_index = @status_window.index if @actor_index == nil
- @actor_index += 1
- @actor_index %= $game_party.members.size
- @status_window.index = @actor_index
- @skill_window.index = 0 if @skill_window.item_max != 0
- @skill_window.refresh($game_party.members[@actor_index])
- return @skill_window.active = false, @spell_command_window.active = true if @skill_window.actor.dead?
- return @skill_window.active = false, @spell_command_window.active = true if @skill_window.item_max == 0
- end
- #--------------------------------------------------------------------------
- # * Prev Spell Actor
- #--------------------------------------------------------------------------
- def prev_spell_actor
- @actor_index = @status_window.index if @actor_index == nil
- @actor_index += $game_party.members.size - 1
- @actor_index %= $game_party.members.size
- @status_window.index = @actor_index
- @skill_window.index = 0 if @skill_window.item_max != 0
- @skill_window.refresh($game_party.members[@actor_index])
- return @skill_window.active = false, @spell_command_window.active = true if @skill_window.actor.dead?
- return @skill_window.active = false, @spell_command_window.active = true if @skill_window.item_max == 0
- end
- #--------------------------------------------------------------------------
- # * Use Skill
- #--------------------------------------------------------------------------
- def use_skill
- # Set skill variable value to the currently used skill
- @skill = @skill_window.skill
- # If actor can use the skill
- if @skill_window.actor.skill_can_use?(@skill)
- # Play desicion sound
- Sound.play_decision
- # Change skill window active to false
- @skill_window.active = false
- # Set return status index to the current status index
- @return_status_index = @status_window.index
- # Change status window active to true
- @status_window.active = true
- # If skill scope covers all characters and there are more tnan 1 party members
- if @skill.scope == 8 and $game_party.members.size > 1
- # Make cursor select eveveryone
- @status_window.index = 100
- else
- # Change status window index to 1
- @status_window.index = 0
- end
- else
- # Play buzzer sound
- Sound.play_buzzer
- end
- end
- #--------------------------------------------------------------------------
- # * Confirm Target
- # If there is no effect (such as using a potion on an incapacitated
- # character), play a buzzer SE.
- #--------------------------------------------------------------------------
- def determine_skill
- # Set used value to false
- used = false
- # If skill is for all
- if @skill.for_all?
- for target in $game_party.members
- target.skill_effect(@skill_window.actor, @skill)
- used = true unless target.skipped
- end
- elsif @skill.for_user?
- target = $game_party.members[@status_window.index]
- target.skill_effect(target, @skill)
- used = true unless target.skipped
- else
- $game_party.last_target_index = @status_window.index
- target = $game_party.members[@status_window.index]
- target.skill_effect(target, @skill)
- used = true unless target.skipped
- end
- # If used is true
- if used
- use_skill_nontarget
- else
- # Play buzzer sound
- Sound.play_buzzer
- end
- end
- #--------------------------------------------------------------------------
- # * Use Skill (apply effects to non-ally targets)
- #--------------------------------------------------------------------------
- def use_skill_nontarget
- # Play use skill sound
- Sound.play_use_skill
- # Detract MP equal to the skill MP cost
- @skill_window.actor.mp -= @skill_window.actor.calc_mp_cost(@skill)
- # Refresh status window
- @status_window.refresh
- # Refresh skill window
- @skill_window.refresh(@skill_window.actor)
- # If the whole party is dead
- if $game_party.all_dead?
- $scene = Scene_Gameover.new
- elsif @skill.common_event_id > 0
- $game_temp.common_event_id = @skill.common_event_id
- $scene = Scene_Map.new
- end
- end
- #--------------------------------------------------------------------------
- # * View Skill Information
- # skill : skill from which to read data from
- #--------------------------------------------------------------------------
- def view_skill_information(skill)
- # If viewing spell information flag is false
- if @viewing_spell_information_window == false
- skill_info = skill
- # Change skill window visibility and active
- @skill_window.visible = false
- @skill_window.active = false
- # Change scene help header visibility, add text and change text color
- @scene_help_header.visible = true
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, skill_info.name,1)
- # Change dummy help window visibility, add text and color
- @dummy_help_window.visible = true
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32, skill_info.description.capitalize)
- # Change viewing spell information flag to true
- @viewing_spell_information_window = true
- else
- # Change skill window visibility and active
- @skill_window.visible = true
- @skill_window.active = true
- # Change help header window visibilty and clear text
- @scene_help_header.visible = false
- @scene_help_header.contents.clear
- # Change dummy help window visibily and clear text
- @dummy_help_window.visible = false
- @dummy_help_window.contents.clear
- # Change viewing spell information flag to false
- @viewing_spell_information_window = false
- return
- end
- end
- #==============================================================================
- # ** Scenario Methods
- #------------------------------------------------------------------------------
- # These methods performs the scenario screen processing.
- #==============================================================================
- #--------------------------------------------------------------------------
- # * Start Scenario Mode
- #--------------------------------------------------------------------------
- def start_scenario_mode
- # Start updating scenario processing
- @update_scenario_mode_processing = true
- # Change command window visibility
- @command_window.visible = false
- @command_window.active = false
- # Deactivate status window
- @status_window.active = false
- # Changing visibily of gold window
- @gold_time_window.visible = false
- # Change sceneraio header visibility to true
- @scenario_header.visible = true
- # Determining item index and activity
- if @item_window.item_max == 0
- @item_window.index = -1
- @item_window.active = false
- else
- @item_window.index = 0
- @item_window.active = true
- end
- # Change item window mode to display scenenario items
- @item_window.scenario_items_mode(true)
- @item_window.only_items_mode(false)
- @item_window.all_items_mode(false)
- # Changing command window visibility
- @item_window.visible = true
- # Refresh item window
- @item_window.refresh
- # Update Input
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * End Scenario Scene
- #--------------------------------------------------------------------------
- def end_scenario_scene
- # End scenario processing
- @update_scenario_mode_processing = false
- # Change sceneraio header visibility to false
- @scenario_header.visible = false
- # Change item window mode to display normal items
- @item_window.active = false
- @item_window.only_items_mode(true)
- @item_window.all_items_mode(false)
- @item_window.scenario_items_mode(false)
- # Change item window index
- @item_window.index = -1
- # Changing command window visibility
- @item_window.visible = false
- # Refresh item window
- @item_window.refresh
- # Change command window visibility
- @command_window.visible = true
- @command_window.active = true
- # Deactivate status window
- @status_window.active = false
- # Changing visibily of gold window
- @gold_time_window.visible = true
- # Update Input
- Input.update
- return
- end
- #--------------------------------------------------------------------------
- # * Update Scenario Item Choosing
- #--------------------------------------------------------------------------
- def update_scenario_item_choosing
- # If Input Trigger Cancel
- if Input.trigger?(Input::B)
- # Play cancel sound
- Sound.play_cancel
- # If viewing sceneario information flag is true
- if @viewing_scenario_information_window == true
- # View scenario_ information
- view_scenario_item_information(@item_window.item)
- return
- end
- # End scenario scene processing
- end_scenario_scene
- return
- end
- # If Input Trigger CTRL
- if Input.trigger?(Input::CTRL)
- # PLay desicion sound
- Sound.play_decision
- # View item information
- view_scenario_item_information(@item_window.item)
- return
- end
- end
- #--------------------------------------------------------------------------
- # * View Scenario Item Information
- # item : item from which to read data from
- #--------------------------------------------------------------------------
- def view_scenario_item_information(item)
- # If viewing scenario information flag is false
- if @viewing_scenario_information_window == false
- item_info = item
- # Change item window visibility and active
- @item_window.visible = false
- @item_window.active = false
- # Change scene help header visibility, add text and change text color
- @scene_help_header.visible = true
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, item_info.name,1)
- # Change dummy help window visibility, add text and color
- @dummy_help_window.visible = true
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32, item_info.description.capitalize)
- # Change viewing item information flag to true
- @viewing_scenario_information_window = true
- else
- # Change item window visibility and active
- @item_window.visible = true
- @item_window.active = true
- # Change help header window visibilty and clear text
- @scene_help_header.visible = false
- @scene_help_header.contents.clear
- # Change dummy help window visibily and clear text
- @dummy_help_window.visible = false
- @dummy_help_window.contents.clear
- # Change viewing scenario information flag to false
- @viewing_scenario_information_window = false
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- super
- # Dipose of back sprite
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- # Dispose command windows
- @command_window.dispose
- @item_command_window.dispose
- @spell_command_window.dispose
- # Dispose of windows
- @gold_time_window.dispose
- @status_window.dispose
- @item_window.dispose
- @skill_window.dispose
- # Dispose of headers and dummy windows
- @scene_header.dispose
- @dummy_help_window.dispose
- @scene_help_header.dispose
- @scenario_header.dispose
- end
- end
- #==============================================================================
- # ** Window_MenuStatus
- #------------------------------------------------------------------------------
- # This window displays party member status on the menu screen.
- #==============================================================================
- class Window_MenuStatus < Window_Selectable
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :normal_mode # Normal Mode flag
- attr_reader :item_mode # Item Mode Flag
- attr_reader :skill_mode # skill Mode Flag
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y coordinate
- #--------------------------------------------------------------------------
- def initialize(x, y)
- super(x, y, 544, 416)
- self.active = false
- self.contents.font.size = 18
- self.opacity = 0
- self.index = -1
- @normal_mode = true
- @item_mode = false
- @skill_mode = false
- refresh
- end
- #--------------------------------------------------------------------------
- # * Change Mode
- # mode : mode to modify 0 = Normal, 1 = Item, 2 = Skill
- # value : true or false value
- #--------------------------------------------------------------------------
- def change_mode(mode, value)
- # Modes array
- @normal_mode = (mode == 0 ? value : false )
- @item_mode = (mode == 1 ? value : false )
- @skill_mode = (mode == 2 ? value : false )
- return
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- self.contents.clear
- @item_max = $game_party.members.size
- @column_max = 2
- for actor in $game_party.members
- y = 0
- if actor.index > 1
- x = 260 #272
- draw_actor_graphic(actor, 19 + actor.index * x - actor.index - @column_max * x, 90)
- draw_actor_name(actor, 96 + actor.index * x - actor.index - @column_max * x, 90)
- draw_actor_hp(actor, 96 + actor.index * x - actor.index - @column_max * x, y + 84 + WLH * 1 , 120, true)
- draw_actor_mp(actor, 96 + actor.index * x - actor.index - @column_max * x, y + 84 + WLH * 2 , 120, true)
- draw_actor_level(actor, 174 + actor.index * x - actor.index - @column_max * x, 90)
- else
- x = 260 #272
- draw_actor_graphic(actor, 20 + actor.index * x, 8)
- draw_actor_name(actor, 96 + actor.index * x, 10)
- draw_actor_hp(actor, 96 + actor.index * x, y + WLH * 1 + 4, 120, true)
- draw_actor_mp(actor, 96 + actor.index * x, y + WLH * 2 + 4, 120, true)
- draw_actor_level(actor, 174 + actor.index * x, 10)
- end
- x = actor.index * 96 + WLH / 2
- y = 0
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Level
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_level(actor, x, y)
- self.contents.font.color = system_color
- self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw Actor Walking Graphic
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_graphic(actor, x, y)
- character_name = actor.character_name
- bitmap = Cache.character(character_name)
- sign = character_name[/^[\!\$]./]
- if sign != nil and sign.include?('$')
- cw = bitmap.width / 3
- ch = bitmap.height / 4
- else
- cw = bitmap.width / 12
- ch = bitmap.height / 8
- end
- n = actor.character_index
- src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
- dest_rect = Rect.new(x, y, 80, 80)
- dest_rect = Rect.new(x, y, 65, 65)
- self.contents.stretch_blt(dest_rect, bitmap, src_rect)
- end
- #--------------------------------------------------------------------------
- # * Draw Name
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_name(actor, x, y)
- self.contents.font.color = hp_color(actor)
- self.contents.draw_text(x, y, 75, WLH, actor.name)
- end
- #--------------------------------------------------------------------------
- # * Update cursor
- #--------------------------------------------------------------------------
- def update_cursor
- if @index < 0 # No cursor
- self.cursor_rect.empty
- end
- case @index
- when 0, 1
- self.cursor_rect.set(19 + @index * 258, 0, 210, 86)
- when 2, 3
- self.cursor_rect.set(19 + @index * 258 - @index - @column_max * 258, 80, 210, 86)
- when 100
- self.cursor_rect.set(16, 0, contents.width-38, 163)
- end
- end
- end
- #==============================================================================
- # ** Window_Gold & Time
- #------------------------------------------------------------------------------
- # This window displays the amount of gold and played time.
- #==============================================================================
- class Window_Gold_Time < Window_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y coordinate
- #--------------------------------------------------------------------------
- def initialize(x, y, width = 260, height = 80)
- super(x, y, width, height)
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.back_opacity = 255
- refresh
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- self.contents.clear
- self.contents.font.size = 25
- draw_playtime(0, 0, self.width-32, 0)
- draw_currency_value($game_party.gold, 0, 26, self.width-32)
- end
- #--------------------------------------------------------------------------
- # * Draw Play Time
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- # width : Width
- # align : Alignment
- #--------------------------------------------------------------------------
- def draw_playtime(x, y, width, align)
- @total_sec = Graphics.frame_count / Graphics.frame_rate
- hour = @total_sec / 60 / 60
- min = @total_sec / 60 % 60
- sec = @total_sec % 60
- time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 12, y, width, WLH, "TIME")
- self.contents.draw_text(x, y, width - 12, WLH + 2, time_string, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw number with currency unit
- # value : Number (gold, etc)
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # width : Width
- #--------------------------------------------------------------------------
- def draw_currency_value(value, x, y, width)
- cx = contents.text_size(Vocab::gold).width
- self.contents.font.color = normal_color
- self.contents.draw_text(x, y, width-12, WLH, value, 2)
- self.contents.draw_text(x + 12, y, width, WLH, "GOLD")
- end
- end
- #==============================================================================
- # ** TDS_Lufia_Window_Item
- #------------------------------------------------------------------------------
- # This window displays a list of inventory items for the item screen, etc.
- #==============================================================================
- class TDS_Lufia_Window_Item < Window_Selectable
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :drop_mode # Drop flag
- attr_reader :item_mode # Item display flag
- attr_reader :all_mode # All item display flag
- attr_reader :scenario_mode # Scenario display flag
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window x-coordinate
- # y : window y-coordinate
- # width : window width
- # height : window height
- #--------------------------------------------------------------------------
- def initialize(x, y, width, height)
- super(x, y, width, height)
- @use_custom_cursor = true
- @column_max = 1
- self.index = 0
- self.back_opacity = 255
- self.windowskin = Cache.system("TDS-Lufia Window")
- @drop_mode = false
- @item_mode = true
- @all_mode = false
- @scenario_mode = false
- refresh
- end
- #--------------------------------------------------------------------------
- # * Only Items Mode
- #--------------------------------------------------------------------------
- def all_items_mode(value)
- @all_mode = value
- end
- #--------------------------------------------------------------------------
- # * Only Items Mode
- #--------------------------------------------------------------------------
- def only_items_mode(value)
- @item_mode = value
- end
- #--------------------------------------------------------------------------
- # * Drop Items Mode
- #--------------------------------------------------------------------------
- def drop_items_mode(value)
- @drop_mode = value
- end
- #--------------------------------------------------------------------------
- # * Scenario Items Mode
- #--------------------------------------------------------------------------
- def scenario_items_mode(value)
- @scenario_mode = value
- end
- #--------------------------------------------------------------------------
- # * Get Item
- #--------------------------------------------------------------------------
- def item
- return @data[self.index]
- end
- #--------------------------------------------------------------------------
- # * Whether or not to include in item list
- # item : item
- #--------------------------------------------------------------------------
- def include?(item)
- return false if item == nil
- if $game_temp.in_battle
- return false unless item.is_a?(RPG::Item)
- end
- return true
- end
- #--------------------------------------------------------------------------
- # * Whether or not to display in enabled state
- # item : item
- #--------------------------------------------------------------------------
- def enable?(item)
- return $game_party.item_can_use?(item)
- end
- #--------------------------------------------------------------------------
- # * Drop item
- # item : item
- #--------------------------------------------------------------------------
- def drop_item(item)
- $game_party.lose_item(item, $game_party.item_number(item))
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- @data = []
- for item in $game_party.items
- next unless include?(item)
- next if @item_mode == true and !$game_party.item_can_use?(item)
- next if @scenario_mode == true and !item.element_set.include?(17)
- if @item_mode == true
- if $game_party.item_can_use?(item) and !item.element_set.include?(17)
- @data.push(item)
- end
- end
- if @scenario_mode == true
- if item.element_set.include?(17)
- @data.push(item)
- end
- end
- if @all_mode
- if !item.element_set.include?(17)
- @data.push(item)
- end
- end
- if item.is_a?(RPG::Item) and item.id == $game_party.last_item_id
- self.index = @data.size - 1
- end
- end
- @data.push(nil) if include?(nil)
- @item_max = @data.size
- create_contents
- if @data.empty?
- @cursor_visible = false
- else
- @cursor_visible = true
- end
- for i in 0...@item_max
- draw_item(i)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Item
- # index : item number
- #--------------------------------------------------------------------------
- def draw_item(index)
- rect = item_rect(index)
- self.contents.clear_rect(rect)
- item = @data[index]
- if item != nil
- number = $game_party.item_number(item)
- enabled = enable?(item)
- rect.width -= 30
- draw_item_name(item, rect.x += 26, rect.y, enabled)
- rect.x -= 20
- self.contents.draw_text(rect, sprintf(":%2d", number), 2)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Item
- # index : item number
- #--------------------------------------------------------------------------
- def draw_item(index)
- rect = item_rect(index)
- self.contents.clear_rect(rect)
- item = @data[index]
- if item != nil
- number = $game_party.item_number(item)
- enabled = enable?(item)
- rect.width -= 30
- draw_item_name(item, rect.x += 26, rect.y, enabled)
- rect.x -= 20
- if @scenario_mode != true
- self.contents.draw_text(rect, sprintf(":%2d", number), 2)
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Update Help Text
- #--------------------------------------------------------------------------
- def update_help
- @help_window.set_text(item == nil ? "" : item.description)
- end
- end
- #==============================================================================
- # ** TDS_Lufia_Window_Skill
- #------------------------------------------------------------------------------
- # This window displays a list of usable skills on the skill screen, etc.
- #==============================================================================
- class TDS_Lufia_Window_Skill < Window_Selectable
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :use_skill_mode # Use skill display flag
- attr_reader :all_skill_mode # All skill display flag
- attr_reader :actor # Actor information
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window x-coordinate
- # y : window y-coordinate
- # width : window width
- # height : window height
- # actor : actor
- #--------------------------------------------------------------------------
- def initialize(x, y, width, height, actor)
- super(x, y, width, height)
- @actor = actor
- @column_max = 2
- @use_custom_cursor = true
- self.index = 0
- self.back_opacity = 255
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.index = 0
- @use_skill_mode = true
- @all_skill_mode = false
- refresh(@actor)
- end
- #--------------------------------------------------------------------------
- # * Only Use Skill Mode
- #--------------------------------------------------------------------------
- def only_use_skill_mode(value)
- @use_skill_mode = value
- end
- #--------------------------------------------------------------------------
- # * All skill display mode
- #--------------------------------------------------------------------------
- def all_skill_display_mode(value)
- @all_skill_mode = value
- end
- #--------------------------------------------------------------------------
- # * Get Skill
- #--------------------------------------------------------------------------
- def skill
- return @data[self.index]
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh(actor)
- @item_max = @data.size if @data != nil
- @data = []
- @actor = actor
- for skill in @actor.skills
- next if @use_skill_mode == true and skill_can_use?(skill) == false
- if @use_skill_mode == true
- @data.push(skill) if skill_can_use?(skill)
- end
- if @all_skill_mode == true
- @data.push(skill)
- end
- if skill.id == @actor.last_skill_id
- self.index = @data.size - 1
- end
- end
- @item_max = @data.size
- create_contents
- for i in 0...@item_max
- draw_item(i)
- end
- if @data.empty?
- @cursor_visible = false
- else
- @cursor_visible = true
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Item
- # index : item number
- #--------------------------------------------------------------------------
- def draw_item(index)
- rect = item_rect(index)
- self.contents.clear_rect(rect)
- skill = @data[index]
- if skill != nil
- rect.width -= 4
- enabled = skill_can_use?(skill, true) # @actor.skill_can_use?(skill)
- draw_item_name(skill, rect.x + 26, rect.y, enabled)
- self.contents.draw_text(rect, @actor.calc_mp_cost(skill), 2)
- end
- end
- #--------------------------------------------------------------------------
- # * Determine Usable Skills
- # skill : skill
- #--------------------------------------------------------------------------
- def skill_can_use?(skill,dead = false)
- skill = @data[index] if skill == nil
- return false unless skill.is_a?(RPG::Skill)
- return false unless @actor.movable? if dead == true
- return false if @actor.silent? and skill.spi_f > 0
- return false if @actor.calc_mp_cost(skill) > @actor.mp if dead == true
- return skill.menu_ok?
- end
- #--------------------------------------------------------------------------
- # * Update Help Text
- #--------------------------------------------------------------------------
- def update_help
- @help_window.set_text(skill == nil ? "" : skill.description)
- end
- end
- #==============================================================================
- # ** Scene_Status
- #------------------------------------------------------------------------------
- # This class performs the status screen processing.
- #==============================================================================
- class Scene_Status < Scene_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # actor_index : actor index
- #--------------------------------------------------------------------------
- def initialize(actor_index = 0)
- @actor_index = actor_index
- end
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- super
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- @actor = $game_party.members[@actor_index]
- # Create Status Header Window
- @status_header = Window_Base.new(14, 330, 140, 56)
- @status_header.windowskin = Cache.system("TDS-Lufia Window")
- @status_header.back_opacity = 255
- @status_header.contents = Bitmap.new(140-32,56-32)
- @status_header.contents.font.color = @status_header.text_color(0)
- @status_header.contents.draw_text(0,0,140-32,56-32, "STATUS",1)
- # Create Status Window
- @status_window = Window_Status.new(@actor)
- # Create command window
- @command_window = TDS_Window_Command.new(370, ["NEXT", "PREVIOUS", "RETURN"],
- 3, 0)
- @command_window.active = true
- @command_window.x = 154 #120 + 14
- @command_window.y = 330
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- super
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- @status_window.dispose
- @status_header.dispose
- @command_window.dispose
- end
- #--------------------------------------------------------------------------
- # * Return to Original Screen
- #--------------------------------------------------------------------------
- def return_scene
- $scene = Scene_Menu.new(1)
- end
- #--------------------------------------------------------------------------
- # * Switch to Next Actor Screen
- #--------------------------------------------------------------------------
- def next_actor
- @actor_index += 1
- @actor_index %= $game_party.members.size
- @status_window.refresh($game_party.members[@actor_index])
- end
- #--------------------------------------------------------------------------
- # * Switch to Previous Actor Screen
- #--------------------------------------------------------------------------
- def prev_actor
- @actor_index += $game_party.members.size - 1
- @actor_index %= $game_party.members.size
- @status_window.refresh($game_party.members[@actor_index])
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- @command_window.update
- @status_window.update
- if Input.trigger?(Input::B)
- Sound.play_cancel
- return_scene
- end
- if Input.trigger?(Input::C)
- case @command_window.index
- when 0
- Sound.play_cursor
- next_actor
- when 1
- Sound.play_cursor
- prev_actor
- when 2
- Sound.play_cancel
- return_scene
- end
- end
- super
- end
- end
- #==============================================================================
- # ** Window_Status
- #------------------------------------------------------------------------------
- # This window displays full status specs on the status screen.
- #==============================================================================
- class Window_Status < Window_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # actor : actor
- #--------------------------------------------------------------------------
- def initialize(actor)
- super(0, 0, 544, 416)
- self.opacity = 0
- self.contents.font.size = 20
- @actor = actor
- refresh(@actor)
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh(actor)
- @actor = actor
- self.contents.clear
- draw_actor_name(@actor, 78, 24)
- self.contents.font.color = system_color
- self.contents.draw_text(260, 24, 80, WLH, "CLASS")
- self.contents.draw_text(260, 48, 80, WLH, "STATES")
- self.contents.font.color = normal_color
- draw_actor_class(@actor, 308 + 30, 24)
- draw_actor_graphic(@actor, 8, 24)
- draw_basic_info(128, 24)
- draw_parameters(55, 110)
- draw_exp_info(60, 218)
- draw_equipments(262, 110)
- end
- #--------------------------------------------------------------------------
- # * Draw Basic Information
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_basic_info(x, y)
- draw_actor_level(@actor, x + 25, y + WLH * 0)
- draw_actor_state(@actor, x + 180 + 30, y + WLH * 1)
- draw_actor_hp(@actor, 78, y + WLH * 2 -24, 120, true)
- draw_actor_mp(@actor, 78, y + WLH * 3 -24, 120, true)
- end
- #--------------------------------------------------------------------------
- # * Draw Parameters
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_parameters(x, y)
- draw_actor_parameter(@actor, x, y + WLH * 0, 0)
- draw_actor_parameter(@actor, x, y + WLH * 1, 1)
- draw_actor_parameter(@actor, x, y + WLH * 2, 2)
- draw_actor_parameter(@actor, x, y + WLH * 3, 3)
- end
- #--------------------------------------------------------------------------
- # * Draw Experience Information
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_exp_info(x, y)
- s1 = @actor.exp_s
- s2 = @actor.next_rest_exp_s
- s_next = sprintf(Vocab::ExpNext, Vocab::level)
- self.contents.font.color = system_color
- self.contents.draw_text(x, y + WLH * 0, 180, WLH, "NOW EXP")
- self.contents.draw_text(x, y + WLH * 2 , 180, WLH, "NEXT LEVEL")
- self.contents.font.color = normal_color
- self.contents.draw_text(x - 30, y + WLH * 1, 180, WLH, s1, 2)
- self.contents.draw_text(x - 30, y + WLH * 3 , 180, WLH, s2, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw Actor Walking Graphic
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_graphic(actor, x, y)
- character_name = actor.character_name
- bitmap = Cache.character(character_name)
- sign = character_name[/^[\!\$]./]
- if sign != nil and sign.include?('$')
- cw = bitmap.width / 3
- ch = bitmap.height / 4
- else
- cw = bitmap.width / 12
- ch = bitmap.height / 8
- end
- n = actor.character_index
- src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
- dest_rect = Rect.new(x, y, 80, 80)
- dest_rect = Rect.new(x, y, 65, 65)
- self.contents.stretch_blt(dest_rect, bitmap, src_rect)
- end
- #--------------------------------------------------------------------------
- # * Draw State
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # width : draw spot width
- #--------------------------------------------------------------------------
- def draw_actor_state(actor, x, y, width = 96)
- count = 0
- if actor.states.empty?
- self.contents.draw_text(x, y, 80, WLH, "Fine")
- end
- for state in actor.states
- draw_icon(state.icon_index, x + 24 * count, y)
- count += 1
- break if (24 * count > width - 24)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Level
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_level(actor, x, y)
- self.contents.font.color = system_color
- self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw Name
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_name(actor, x, y)
- self.contents.font.color = hp_color(actor)
- self.contents.draw_text(x, y, 75, WLH, actor.name)
- end
- #--------------------------------------------------------------------------
- # * Draw Equipment
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_equipments(x, y)
- self.contents.font.color = system_color
- for i in 0..4
- self.contents.font.size = 25
- if @actor.equips[i] == nil
- self.contents.draw_text(x + 37, y + i * 32, 100, WLH, "No Equip")
- end
- draw_item_name(@actor.equips[i], x , y + i * 32)
- end
- self.contents.font.size = 20
- end
- #--------------------------------------------------------------------------
- # * Draw Item Name
- # item : Item (skill, weapon, armor are also possible)
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # enabled : Enabled flag. When false, draw semi-transparently.
- #--------------------------------------------------------------------------
- def draw_item_name(item, x, y, enabled = true)
- if item != nil
- draw_icon(item.icon_index, x + 2, y, enabled)
- self.contents.font.color = Color.new(255, 255, 255, 255)
- self.contents.font.color.alpha = enabled ? 255 : 128
- self.contents.draw_text(x + 31, y, 290, WLH, item.name)
- end
- end
- end
- #==============================================================================
- # ** Scene_Equip
- #------------------------------------------------------------------------------
- # This class performs the equipment screen processing.
- #==============================================================================
- class Scene_Equip < Scene_Base
- #--------------------------------------------------------------------------
- # * Constants
- #--------------------------------------------------------------------------
- EQUIP_TYPE_MAX = 5 # Number of equip region
- #--------------------------------------------------------------------------
- # * Object Initialization
- # actor_index : actor index
- # equip_index : equipment index
- #--------------------------------------------------------------------------
- def initialize(actor_index = 0, equip_index = 0, command_index = 0)
- @actor_index = actor_index
- @equip_index = equip_index
- @command_index = command_index
- @viewing_item_window_info = false
- @viewing_equip_window_info = false
- @remove_item_mode = false
- @drop_item_mode = false
- @item_index_return = 0
- end
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- super
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- # Actor information
- @actor = $game_party.members[@actor_index]
- # Create command window
- @command_window = TDS_Window_Command.new(247, ["EQUIP", "STRONGEST",
- "REMOVE", "REMOVE ALL", "DROP"])
- @command_window.x = 250
- @command_window.y = 247
- @command_window.index = @command_index
- if @actor.fix_equipment
- for i in 0...@command_window.commands.size
- @command_window.draw_item(i, false)
- end
- end
- @equip_window = Window_Equip.new(228, 56, @actor)
- @equip_window.index = @equip_index
- @equip_window.active = false
- @equip_window.change_cursor_visibility(false)
- @status_window = Window_EquipStatus.new(0, 0, @actor)
- create_item_windows
- update_item_windows
- # Create Dummy help window
- @dummy_help_window = Window_Base.new(18, 298, 510, 101)
- @dummy_help_window.windowskin = Cache.system("TDS-Lufia Window")
- @dummy_help_window.contents = Bitmap.new(510-32,56-32)
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32, "Help window text test")
- @dummy_help_window.back_opacity = 255
- @dummy_help_window.visible = false
- @dummy_help_window.z = 5000
- # Create Help Window Header
- @scene_help_header = Window_Base.new(18, 247, 510, 56)
- @scene_help_header.windowskin = Cache.system("TDS-Lufia Window")
- @scene_help_header.back_opacity = 255
- @scene_help_header.contents = Bitmap.new(510-32,56-32)
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.draw_text(0, 0 , 505-32,56-32, "Item name",1)
- @scene_help_header.visible = false
- @scene_help_header.z = 5000
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- super
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- @command_window.dispose
- @equip_window.dispose
- @status_window.dispose
- dispose_item_windows
- @dummy_help_window.dispose
- @scene_help_header.dispose
- end
- #--------------------------------------------------------------------------
- # * Update Frame
- #--------------------------------------------------------------------------
- def update
- super
- # Update windows
- @command_window.update
- @equip_window.update
- update_status_window
- update_item_windows
- # If not viewing any info and command window active
- if @viewing_equip_window_info == false and @viewing_item_window_info == false and
- @command_window.active == true
- if Input.trigger?(Input::R)
- Sound.play_cursor
- next_actor
- elsif Input.trigger?(Input::L)
- Sound.play_cursor
- prev_actor
- end
- end
- # If command Window active
- if @command_window.active
- update_command_selection
- end
- # If equip window active or viewing equip item info
- if @equip_window.active or @viewing_equip_window_info
- update_equip_selection
- @equip_window.change_cursor_visibility(true)
- else
- if @item_window.active == false and @viewing_item_window_info == false
- @equip_window.change_cursor_visibility(false)
- end
- end
- # If item window active or viewing item window info
- if @item_window.active or @viewing_item_window_info
- update_item_selection
- end
- end
- #--------------------------------------------------------------------------
- # * Update Command Selection
- #--------------------------------------------------------------------------
- def update_command_selection
- if Input.trigger?(Input::B)
- Sound.play_cancel
- $scene = Scene_Menu.new(3)
- end
- # If input trigger
- if Input.trigger?(Input::C)
- if @actor.fix_equipment
- Sound.play_buzzer
- return
- end
- case @command_window.index
- when 0 # Equip
- Sound.play_decision
- @command_window.active = false
- @command_window.visible = false
- @item_window.visible = true
- @equip_window.active = true
- @remove_item_mode = false
- @drop_item_mode = false
- Input.update
- when 1 # Equip Strongest
- Sound.play_equip
- for i in 0...3
- equip_strongest_armor(i, i+1)
- end
- for i in 0...5
- @item_windows[i].refresh
- end
- equip_strongest_weapon
- @status_window.refresh
- Input.update
- return
- when 2 # Remove
- Sound.play_decision
- @command_window.active = false
- @equip_window.active = true
- @item_window.visible = false
- @remove_item_mode = true
- Input.update
- when 3 # Remove all
- Sound.play_equip
- old_equip_index = @equip_window.index
- for i in 0...5
- @actor.change_equip(i, nil)
- @equip_window.index = i
- @item_windows[i].refresh
- if @equip_window.item != nil
- equip_redraw_index = @item_windows[i].return_item_index(@equip_window.item)
- if equip_redraw_index != nil
- @item_windows[i].draw_item(equip_redraw_index)
- end
- end
- @status_window.refresh
- end
- @equip_window.index = old_equip_index
- @equip_window.refresh
- when 4 # Drop
- Sound.play_decision
- @command_window.active = false
- @equip_window.active = true
- @item_window.visible = false
- @drop_item_mode = true
- Input.update
- end
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Equip Region Selection
- #--------------------------------------------------------------------------
- def update_equip_selection
- if Input.trigger?(Input::B)
- Sound.play_cancel
- if @viewing_equip_window_info
- if @drop_item_mode == true or @remove_item_mode == true
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @command_window.visible = true
- @equip_window.active = true
- @scene_help_header.contents.clear
- @viewing_equip_window_info = false
- return
- end
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @item_window.visible = true
- @equip_window.active = true
- @scene_help_header.contents.clear
- @viewing_equip_window_info = false
- @remove_item_mode = false
- @drop_item_mode = false
- return
- end
- @item_window.visible = false
- @equip_window.active = false
- @equip_window.change_cursor_visibility(false)
- @command_window.active = true
- @command_window.visible = true
- @remove_item_mode = false
- @drop_item_mode = false
- end
- if Input.trigger?(Input::C) and @viewing_equip_window_info == false
- if @remove_item_mode == true
- if @actor.fix_equipment or @equip_window.item == nil
- Sound.play_buzzer
- Input.update
- return
- else
- Sound.play_equip
- draw_index = @item_window.return_item_index(@equip_window.item)
- @actor.change_equip(@equip_window.index, nil)
- if draw_index != nil
- @item_window.draw_item(draw_index)
- end
- @item_window.refresh
- @equip_window.refresh
- @status_window.refresh
- Input.update
- return
- end
- end
- if @drop_item_mode == true
- if @actor.fix_equipment or @equip_window.item == nil
- Sound.play_buzzer
- Input.update
- return
- else
- Sound.play_equip
- draw_index = @item_window.return_item_index(@equip_window.item)
- @actor.change_equip(@equip_window.index, nil)
- $game_party.lose_item(@equip_window.item, 1, true)
- @equip_window.refresh
- if draw_index != nil
- @item_window.draw_item(draw_index)
- end
- @item_window.refresh
- @status_window.refresh
- Input.update
- return
- end
- end
- if @actor.fix_equipment or @item_window.item_max == 0
- Sound.play_buzzer
- else
- Sound.play_decision
- @equip_window.active = false
- @item_window.active = true
- @item_window.index = 0
- Input.update
- end
- end
- if Input.trigger?(Input::CTRL)
- if @viewing_equip_window_info == false
- return Sound.play_buzzer if @equip_window.item == nil
- Sound.play_decision
- if @drop_item_mode == true or @remove_item_mode == true
- @command_window.active = false
- @command_window.visible = false
- @equip_window.active = false
- @dummy_help_window.visible = true
- @scene_help_header.visible = true
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @equip_window.item.name,1)
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32, @equip_window.item.description.capitalize)
- @viewing_equip_window_info = true
- return
- end
- @dummy_help_window.visible = true
- @scene_help_header.visible = true
- @item_window.visible = false
- @equip_window.active = false
- @item_index_return = @item_window.index
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @equip_window.item.name,1)
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32, @equip_window.item.description.capitalize)
- @item_window.index = -1
- @viewing_equip_window_info = true
- else
- if @drop_item_mode == true or @remove_item_mode == true
- Sound.play_decision
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @command_window.visible = true
- @equip_window.active = true
- @scene_help_header.contents.clear
- @viewing_equip_window_info = false
- return
- end
- Sound.play_decision
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @item_window.visible = true
- @equip_window.active = true
- @scene_help_header.contents.clear
- @viewing_equip_window_info = false
- end
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Item Selection
- #--------------------------------------------------------------------------
- def update_item_selection
- if Input.trigger?(Input::B)
- Sound.play_cancel
- if @viewing_item_window_info
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @item_window.active = true
- @item_window.visible = true
- @item_window.index = @item_index_return
- @scene_help_header.contents.clear
- @viewing_item_window_info = false
- return
- end
- @equip_window.active = true
- @item_window.active = false
- @item_window.index = -1
- end
- if Input.trigger?(Input::C) and @viewing_item_window_info == false
- Sound.play_equip
- @actor.change_equip(@equip_window.index, @item_window.item)
- @equip_window.active = true
- @item_window.active = false
- @item_window.index = -1
- @equip_window.refresh
- for item_window in @item_windows
- item_window.refresh
- end
- end
- if Input.trigger?(Input::CTRL)
- Sound.play_decision
- if @viewing_item_window_info == false
- @dummy_help_window.visible = true
- @scene_help_header.visible = true
- @item_window.visible = false
- @item_window.active = false
- @item_index_return = @item_window.index
- @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
- @scene_help_header.contents.clear
- @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @item_window.item.name,1)
- @dummy_help_window.contents.font.color = @dummy_help_window.text_color(0)
- @dummy_help_window.contents.clear
- @dummy_help_window.contents.font.size = 22
- @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32, @item_window.item.description.capitalize)
- @item_window.index = -1
- @viewing_item_window_info = true
- else
- @dummy_help_window.visible = false
- @scene_help_header.visible = false
- @item_window.active = true
- @item_window.visible = true
- @item_window.index = @item_index_return
- @scene_help_header.contents.clear
- @viewing_item_window_info = false
- end
- return
- end
- end
- #--------------------------------------------------------------------------
- # * Update Status Window
- #--------------------------------------------------------------------------
- def update_status_window
- if @equip_window.active
- @status_window.set_new_parameters(nil, nil, nil, nil)
- elsif @item_window.active
- temp_actor = @actor.clone
- temp_actor.change_equip(@equip_window.index, @item_window.item, true)
- new_atk = temp_actor.atk
- new_def = temp_actor.def
- new_spi = temp_actor.spi
- new_agi = temp_actor.agi
- @status_window.set_new_parameters(new_atk, new_def, new_spi, new_agi)
- end
- @status_window.update
- end
- #--------------------------------------------------------------------------
- # * Equip Strongest Weapon
- #--------------------------------------------------------------------------
- def equip_strongest_weapon
- # Owned weapons array
- weapons = []
- # Actor class weapon set
- weapon_set = @actor.class.weapon_set
- # Block
- weapon_set.each do |i|
- next if $game_party.has_item?($data_weapons[i]) == false
- next if @actor.equippable?($data_weapons[i]) == false
- # Push weapon values into weapons variable
- weapons << $data_weapons[i]
- end
- # Return if weaponsa array is empty
- return if weapons == []
- # If actors currently equiped weapon is nil
- if @actor.weapons[0] == nil
- ver_weapon = weapons[0]
- else
- ver_weapon = @actor.weapons[0]
- end
- for weapon in weapons
- next if weapon.two_handed
- if ver_weapon.atk < weapon.atk
- ver_weapon = weapon
- end
- end
- # Equip Strongest Weapon
- @actor.change_equip(0, ver_weapon)
- # Reresh equip window
- @equip_window.refresh
- end
- #--------------------------------------------------------------------------
- # * Equip Strongest Armor
- #--------------------------------------------------------------------------
- def equip_strongest_armor(armor_kind , index)
- # Owned armors array
- armors = []
- # Actor class armor set
- armor_set = @actor.class.armor_set
- # Block
- armor_set.each do |i|
- next if $data_armors[i].kind == 3
- next if $game_party.has_item?($data_armors[i]) == false
- next if @actor.armors[armor_kind] == $data_armors[i]
- if $data_armors[i].kind == armor_kind
- armors << $data_armors[i]
- end
- end
- # Return if armors array is empty
- return if armors == []
- # If actor armor is nil
- if @actor.armors[armor_kind] == nil
- ver_armor = armors[0]
- else
- ver_armor = @actor.armors[armor_kind]
- end
- for armor in armors
- if ver_armor.def < armor.def
- ver_armor = armor
- end
- end
- # Equip strongest armor
- @actor.change_equip(index, ver_armor)
- # Reresh equip window
- @equip_window.refresh
- end
- #--------------------------------------------------------------------------
- # * Create Item Window
- #--------------------------------------------------------------------------
- def create_item_windows
- @item_windows = []
- for i in 0...EQUIP_TYPE_MAX
- @item_windows[i] = Window_EquipItem.new(18, 247, 510, 152, @actor, i)
- @item_windows[i].visible = (@equip_index == i)
- @item_windows[i].active = false
- @item_windows[i].visible = false
- @item_windows[i].index = -1
- end
- end
- #--------------------------------------------------------------------------
- # * Dispose of Item Window
- #--------------------------------------------------------------------------
- def dispose_item_windows
- for window in @item_windows
- window.dispose
- end
- end
- #--------------------------------------------------------------------------
- # * Switch to Next Actor Screen
- #--------------------------------------------------------------------------
- def next_actor
- @actor_index += 1
- @actor_index %= $game_party.members.size
- @actor = $game_party.members[@actor_index]
- @status_window.refresh(@actor)
- @equip_window.refresh(@actor)
- create_item_windows
- update_item_windows
- @viewing_item_window_info = false
- @viewing_equip_window_info = false
- @remove_item_mode = false
- @drop_item_mode = false
- end
- #--------------------------------------------------------------------------
- # * Switch to Previous Actor Screen
- #--------------------------------------------------------------------------
- def prev_actor
- @actor_index += $game_party.members.size - 1
- @actor_index %= $game_party.members.size
- @actor = $game_party.members[@actor_index]
- @status_window.refresh(@actor)
- @equip_window.refresh(@actor)
- create_item_windows
- update_item_windows
- @viewing_item_window_info = false
- @viewing_equip_window_info = false
- @remove_item_mode = false
- @drop_item_mode = false
- end
- #--------------------------------------------------------------------------
- # * Update Item Window
- #--------------------------------------------------------------------------
- def update_item_windows
- for i in 0...EQUIP_TYPE_MAX
- @item_windows[i].visible = false if @command_window.active == true
- if @command_window.active == false and @remove_item_mode == false and
- @drop_item_mode == false
- @item_windows[i].visible = (@equip_window.index == i)
- @item_windows[i].update
- end
- end
- @item_window = @item_windows[@equip_window.index]
- end
- end
- #==============================================================================
- # ** Window_Equip
- #------------------------------------------------------------------------------
- # This window displays items the actor is currently equipped with on the
- # equipment screen.
- #==============================================================================
- class Window_Equip < Window_Selectable
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y corrdinate
- # actor : actor
- #--------------------------------------------------------------------------
- def initialize(x, y, actor)
- super(x, y, 290, 200)
- @actor = actor
- @use_custom_cursor = true
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.contents.font.color = Color.new(255, 255, 255, 255)
- self.opacity = 0
- refresh
- self.index = 0
- end
- #--------------------------------------------------------------------------
- # * Get Item
- #--------------------------------------------------------------------------
- def item
- return @data[self.index]
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh(actor = nil)
- self.contents.clear
- @actor = actor if actor != nil
- @data = []
- for item in @actor.equips do @data.push(item) end
- @item_max = @data.size
- for i in 0...@data.size
- if @data[i] == nil
- self.contents.font.color = Color.new(255, 255, 255, 255)
- self.contents.draw_text(48, 32 * i , 172, 24, "No Equip")
- end
- self.contents.font.color = Color.new(255, 255, 255, 255)
- draw_item_name(@data[i], 24, 32 * i)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Item Name
- # item : Item (skill, weapon, armor are also possible)
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # enabled : Enabled flag. When false, draw semi-transparently.
- #--------------------------------------------------------------------------
- def draw_item_name(item, x, y, enabled = true)
- if item != nil
- draw_icon(item.icon_index, x + 2, y, enabled)
- self.contents.font.color = Color.new(255, 255, 255, 255)
- self.contents.font.color.alpha = enabled ? 255 : 128
- self.contents.draw_text(x + 31, y, 290, WLH, item.name)
- end
- end
- #--------------------------------------------------------------------------
- # * Get rectangle for displaying items
- # index : item number
- #--------------------------------------------------------------------------
- def item_rect(index)
- rect = Rect.new(0, 0, 0, 0)
- rect.width = (contents.width + @spacing) / @column_max - @spacing
- rect.height = 25
- rect.x = index % @column_max * (rect.width + @spacing)
- rect.y = index / @column_max * 32
- return rect
- end
- end
- #==============================================================================
- # ** Window_EquipItem
- #------------------------------------------------------------------------------
- # This window displays choices when opting to change equipment on the
- # equipment screen.
- #==============================================================================
- class Window_EquipItem < Window_Item
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : sindow X coordinate
- # y : sindow Y corrdinate
- # width : sindow width
- # height : sindow height
- # actor : actor
- # equip_type : equip region (0-4)
- #--------------------------------------------------------------------------
- def initialize(x, y, width, height, actor, equip_type)
- @actor = actor
- if equip_type == 1 and actor.two_swords_style
- equip_type = 0 # Change shield to weapon
- end
- @equip_type = equip_type
- super(x, y, width, height)
- @column_max = 1
- @use_custom_cursor = true
- @normal_color = normal_color
- self.contents.font.color = @normal_color
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.back_opacity = 255
- refresh
- end
- #--------------------------------------------------------------------------
- # * Whether to include item in list
- # item : item
- #--------------------------------------------------------------------------
- def return_item_index(item)
- item_index = item
- item_index = @data.index(item)
- return item_index
- end
- #--------------------------------------------------------------------------
- # * Whether to include item in list
- # item : item
- #--------------------------------------------------------------------------
- def include?(item)
- return true if item == nil
- if @equip_type == 0
- return false unless item.is_a?(RPG::Weapon)
- else
- return false unless item.is_a?(RPG::Armor)
- return false unless item.kind == @equip_type - 1
- end
- return @actor.equippable?(item)
- end
- #--------------------------------------------------------------------------
- # * Draw Item
- # index : item number
- #--------------------------------------------------------------------------
- def draw_item(index)
- @item_max = @data.size-1
- rect = item_rect(index)
- self.contents.clear_rect(rect)
- self.contents.font.color = normal_color
- item = @data[index]
- if item != nil
- number = $game_party.item_number(item)
- enabled = enable?(item)
- rect.width -= 14
- draw_item_name(item, rect.x + 26, rect.y, enabled)
- self.contents.draw_text(rect, sprintf(":%2d", number), 2)
- end
- end
- #--------------------------------------------------------------------------
- # * Whether to display item in enabled state
- # item : item
- #--------------------------------------------------------------------------
- def enable?(item)
- return true
- end
- end
- #==============================================================================
- # ** Window_EquipStatus
- #------------------------------------------------------------------------------
- # This window displays actor parameter changes on the equipment screen, etc.
- #==============================================================================
- class Window_EquipStatus < Window_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y corrdinate
- # actor : actor
- #--------------------------------------------------------------------------
- def initialize(x, y, actor)
- super(x, y, 290, 300)
- @actor = actor
- self.opacity = 0
- self.contents.font.size = 20
- refresh
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh(actor = nil)
- self.contents.clear
- @actor = actor if actor != nil
- x = 128
- y = 24
- draw_actor_name(@actor, 78, y)
- draw_actor_graphic(@actor, 8, y)
- draw_actor_level(@actor, x + 25, y + WLH * 0)
- draw_actor_state(@actor, x + 180 + 30, y + WLH * 1)
- draw_actor_hp(@actor, 78, y + WLH * 2 -24, 120, true)
- draw_actor_mp(@actor, 78, y + WLH * 3 -24, 120, true)
- draw_parameter(55, 90 + WLH * 1, 0)
- draw_parameter(55, 90 + WLH * 2, 1)
- draw_parameter(55, 90 + WLH * 3, 2)
- draw_parameter(55, 90 + WLH * 4, 3)
- if self.active == false
- end
- end
- #--------------------------------------------------------------------------
- # * Set Parameters After Equipping
- # new_atk : attack after equipping
- # new_def : defense after equipping
- # new_spi : spirit after equipping
- # new_agi : agility after equipping
- #--------------------------------------------------------------------------
- def set_new_parameters(new_atk, new_def, new_spi, new_agi)
- if @new_atk != new_atk or @new_def != new_def or
- @new_spi != new_spi or @new_agi != new_agi
- @new_atk = new_atk
- @new_def = new_def
- @new_spi = new_spi
- @new_agi = new_agi
- refresh
- end
- end
- #--------------------------------------------------------------------------
- # * Get Post Equip Parameter Drawing Color
- # old_value : parameter before equipment change
- # new_value : parameter after equipment change
- #--------------------------------------------------------------------------
- def new_parameter_color(old_value, new_value)
- if new_value > old_value # Get stronger
- return power_up_color
- elsif new_value == old_value # No change
- return normal_color
- else # Get weaker
- return power_down_color
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Parameters
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # type : type of parameter (0 - 3)
- #--------------------------------------------------------------------------
- def draw_parameter(x, y, type)
- case type
- when 0
- name = Vocab::atk
- value = @actor.atk
- new_value = @new_atk
- when 1
- name = Vocab::def
- value = @actor.def
- new_value = @new_def
- when 2
- name = Vocab::spi
- value = @actor.spi
- new_value = @new_spi
- when 3
- name = Vocab::agi
- value = @actor.agi
- new_value = @new_agi
- end
- self.contents.font.color = system_color
- self.contents.draw_text(x + 4, y, 80, WLH, name)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 50, y, 30, WLH, value, 2)
- self.contents.font.color = system_color
- stat_icons_positive = [120, 121, 122, 123]
- stat_icons_negative = [124, 125, 126, 127]
- if new_value != nil
- if new_value > value
- draw_icon(stat_icons_positive[type], x + 84, y-4, enabled = true)
- elsif new_value < value
- draw_icon(stat_icons_negative[type], x + 84, y, enabled = true)
- else
- draw_equal_icon(x + 84, y-2, enabled = true)
- end
- end
- if new_value != nil
- self.contents.font.color = new_parameter_color(value, new_value)
- self.contents.draw_text(x + 110, y, 30, WLH, new_value, 2)
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Actor Walking Graphic
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_graphic(actor, x, y)
- character_name = actor.character_name
- bitmap = Cache.character(character_name)
- sign = character_name[/^[\!\$]./]
- if sign != nil and sign.include?('$')
- cw = bitmap.width / 3
- ch = bitmap.height / 4
- else
- cw = bitmap.width / 12
- ch = bitmap.height / 8
- end
- n = actor.character_index
- src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
- dest_rect = Rect.new(x, y, 80, 80)
- dest_rect = Rect.new(x, y, 65, 65)
- self.contents.stretch_blt(dest_rect, bitmap, src_rect)
- end
- #--------------------------------------------------------------------------
- # * Draw Equal Icon
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- # enabled : Enabled flag. When false, draw semi-transparently.
- #--------------------------------------------------------------------------
- def draw_equal_icon(x, y, enabled = true)
- bitmap = Cache.system("Equal Icon")
- rect = Rect.new(0, 0, 24, 24)
- self.contents.blt(x, y, bitmap, rect, enabled ? 255 : 128)
- end
- #--------------------------------------------------------------------------
- # * Draw Name
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_name(actor, x, y)
- self.contents.font.color = hp_color(actor)
- self.contents.draw_text(x, y, 75, WLH, actor.name)
- end
- #--------------------------------------------------------------------------
- # * Draw Level
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_level(actor, x, y)
- self.contents.font.color = system_color
- self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
- end
- end
- #==============================================================================
- # ** Scene_File
- #------------------------------------------------------------------------------
- # This class performs the save and load screen processing.
- #==============================================================================
- class Scene_File < Scene_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # saving : save flag (if false, load screen)
- # from_title : flag: it was called from "Continue" on the title screen
- # from_event : flag: it was called from the "Call Save Screen" event
- # return_index : value index when returning to the scene
- #--------------------------------------------------------------------------
- def initialize(saving, from_title, from_event, return_index = nil)
- @saving = saving
- @from_title = from_title
- @from_event = from_event
- @return_index = return_index
- @updating_exit = false
- end
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- super
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- if @saving == false
- load_database # Load databasee
- else
- # Create Scene Header
- @scene_header = Window_Base.new(18, 32, 140, 56)
- @scene_header.windowskin = Cache.system("TDS-Lufia Window")
- @scene_header.back_opacity = 255
- @scene_header.contents = Bitmap.new(140-32,56-32)
- @scene_header.contents.font.color = @scene_header.text_color(0)
- @scene_header.contents.draw_text(0,0,140-32,56-32, "SAVE",1)
- end
- create_savefile_windows
- # Create Scene Header
- @first_save_header = Window_Base.new(137, 32, 389, 56)
- @first_save_header.windowskin = Cache.system("TDS-Lufia Window")
- @first_save_header.back_opacity = 255
- @first_save_header.contents = Bitmap.new(140-32,56-32)
- @first_save_header.contents.font.color = @first_save_header.text_color(0)
- @first_save_header.contents.draw_text(0,0,140-32,56-32, "Game Saved.",0)
- @first_save_header.visible = false
- if @saving
- @index = $game_temp.last_file_index
- else
- @index = self.latest_file_index
- end
- if @return_index != nil
- @index = @return_index
- end
- @savefile_windows[@index].selected = true
- end
- #--------------------------------------------------------------------------
- # * Load Database
- #--------------------------------------------------------------------------
- def load_database
- $data_actors = load_data("Data/Actors.rvdata")
- $data_classes = load_data("Data/Classes.rvdata")
- $data_skills = load_data("Data/Skills.rvdata")
- $data_items = load_data("Data/Items.rvdata")
- $data_weapons = load_data("Data/Weapons.rvdata")
- $data_armors = load_data("Data/Armors.rvdata")
- $data_enemies = load_data("Data/Enemies.rvdata")
- $data_troops = load_data("Data/Troops.rvdata")
- $data_states = load_data("Data/States.rvdata")
- $data_animations = load_data("Data/Animations.rvdata")
- $data_common_events = load_data("Data/CommonEvents.rvdata")
- $data_system = load_data("Data/System.rvdata")
- $data_areas = load_data("Data/Areas.rvdata")
- end
- #--------------------------------------------------------------------------
- # * Command: New Game
- #--------------------------------------------------------------------------
- def command_new_game
- confirm_player_location
- Sound.play_decision
- $game_party.setup_starting_members # Initial party
- $game_map.setup($data_system.start_map_id) # Initial map position
- $game_player.moveto($data_system.start_x, $data_system.start_y)
- $game_player.refresh
- $scene = Scene_Map.new
- RPG::BGM.fade(1500)
- Graphics.fadeout(60)
- Graphics.wait(40)
- Graphics.frame_count = 0
- RPG::BGM.stop
- $game_map.autoplay
- end
- #--------------------------------------------------------------------------
- # * Check Player Start Location Existence
- #--------------------------------------------------------------------------
- def confirm_player_location
- if $data_system.start_map_id == 0
- print "Player start location not set."
- exit
- end
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- super
- dispose_item_windows
- if @saving == true
- @scene_header.dispose
- end
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- @first_save_header.dispose
- end
- #--------------------------------------------------------------------------
- # * Return to Original Screen
- #--------------------------------------------------------------------------
- def return_scene
- if @from_event
- $scene = Scene_Map.new
- else
- if @saving == true
- $scene = Scene_Menu.new(5)
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- super
- update_savefile_windows
- if @updating_exit
- updating_first_time_save_exit
- return
- end
- update_savefile_selection
- end
- #--------------------------------------------------------------------------
- # * Create Save File Window
- #--------------------------------------------------------------------------
- def create_savefile_windows
- @savefile_windows = []
- for i in 0..4
- next if @saving == true and i == 0
- @savefile_windows.push(Window_SaveFile.new(i, "Save#{i}.rvdata"))
- end
- @item_max = (@saving == true ? 4 : 5 )
- end
- #--------------------------------------------------------------------------
- # * Dispose of Save File Window
- #--------------------------------------------------------------------------
- def dispose_item_windows
- for window in @savefile_windows
- window.dispose
- end
- end
- #--------------------------------------------------------------------------
- # * Update Save File Window
- #--------------------------------------------------------------------------
- def update_savefile_windows
- for window in @savefile_windows
- window.update
- window.update_cursor_graphic
- window.update_cursor_animation
- end
- end
- #--------------------------------------------------------------------------
- # * Update Save File Selection
- #--------------------------------------------------------------------------
- def update_savefile_selection
- if Input.trigger?(Input::C)
- determine_savefile
- elsif Input.trigger?(Input::B)
- if @saving == false
- return
- end
- Sound.play_cancel
- return_scene
- else
- last_index = @index
- return if @updating_exit
- if Input.repeat?(Input::DOWN)
- cursor_down(Input.trigger?(Input::DOWN))
- end
- if Input.repeat?(Input::UP)
- cursor_up(Input.trigger?(Input::UP))
- end
- if Input.repeat?(Input::LEFT)
- cursor_up(Input.trigger?(Input::LEFT))
- end
- if Input.repeat?(Input::RIGHT)
- cursor_down(Input.trigger?(Input::RIGHT))
- end
- if @index != last_index
- Sound.play_cursor
- @savefile_windows[last_index].selected = false
- @savefile_windows[@index].selected = true
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Updating first time save exit
- #--------------------------------------------------------------------------
- def updating_first_time_save_exit
- # Exit frame count
- @frames = 0 if @frames == nil
- @frames += 1 if @frames < 70
- if @frames == 70
- return_scene
- end
- end
- #--------------------------------------------------------------------------
- # * Confirm Save File
- #--------------------------------------------------------------------------
- def determine_savefile
- if @saving
- if @savefile_windows[@index].file_exist == false
- @first_save_header.visible = true
- Sound.play_save
- do_save
- else
- Sound.play_decision
- $scene = Scene_File_II.new(@savefile_windows[@index].filename, @saving,
- @index, @from_event)
- return
- end
- else
- if @savefile_windows[0].selected == true
- command_new_game
- return
- end
- if @savefile_windows[@index].file_exist
- Sound.play_decision
- $scene = Scene_File_II.new(@savefile_windows[@index].filename, @saving,
- @index, @from_event)
- else
- Sound.play_buzzer
- return
- end
- end
- $game_temp.last_file_index = @index
- end
- #--------------------------------------------------------------------------
- # * Move cursor down
- # wrap : Wraparound allowed
- #--------------------------------------------------------------------------
- def cursor_down(wrap)
- if @index < @item_max - 1 or wrap
- @index = (@index + 1) % @item_max
- end
- end
- #--------------------------------------------------------------------------
- # * Move cursor up
- # wrap : Wraparound allowed
- #--------------------------------------------------------------------------
- def cursor_up(wrap)
- if @index > 0 or wrap
- @index = (@index - 1 + @item_max) % @item_max
- end
- end
- #--------------------------------------------------------------------------
- # * Create Filename
- # file_index : save file index (0-4)
- #--------------------------------------------------------------------------
- def make_filename(file_index)
- return if file_index == 0
- return "Save#{file_index}.rvdata"
- end
- #--------------------------------------------------------------------------
- # * Select File With Newest Timestamp
- #--------------------------------------------------------------------------
- def latest_file_index
- index = 0
- latest_time = Time.at(0)
- for i in 1...@savefile_windows.size
- if @savefile_windows[i].time_stamp > latest_time
- latest_time = @savefile_windows[i].time_stamp
- index = i
- end
- end
- return index
- end
- #--------------------------------------------------------------------------
- # * Execute Save
- #--------------------------------------------------------------------------
- def do_save
- file = File.open(@savefile_windows[@index].filename, "wb")
- write_save_data(file)
- file.close
- @savefile_windows[@index].redraw_new_save_infofmation
- @updating_exit = true
- return
- end
- #--------------------------------------------------------------------------
- # * Write Save Data
- # file : write file object (opened)
- #--------------------------------------------------------------------------
- def write_save_data(file)
- characters = []
- for actor in $game_party.members
- characters.push([actor.character_name, actor.character_index])
- end
- $game_system.save_count += 1
- $game_system.version_id = $data_system.version_id
- @last_bgm = RPG::BGM::last
- @last_bgs = RPG::BGS::last
- Marshal.dump(characters, file)
- Marshal.dump(Graphics.frame_count, file)
- Marshal.dump(@last_bgm, file)
- Marshal.dump(@last_bgs, file)
- Marshal.dump($game_system, file)
- Marshal.dump($game_message, file)
- Marshal.dump($game_switches, file)
- Marshal.dump($game_variables, file)
- Marshal.dump($game_self_switches, file)
- Marshal.dump($game_actors, file)
- Marshal.dump($game_party, file)
- Marshal.dump($game_troop, file)
- Marshal.dump($game_map, file)
- Marshal.dump($game_player, file)
- end
- #--------------------------------------------------------------------------
- # * Read Save Data
- # file : file object for reading (opened)
- #--------------------------------------------------------------------------
- def read_save_data(file)
- characters = Marshal.load(file)
- Graphics.frame_count = Marshal.load(file)
- @last_bgm = Marshal.load(file)
- @last_bgs = Marshal.load(file)
- $game_system = Marshal.load(file)
- $game_message = Marshal.load(file)
- $game_switches = Marshal.load(file)
- $game_variables = Marshal.load(file)
- $game_self_switches = Marshal.load(file)
- $game_actors = Marshal.load(file)
- $game_party = Marshal.load(file)
- $game_troop = Marshal.load(file)
- $game_map = Marshal.load(file)
- $game_player = Marshal.load(file)
- if $game_system.version_id != $data_system.version_id
- $game_map.setup($game_map.map_id)
- $game_player.center($game_player.x, $game_player.y)
- end
- end
- end
- #==============================================================================
- # ** Scene_File_II
- #------------------------------------------------------------------------------
- # This class performs the save and load screen processing when rewriting.
- #==============================================================================
- class Scene_File_II < Scene_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # file : Save file to load data from
- # saving : save flag (if false, load screen)
- # return_index : index to return
- #--------------------------------------------------------------------------
- def initialize(file, saving, return_index, from_event)
- @file = file
- @saving = saving
- @return_index = return_index
- @from_event = from_event
- load_saved_game_data(@file)
- end
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- # Create Status window
- @status_window = Window_File_MenuStatus.new(0, 0, @game_party)
- @status_window.active = false
- # Get map information
- map_info = load_data("Data/MapInfos.rvdata")
- # Get map name
- map_name = map_info[@game_map.map_id].name
- # Create map name window header
- @map_name_header = Window_Base.new(18, 198, 505, 76)
- @map_name_header.windowskin = Cache.system("TDS-Lufia Window")
- @map_name_header.back_opacity = 255
- @map_name_header.contents = Bitmap.new(505-32, 76-32)
- @map_name_header.contents.font.size = 37
- @map_name_header.contents.font.color = @map_name_header.text_color(0)
- @map_name_header.contents.draw_text(18, 7 , 505-32, 37, map_name.to_s, 0)
- # Create dummy command window header
- @dummy_command_window_header = Window_Base.new(358, 274, 165, 135)
- @dummy_command_window_header.windowskin = Cache.system("TDS-Lufia Window")
- @dummy_command_window_header.back_opacity = 255
- @dummy_command_window_header.contents = Bitmap.new(180-32, 130-32)
- @dummy_command_window_header.contents.font.size = 20
- @dummy_command_window_header.contents.font.color = @dummy_command_window_header.text_color(0)
- if @saving == true
- @dummy_command_window_header.contents.draw_text(3, 0 , 165-32, 24, "Save over this")
- @dummy_command_window_header.contents.draw_text(3, 24 , 165-32, 24, "file?")
- else
- @dummy_command_window_header.contents.draw_text(3, 0 , 165-32, 24, "Start the game")
- @dummy_command_window_header.contents.draw_text(3, 24 , 165-32, 24, "from this file?")
- end
- @dummy_command_window_header.contents.font.size = 25
- # Create command window
- @command_window = TDS_Window_Command.new(165, ["YES", "NO"])
- @command_window.x = 370
- @command_window.y = 332
- @command_window.opacity = 0
- # Create gold & time window
- @gold_time_header = Window_Base.new(18, 274, 340, 78)
- @gold_time_header.windowskin = Cache.system("TDS-Lufia Window")
- @gold_time_header.back_opacity = 255
- @gold_time_header.contents = Bitmap.new(340-32, 78-32)
- @gold_time_header.contents.font.size = 25
- @gold_time_header.contents.font.color = @gold_time_header.text_color(0)
- @gold_time_header.contents.draw_text(18, 0, 340-32, 24, "TIME", 0)
- @gold_time_header.contents.draw_text(18, 24 , 340-32, 24, "GOLD", 0)
- @gold_time_header.contents.draw_text(18, 24 , 300-32, 24, @game_party.gold , 2)
- # Calculate playtime
- total_sec = Graphics.frame_count / Graphics.frame_rate
- hour = total_sec / 60 / 60
- min = total_sec / 60 % 60
- sec = total_sec % 60
- time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
- @gold_time_header.contents.draw_text(18, 0 , 300-32, 24, time_string , 2)
- # Create save cofirmation header
- @save_confirmation_header = Window_Base.new(18, 352, 340, 57)
- @save_confirmation_header.windowskin = Cache.system("TDS-Lufia Window")
- @save_confirmation_header.back_opacity = 255
- @save_confirmation_header.contents = Bitmap.new(340-32, 78-32)
- @save_confirmation_header.contents.font.size = 25
- @save_confirmation_header.contents.font.color = @save_confirmation_header.text_color(0)
- @save_confirmation_header.contents.draw_text(18, 0, 340-32, 24, "Game saved.", 0)
- @save_confirmation_header.visible = false
- # Save process flag
- @saving_process = false
- end
- #--------------------------------------------------------------------------
- # * Load Saved Game Data
- # file : Save file to load data from
- #--------------------------------------------------------------------------
- def load_saved_game_data(file = nil)
- filename = file
- file = File.open(filename, "r")
- @characters = Marshal.load(file)
- Graphics.frame_count = Marshal.load(file)
- @last_bgm = Marshal.load(file)
- @last_bgs = Marshal.load(file)
- @game_system = Marshal.load(file)
- @game_message = Marshal.load(file)
- @game_switches = Marshal.load(file)
- @game_variables = Marshal.load(file)
- @game_self_switches = Marshal.load(file)
- @game_actors = Marshal.load(file)
- @game_party = Marshal.load(file)
- @game_troop = Marshal.load(file)
- @game_map = Marshal.load(file)
- @game_player = Marshal.load(file)
- return
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- # Update command window
- @command_window.update
- # If saving process flag is true
- if @saving_process
- update_save_process
- return
- end
- # If input trigger cancel
- if Input.trigger?(Input::B)
- Sound.play_cancel
- $scene = Scene_File.new(@saving, false, false, @return_index)
- return
- end
- # If input is confirm
- if Input.trigger?(Input::C)
- case @command_window.index
- when 0
- if @saving
- Sound.play_save
- @command_window.active = false
- @save_confirmation_header.visible = true
- @saving_process = true
- $game_temp.last_file_index
- return
- else
- Sound.play_load
- @command_window.active = false
- do_load
- return
- end
- when 1
- Sound.play_cancel
- $scene = Scene_File.new(@saving, false, false, @return_index)
- return
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Update save process
- #--------------------------------------------------------------------------
- def update_save_process
- # Exit frame count
- @frames = 0 if @frames == nil
- @frames += 1 if @frames < 70
- if @frames == 70
- do_save
- end
- end
- #--------------------------------------------------------------------------
- # * Execute Load
- #--------------------------------------------------------------------------
- def do_load
- file = File.open(@file, "rb")
- read_save_data(file)
- file.close
- $scene = Scene_Map.new
- RPG::BGM.fade(1500)
- Graphics.fadeout(60)
- Graphics.wait(40)
- @last_bgm.play
- @last_bgs.play
- end
- #--------------------------------------------------------------------------
- # * Execute Save
- #--------------------------------------------------------------------------
- def do_save
- file = File.open(@file, "wb")
- write_save_data(file)
- file.close
- if @from_event
- $scene = Scene_Map.new
- else
- $scene = Scene_Menu.new(5)
- end
- return
- end
- #--------------------------------------------------------------------------
- # * Write Save Data
- # file : write file object (opened)
- #--------------------------------------------------------------------------
- def write_save_data(file)
- characters = []
- for actor in $game_party.members
- characters.push([actor.character_name, actor.character_index])
- end
- $game_system.save_count += 1
- $game_system.version_id = $data_system.version_id
- @last_bgm = RPG::BGM::last
- @last_bgs = RPG::BGS::last
- Marshal.dump(characters, file)
- Marshal.dump(Graphics.frame_count, file)
- Marshal.dump(@last_bgm, file)
- Marshal.dump(@last_bgs, file)
- Marshal.dump($game_system, file)
- Marshal.dump($game_message, file)
- Marshal.dump($game_switches, file)
- Marshal.dump($game_variables, file)
- Marshal.dump($game_self_switches, file)
- Marshal.dump($game_actors, file)
- Marshal.dump($game_party, file)
- Marshal.dump($game_troop, file)
- Marshal.dump($game_map, file)
- Marshal.dump($game_player, file)
- end
- #--------------------------------------------------------------------------
- # * Read Save Data
- # file : file object for reading (opened)
- #--------------------------------------------------------------------------
- def read_save_data(file)
- characters = Marshal.load(file)
- Graphics.frame_count = Marshal.load(file)
- @last_bgm = Marshal.load(file)
- @last_bgs = Marshal.load(file)
- $game_system = Marshal.load(file)
- $game_message = Marshal.load(file)
- $game_switches = Marshal.load(file)
- $game_variables = Marshal.load(file)
- $game_self_switches = Marshal.load(file)
- $game_actors = Marshal.load(file)
- $game_party = Marshal.load(file)
- $game_troop = Marshal.load(file)
- $game_map = Marshal.load(file)
- $game_player = Marshal.load(file)
- if $game_system.version_id != $data_system.version_id
- $game_map.setup($game_map.map_id)
- $game_player.center($game_player.x, $game_player.y)
- end
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- @status_window.dispose
- @map_name_header.dispose
- @dummy_command_window_header.dispose
- @command_window.dispose
- @gold_time_header.dispose
- @save_confirmation_header.dispose
- end
- end
- #==============================================================================
- # ** Window_File_MenuStatus
- #------------------------------------------------------------------------------
- # This window displays party member status on the save and load screen.
- #==============================================================================
- class Window_File_MenuStatus < Window_Base
- #--------------------------------------------------------------------------
- # * Object Initialization
- # x : window X coordinate
- # y : window Y coordinate
- #--------------------------------------------------------------------------
- def initialize(x, y, party_data)
- super(x, y, 544, 416)
- self.active = false
- self.contents.font.size = 18
- self.opacity = 0
- @party_data = party_data
- @column_max = 2
- refresh
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- self.contents.clear
- @item_max = @party_data.members.size
- for actor in @party_data.members
- actor_index = @party_data.members.index(actor)
- y = 0
- if actor_index > 1
- x = 260
- draw_actor_graphic(actor, 19 + actor_index * x - actor_index - @column_max * x, 90)
- draw_actor_name(actor, 96 + actor_index * x - actor_index - @column_max * x, 90)
- draw_actor_hp(actor, 96 + actor_index * x - actor_index - @column_max * x, y + 84 + WLH * 1 , 120, true)
- draw_actor_mp(actor, 96 + actor_index * x - actor_index - @column_max * x, y + 84 + WLH * 2 , 120, true)
- draw_actor_level(actor, 174 + actor_index * x - actor_index - @column_max * x, 90)
- else
- x = 260
- draw_actor_graphic(actor, 20 + actor_index * x, 8)
- draw_actor_name(actor, 96 + actor_index * x, 10)
- draw_actor_hp(actor, 96 + actor_index * x, y + WLH * 1 + 4, 120, true)
- draw_actor_mp(actor, 96 + actor_index * x, y + WLH * 2 + 4, 120, true)
- draw_actor_level(actor, 174 + actor_index * x, 10)
- end
- x = actor_index * 96 + WLH / 2
- y = 0
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Level
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_level(actor, x, y)
- self.contents.font.color = system_color
- self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
- self.contents.font.color = normal_color
- self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw Actor Walking Graphic
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_graphic(actor, x, y)
- character_name = actor.character_name
- bitmap = Cache.character(character_name)
- sign = character_name[/^[\!\$]./]
- if sign != nil and sign.include?('$')
- cw = bitmap.width / 3
- ch = bitmap.height / 4
- else
- cw = bitmap.width / 12
- ch = bitmap.height / 8
- end
- n = actor.character_index
- src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
- dest_rect = Rect.new(x, y, 80, 80)
- dest_rect = Rect.new(x, y, 65, 65)
- self.contents.stretch_blt(dest_rect, bitmap, src_rect)
- end
- #--------------------------------------------------------------------------
- # * Draw Name
- # actor : actor
- # x : draw spot x-coordinate
- # y : draw spot y-coordinate
- #--------------------------------------------------------------------------
- def draw_actor_name(actor, x, y)
- self.contents.font.color = hp_color(actor)
- self.contents.draw_text(x, y, 75, WLH, actor.name)
- end
- end
- #==============================================================================
- # ** Window_SaveFile
- #------------------------------------------------------------------------------
- # This window displays save files on the save and load screens.
- #==============================================================================
- class Window_SaveFile < Window_Base
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :filename # filename
- attr_reader :file_exist # file existence flag
- attr_reader :time_stamp # timestamp
- attr_reader :selected # selected
- #--------------------------------------------------------------------------
- # * Object Initialization
- # file_index : save file index (0-3)
- # filename : filename
- #--------------------------------------------------------------------------
- def initialize(file_index, filename, saving = false)
- window_values = [
- # Start
- values = [18, 32, 140, 56 ],
- # Save files
- values = [18, 88, 254, 160 ],
- values = [272, 88, 254, 160 ],
- values = [18, 248, 254, 160 ],
- values = [272, 248, 254, 160 ],
- ]
- v_x = window_values[file_index][0]
- v_y = window_values[file_index][1]
- v_height = window_values[file_index][2]
- v_width = window_values[file_index][3]
- super(v_x, v_y, v_height, v_width)
- self.windowskin = Cache.system("TDS-Lufia Window")
- self.back_opacity = 255
- create_custom_cursor
- @file_index = file_index
- @filename = filename
- @saving = saving
- load_gamedata
- refresh
- @selected = false
- # self.visible = false
- end
- #--------------------------------------------------------------------------
- # * Load Partial Game Data
- # By default, switches and variables are not used (for expansion use,
- # such as displaying place names)
- #--------------------------------------------------------------------------
- def load_gamedata
- @time_stamp = Time.at(0)
- @file_exist = FileTest.exist?(@filename)
- if @file_exist
- file = File.open(@filename, "r")
- @time_stamp = file.mtime
- begin
- @characters = Marshal.load(file)
- @frame_count = Marshal.load(file)
- @last_bgm = Marshal.load(file)
- @last_bgs = Marshal.load(file)
- @game_system = Marshal.load(file)
- @game_message = Marshal.load(file)
- @game_switches = Marshal.load(file)
- @game_variables = Marshal.load(file)
- # Reads self switches
- Marshal.load(file)
- @game_actors = Marshal.load(file)
- @game_party = Marshal.load(file)
- Marshal.load(file)
- @total_sec = @frame_count / Graphics.frame_rate
- rescue
- @file_exist = false
- ensure
- file.close
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Refresh
- #--------------------------------------------------------------------------
- def refresh
- self.contents.clear
- self.contents.font.color = normal_color
- if @file_index == 0
- name = " START "
- self.contents.draw_text(4, 0, 200, WLH, name)
- end
- if @file_exist == false and @file_index != 0
- self.contents.draw_text(30, 0, 200, WLH, "FREE")
- end
- @name_width = contents.text_size(name).width
- if @file_exist
- draw_party_characters(35, 105)
- draw_playtime(-35, 34, contents.width - 4, 2)
- draw_party_leader_name(30, 0)
- end
- end
- #--------------------------------------------------------------------------
- # * Redraw New Save Information
- #--------------------------------------------------------------------------
- def redraw_new_save_infofmation
- self.contents.clear
- self.contents.font.color = normal_color
- @time_stamp = Time.at(0)
- @file_exist = FileTest.exist?(@filename)
- if @file_exist
- file = File.open(@filename, "r")
- @time_stamp = file.mtime
- begin
- @characters = Marshal.load(file)
- @frame_count = Marshal.load(file)
- @last_bgm = Marshal.load(file)
- @last_bgs = Marshal.load(file)
- @game_system = Marshal.load(file)
- @game_message = Marshal.load(file)
- @game_switches = Marshal.load(file)
- @game_variables = Marshal.load(file)
- # Reads self switches
- Marshal.load(file)
- @game_actors = Marshal.load(file)
- @game_party = Marshal.load(file)
- Marshal.load(file)
- @total_sec = @frame_count / Graphics.frame_rate
- rescue
- @file_exist = false
- ensure
- file.close
- end
- end
- draw_party_characters(35, 105)
- draw_playtime(-35, 34, contents.width - 4, 2)
- draw_party_leader_name(30, 0)
- end
- #--------------------------------------------------------------------------
- # * Draw Party Characters
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_party_characters(x, y)
- for i in 0...@characters.size
- name = @characters[i][0]
- index = @characters[i][1]
- draw_character(name, index, x + i * 51, y)
- self.contents.font.size = 18
- self.contents.draw_text(-11 + x + i * 51, 105, 24, 24, @game_party.members[i].level, 1)
- self.contents.font.size = 25
- end
- end
- #--------------------------------------------------------------------------
- # * Draw Play Time
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- # width : Width
- # align : Alignment
- #--------------------------------------------------------------------------
- def draw_playtime(x, y, width, align)
- hour = @total_sec / 60 / 60
- min = @total_sec / 60 % 60
- sec = @total_sec % 60
- time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
- self.contents.font.color = normal_color
- self.contents.draw_text(x, y, width, WLH, "TIME " + time_string, 2)
- end
- #--------------------------------------------------------------------------
- # * Draw Party Leader Name
- # x : Draw spot X coordinate
- # y : Draw spot Y coordinate
- #--------------------------------------------------------------------------
- def draw_party_leader_name(x, y)
- self.contents.draw_text(x, y, 100, WLH, "NAME")
- self.contents.draw_text(x + 77 , y, 85, WLH, @game_party.members[0].name, 0)
- end
- #--------------------------------------------------------------------------
- # * Set Selected
- # selected : new selected (true = selected, false = unselected)
- #--------------------------------------------------------------------------
- def selected=(selected)
- @selected = selected
- update_cursor
- end
- #--------------------------------------------------------------------------
- # * Dispose
- #--------------------------------------------------------------------------
- def dispose
- self.contents.dispose
- @sprite.bitmap.dispose
- @sprite.dispose
- super
- end
- #--------------------------------------------------------------------------
- # * Create Custom Cursor
- #--------------------------------------------------------------------------
- def create_custom_cursor
- @sprite = Sprite.new
- @sprite.bitmap = Cache.system("Cursor")
- @sprite.src_rect.width = @sprite.bitmap.width / 6
- if @file_index == 0
- @sprite.x = self.x + 16
- @sprite.y = self.y + 16 #+ 4
- else
- @sprite.x = self.x + 16
- @sprite.y = self.y + 14 #+ 4
- end
- @sprite.visible = @selected
- @sprite.z = 9999
- update_cursor_graphic
- end
- #--------------------------------------------------------------------------
- # * Update Cursor Graphic
- #--------------------------------------------------------------------------
- def update_cursor_graphic
- @sprite.visible = @selected
- end
- #--------------------------------------------------------------------------
- # * Update Cursor Animation
- #--------------------------------------------------------------------------
- def update_cursor_animation
- @duration = -1 if @duration == nil
- if @selected
- @duration += 1
- @duration %= 8
- if @duration == 8 -1
- @sprite.src_rect.x += 24
- @sprite.src_rect.x %= 6 * 24
- end
- else
- @duration += 1
- @duration %= 8
- if @duration == 8 - 1
- @sprite.src_rect.x -= 24
- @sprite.src_rect.x %= 7 * 24
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Update cursor
- #--------------------------------------------------------------------------
- def update_cursor
- if @selected
- self.cursor_rect.set(0, 0, @name_width + 8, WLH)
- update_cursor_graphic
- else
- self.cursor_rect.empty
- end
- end
- end
- #==============================================================================
- # ** Scene_End
- #------------------------------------------------------------------------------
- # This class performs game end screen processing.
- #==============================================================================
- class Scene_End < Scene_Base
- #--------------------------------------------------------------------------
- # * Start processing
- #--------------------------------------------------------------------------
- def start
- super
- # Create Menu Back Sprite
- @menuback_sprite = Sprite.new
- @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
- create_command_window
- end
- #--------------------------------------------------------------------------
- # * Post-Start Processing
- #--------------------------------------------------------------------------
- def post_start
- super
- open_command_window
- end
- #--------------------------------------------------------------------------
- # * Pre-termination Processing
- #--------------------------------------------------------------------------
- def pre_terminate
- super
- close_command_window
- end
- #--------------------------------------------------------------------------
- # * Termination Processing
- #--------------------------------------------------------------------------
- def terminate
- super
- dispose_command_window
- @menuback_sprite.dispose
- @menuback_sprite.bitmap.dispose
- end
- #--------------------------------------------------------------------------
- # * Return to Original Screen
- #--------------------------------------------------------------------------
- def return_scene
- $scene = Scene_Menu.new(6)
- end
- #--------------------------------------------------------------------------
- # * Frame Update
- #--------------------------------------------------------------------------
- def update
- super
- @command_window.update
- if @command_window.active == false and @command_window.openness == 255
- @command_window.active = true
- @command_window.index = 0
- @command_window.change_cursor_visibility(false)
- end
- if Input.trigger?(Input::B)
- Sound.play_cancel
- @command_window.index = -1
- return_scene
- elsif Input.trigger?(Input::C) and @command_window.active
- case @command_window.index
- when 0 # to title
- command_to_title
- when 1 # shutdown
- command_shutdown
- when 2 # quit
- command_cancel
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Create Command Window
- #--------------------------------------------------------------------------
- def create_command_window
- s1 = Vocab::to_title
- s2 = Vocab::shutdown
- s3 = Vocab::cancel
- @command_window = TDS_Window_Command.new(172, [s1, s2, s3])
- @command_window.x = (544 - @command_window.width) / 2
- @command_window.y = (416 - @command_window.height) / 2
- @command_window.index = -1
- @command_window.active = false
- @command_window.openness = 0
- end
- #--------------------------------------------------------------------------
- # * Dispose of Command Window
- #--------------------------------------------------------------------------
- def dispose_command_window
- @command_window.dispose
- end
- #--------------------------------------------------------------------------
- # * Open Command Window
- #--------------------------------------------------------------------------
- def open_command_window
- @command_window.open
- begin
- @command_window.update
- Graphics.update
- end until @command_window.openness == 255
- end
- #--------------------------------------------------------------------------
- # * Close Command Window
- #--------------------------------------------------------------------------
- def close_command_window
- @command_window.close
- begin
- @command_window.update
- Graphics.update
- end until @command_window.openness == 0
- end
- #--------------------------------------------------------------------------
- # * Process When Choosing [To Title] Command
- #--------------------------------------------------------------------------
- def command_to_title
- @command_window.index = -1
- Sound.play_decision
- RPG::BGM.fade(800)
- RPG::BGS.fade(800)
- RPG::ME.fade(800)
- close_command_window
- Graphics.fadeout(60)
- $scene = Scene_File.new(false, true, false)
- Audio.bgm_play("Audio/BGM/Lufia II - Title Loading Screen", 100, 100)
- end
- #--------------------------------------------------------------------------
- # * Process When Choosing [Shutdown] Command
- #--------------------------------------------------------------------------
- def command_shutdown
- @command_window.index = -1
- Sound.play_decision
- RPG::BGM.fade(800)
- RPG::BGS.fade(800)
- RPG::ME.fade(800)
- $scene = nil
- exit
- end
- #--------------------------------------------------------------------------
- # * Process When Choosing [Cancel] Command
- #--------------------------------------------------------------------------
- def command_cancel
- @command_window.index = -1
- Sound.play_decision
- return_scene
- end
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement