rmxp_extractor 1.8 → 2.0.0

data/Scripts/Scene_Equip.rb

@@ -1,222 +0,0 @@
-#==============================================================================
-# ** Scene_Equip
-#------------------------------------------------------------------------------
-#  This class performs equipment screen processing.
-#==============================================================================
-
-class Scene_Equip
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     actor_index : actor index
-  #     equip_index : equipment index
-  #--------------------------------------------------------------------------
-  def initialize(actor_index = 0, equip_index = 0)
-    @actor_index = actor_index
-    @equip_index = equip_index
-  end
-  #--------------------------------------------------------------------------
-  # * Main Processing
-  #--------------------------------------------------------------------------
-  def main
-    # Get actor
-    @actor = $game_party.actors[@actor_index]
-    # Make windows
-    @help_window = Window_Help.new
-    @left_window = Window_EquipLeft.new(@actor)
-    @right_window = Window_EquipRight.new(@actor)
-    @item_window1 = Window_EquipItem.new(@actor, 0)
-    @item_window2 = Window_EquipItem.new(@actor, 1)
-    @item_window3 = Window_EquipItem.new(@actor, 2)
-    @item_window4 = Window_EquipItem.new(@actor, 3)
-    @item_window5 = Window_EquipItem.new(@actor, 4)
-    # Associate help window
-    @right_window.help_window = @help_window
-    @item_window1.help_window = @help_window
-    @item_window2.help_window = @help_window
-    @item_window3.help_window = @help_window
-    @item_window4.help_window = @help_window
-    @item_window5.help_window = @help_window
-    # Set cursor position
-    @right_window.index = @equip_index
-    refresh
-    # Execute transition
-    Graphics.transition
-    # Main loop
-    loop do
-      # Update game screen
-      Graphics.update
-      # Update input information
-      Input.update
-      # Frame update
-      update
-      # Abort loop if screen is changed
-      if $scene != self
-        break
-      end
-    end
-    # Prepare for transition
-    Graphics.freeze
-    # Dispose of windows
-    @help_window.dispose
-    @left_window.dispose
-    @right_window.dispose
-    @item_window1.dispose
-    @item_window2.dispose
-    @item_window3.dispose
-    @item_window4.dispose
-    @item_window5.dispose
-  end
-  #--------------------------------------------------------------------------
-  # * Refresh
-  #--------------------------------------------------------------------------
-  def refresh
-    # Set item window to visible
-    @item_window1.visible = (@right_window.index == 0)
-    @item_window2.visible = (@right_window.index == 1)
-    @item_window3.visible = (@right_window.index == 2)
-    @item_window4.visible = (@right_window.index == 3)
-    @item_window5.visible = (@right_window.index == 4)
-    # Get currently equipped item
-    item1 = @right_window.item
-    # Set current item window to @item_window
-    case @right_window.index
-    when 0
-      @item_window = @item_window1
-    when 1
-      @item_window = @item_window2
-    when 2
-      @item_window = @item_window3
-    when 3
-      @item_window = @item_window4
-    when 4
-      @item_window = @item_window5
-    end
-    # If right window is active
-    if @right_window.active
-      # Erase parameters for after equipment change
-      @left_window.set_new_parameters(nil, nil, nil)
-    end
-    # If item window is active
-    if @item_window.active
-      # Get currently selected item
-      item2 = @item_window.item
-      # Change equipment
-      last_hp = @actor.hp
-      last_sp = @actor.sp
-      @actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
-      # Get parameters for after equipment change
-      new_atk = @actor.atk
-      new_pdef = @actor.pdef
-      new_mdef = @actor.mdef
-      # Return equipment
-      @actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
-      @actor.hp = last_hp
-      @actor.sp = last_sp
-      # Draw in left window
-      @left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    # Update windows
-    @left_window.update
-    @right_window.update
-    @item_window.update
-    refresh
-    # If right window is active: call update_right
-    if @right_window.active
-      update_right
-      return
-    end
-    # If item window is active: call update_item
-    if @item_window.active
-      update_item
-      return
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update (when right window is active)
-  #--------------------------------------------------------------------------
-  def update_right
-    # If B button was pressed
-    if Input.trigger?(Input::CANCEL)
-      # Play cancel SE
-      $game_system.se_play($data_system.cancel_se)
-      # Switch to menu screen
-      $scene = Scene_Menu.new(2)
-      return
-    end
-    # If C button was pressed
-    if Input.trigger?(Input::ACTION)
-      # If equipment is fixed
-      if @actor.equip_fix?(@right_window.index)
-        # Play buzzer SE
-        $game_system.se_play($data_system.buzzer_se)
-        return
-      end
-      # Play decision SE
-      $game_system.se_play($data_system.decision_se)
-      # Activate item window
-      @right_window.active = false
-      @item_window.active = true
-      @item_window.index = 0
-      return
-    end
-    # If R button was pressed
-    if Input.trigger?(Input::R)
-      # Play cursor SE
-      $game_system.se_play($data_system.cursor_se)
-      # To next actor
-      @actor_index += 1
-      @actor_index %= $game_party.actors.size
-      # Switch to different equipment screen
-      $scene = Scene_Equip.new(@actor_index, @right_window.index)
-      return
-    end
-    # If L button was pressed
-    if Input.trigger?(Input::L)
-      # Play cursor SE
-      $game_system.se_play($data_system.cursor_se)
-      # To previous actor
-      @actor_index += $game_party.actors.size - 1
-      @actor_index %= $game_party.actors.size
-      # Switch to different equipment screen
-      $scene = Scene_Equip.new(@actor_index, @right_window.index)
-      return
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update (when item window is active)
-  #--------------------------------------------------------------------------
-  def update_item
-    # If B button was pressed
-    if Input.trigger?(Input::CANCEL)
-      # Play cancel SE
-      $game_system.se_play($data_system.cancel_se)
-      # Activate right window
-      @right_window.active = true
-      @item_window.active = false
-      @item_window.index = -1
-      return
-    end
-    # If C button was pressed
-    if Input.trigger?(Input::ACTION)
-      # Play equip SE
-      $game_system.se_play($data_system.equip_se)
-      # Get currently selected data on the item window
-      item = @item_window.item
-      # Change equipment
-      @actor.equip(@right_window.index, item == nil ? 0 : item.id)
-      # Activate right window
-      @right_window.active = true
-      @item_window.active = false
-      @item_window.index = -1
-      # Remake right window and item window contents
-      @right_window.refresh
-      @item_window.refresh
-      return
-    end
-  end
-end

data/Scripts/Scene_File.rb

@@ -1,111 +0,0 @@
-#==============================================================================
-# ** Scene_File
-#------------------------------------------------------------------------------
-#  This is a superclass for the save screen and load screen.
-#==============================================================================
-
-class Scene_File
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     help_text : text string shown in the help window
-  #--------------------------------------------------------------------------
-  def initialize(help_text)
-    @help_text = help_text
-  end
-  #--------------------------------------------------------------------------
-  # * Main Processing
-  #--------------------------------------------------------------------------
-  def main
-    # Make help window
-    @help_window = Window_Help.new
-    @help_window.set_text(@help_text)
-    # Make save file window
-    @savefile_windows = []
-    for i in 0..3
-      @savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
-    end
-    # Select last file to be operated
-    @file_index = $game_temp.last_file_index
-    @savefile_windows[@file_index].selected = true
-    # Execute transition
-    Graphics.transition
-    # Main loop
-    loop do
-      # Update game screen
-      Graphics.update
-      # Update input information
-      Input.update
-      # Frame update
-      update
-      # Abort loop if screen is changed
-      if $scene != self
-        break
-      end
-    end
-    # Prepare for transition
-    Graphics.freeze
-    # Dispose of windows
-    @help_window.dispose
-    for i in @savefile_windows
-      i.dispose
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    # Update windows
-    @help_window.update
-    for i in @savefile_windows
-      i.update
-    end
-    # If C button was pressed
-    if Input.trigger?(Input::ACTION)
-      # Call method: on_decision (defined by the subclasses)
-      on_decision(make_filename(@file_index))
-      $game_temp.last_file_index = @file_index
-      return
-    end
-    # If B button was pressed
-    if Input.trigger?(Input::CANCEL)
-      # Call method: on_cancel (defined by the subclasses)
-      on_cancel
-      return
-    end
-    # If the down directional button was pressed
-    if Input.repeat?(Input::DOWN)
-      # If the down directional button pressed down is not a repeat,
-      # or cursor position is more in front than 3
-      if Input.trigger?(Input::DOWN) or @file_index < 3
-        # Play cursor SE
-        $game_system.se_play($data_system.cursor_se)
-        # Move cursor down
-        @savefile_windows[@file_index].selected = false
-        @file_index = (@file_index + 1) % 4
-        @savefile_windows[@file_index].selected = true
-        return
-      end
-    end
-    # If the up directional button was pressed
-    if Input.repeat?(Input::UP)
-      # If the up directional button pressed down is not a repeat、
-      # or cursor position is more in back than 0
-      if Input.trigger?(Input::UP) or @file_index > 0
-        # Play cursor SE
-        $game_system.se_play($data_system.cursor_se)
-        # Move cursor up
-        @savefile_windows[@file_index].selected = false
-        @file_index = (@file_index + 3) % 4
-        @savefile_windows[@file_index].selected = true
-        return
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Make File Name
-  #     file_index : save file index (0-3)
-  #--------------------------------------------------------------------------
-  def make_filename(file_index)
-    return "Save#{file_index + 1}.rxdata"
-  end
-end

data/Scripts/Scene_Item.rb

@@ -1,205 +0,0 @@
-#==============================================================================
-# ** Scene_Item
-#------------------------------------------------------------------------------
-#  This class performs item screen processing.
-#==============================================================================
-
-class Scene_Item
-  #--------------------------------------------------------------------------
-  # * Main Processing
-  #--------------------------------------------------------------------------
-  def main
-    # Make help window, item window
-    @help_window = Window_Help.new
-    @item_window = Window_Item.new
-    # Associate help window
-    @item_window.help_window = @help_window
-    # Make target window (set to invisible / inactive)
-    @target_window = Window_Target.new
-    @target_window.visible = false
-    @target_window.active = false
-    # Execute transition
-    Graphics.transition
-    # Main loop
-    loop do
-      # Update game screen
-      Graphics.update
-      # Update input information
-      Input.update
-      # Frame update
-      update
-      # Abort loop if screen is changed
-      if $scene != self
-        break
-      end
-    end
-    # Prepare for transition
-    Graphics.freeze
-    # Dispose of windows
-    @help_window.dispose
-    @item_window.dispose
-    @target_window.dispose
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    # Update windows
-    @help_window.update
-    @item_window.update
-    @target_window.update
-    # If item window is active: call update_item
-    if @item_window.active
-      update_item
-      return
-    end
-    # If target window is active: call update_target
-    if @target_window.active
-      update_target
-      return
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update (when item window is active)
-  #--------------------------------------------------------------------------
-  def update_item
-    # If B button was pressed
-    if Input.trigger?(Input::CANCEL)
-      # Play cancel SE
-      $game_system.se_play($data_system.cancel_se)
-      # Switch to menu screen
-      $scene = Scene_Menu.new(0)
-      return
-    end
-    # If C button was pressed
-    if Input.trigger?(Input::ACTION)
-      # Get currently selected data on the item window
-      @item = @item_window.item
-      # If not a use item
-      unless @item.is_a?(RPG::Item)
-        # Play buzzer SE
-        $game_system.se_play($data_system.buzzer_se)
-        return
-      end
-      # If it can't be used
-      unless $game_party.item_can_use?(@item.id)
-        # Play buzzer SE
-        $game_system.se_play($data_system.buzzer_se)
-        return
-      end
-      # Play decision SE
-      $game_system.se_play($data_system.decision_se)
-      # If effect scope is an ally
-      if @item.scope >= 3
-        # Activate target window
-        @item_window.active = false
-        @target_window.x = (@item_window.index + 1) % 2 * 304
-        @target_window.visible = true
-        @target_window.active = true
-        # Set cursor position to effect scope (single / all)
-        if @item.scope == 4 || @item.scope == 6
-          @target_window.index = -1
-        else
-          @target_window.index = 0
-        end
-      # If effect scope is other than an ally
-      else
-        # If command event ID is valid
-        if @item.common_event_id > 0
-          # Command event call reservation
-          $game_temp.common_event_id = @item.common_event_id
-          # Play item use SE
-          $game_system.se_play(@item.menu_se)
-          # If consumable
-          if @item.consumable
-            # Decrease used items by 1
-            $game_party.lose_item(@item.id, 1)
-            # Draw item window item
-            @item_window.draw_item(@item_window.index)
-          end
-          # Switch to map screen
-          $scene = Scene_Map.new
-          return
-        end
-      end
-      return
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update (when target window is active)
-  #--------------------------------------------------------------------------
-  def update_target
-    # If B button was pressed
-    if Input.trigger?(Input::CANCEL)
-      # Play cancel SE
-      $game_system.se_play($data_system.cancel_se)
-      # If unable to use because items ran out
-      unless $game_party.item_can_use?(@item.id)
-        # Remake item window contents
-        @item_window.refresh
-      end
-      # Erase target window
-      @item_window.active = true
-      @target_window.visible = false
-      @target_window.active = false
-      return
-    end
-    # If C button was pressed
-    if Input.trigger?(Input::ACTION)
-      # If items are used up
-      if $game_party.item_number(@item.id) == 0
-        # Play buzzer SE
-        $game_system.se_play($data_system.buzzer_se)
-        return
-      end
-      # If target is all
-      if @target_window.index == -1
-        # Apply item effects to entire party
-        used = false
-        for i in $game_party.actors
-          used |= i.item_effect(@item)
-        end
-      end
-      # If single target
-      if @target_window.index >= 0
-        # Apply item use effects to target actor
-        target = $game_party.actors[@target_window.index]
-        used = target.item_effect(@item)
-      end
-      # If an item was used
-      if used
-        # Play item use SE
-        $game_system.se_play(@item.menu_se)
-        # If consumable
-        if @item.consumable
-          # Decrease used items by 1
-          $game_party.lose_item(@item.id, 1)
-          # Redraw item window item
-          @item_window.draw_item(@item_window.index)
-        end
-        # Remake target window contents
-        @target_window.refresh
-        # If all party members are dead
-        if $game_party.all_dead?
-          # Switch to game over screen
-          $scene = Scene_Gameover.new
-          return
-        end
-        # If common event ID is valid
-        if @item.common_event_id > 0
-          # Common event call reservation
-          $game_temp.common_event_id = @item.common_event_id
-          # Switch to map screen
-          $scene = Scene_Map.new
-          return
-        end
-      end
-      # If item wasn't used
-      unless used
-        # Play buzzer SE
-        $game_system.se_play($data_system.buzzer_se)
-      end
-      return
-    end
-  end
-end

data/Scripts/Scene_Load.rb

@@ -1,106 +0,0 @@
-#==============================================================================
-# ** Scene_Load
-#------------------------------------------------------------------------------
-#  This class performs load screen processing.
-#==============================================================================
-
-class Scene_Load < Scene_File
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #--------------------------------------------------------------------------
-  def initialize
-    # Remake temporary object
-    $game_temp = Game_Temp.new
-    # Timestamp selects new file
-    $game_temp.last_file_index = 0
-    latest_time = Time.at(0)
-    for i in 0..3
-      filename = make_filename(i)
-      if FileTest.exist?(filename)
-        file = File.open(filename, "r")
-        if file.mtime > latest_time
-          latest_time = file.mtime
-          $game_temp.last_file_index = i
-        end
-        file.close
-      end
-    end
-    super("Which file would you like to load?")
-  end
-  #--------------------------------------------------------------------------
-  # * Decision Processing
-  #--------------------------------------------------------------------------
-  def on_decision(filename)
-    # If file doesn't exist
-    unless FileTest.exist?(filename)
-      # Play buzzer SE
-      $game_system.se_play($data_system.buzzer_se)
-      return
-    end
-    # Play load SE
-    $game_system.se_play($data_system.load_se)
-    # Read save data
-    file = File.open(filename, "rb")
-    read_save_data(file)
-    file.close
-    # Restore BGM and BGS
-    $game_system.bgm_play($game_system.playing_bgm)
-    $game_system.bgs_play($game_system.playing_bgs)
-    # Update map (run parallel process event)
-    $game_map.update
-    # Switch to map screen
-    $scene = Scene_Map.new
-  end
-  #--------------------------------------------------------------------------
-  # * Cancel Processing
-  #--------------------------------------------------------------------------
-  def on_cancel
-    # Play cancel SE
-    $game_system.se_play($data_system.cancel_se)
-    # Switch to title screen
-    $scene = Scene_Title.new
-  end
-  #--------------------------------------------------------------------------
-  # * Read Save Data
-  #     file : file object for reading (opened)
-  #--------------------------------------------------------------------------
-  def read_save_data(file)
-    # Read character data for drawing save file
-    characters = Marshal.load(file)
-    # Read frame count for measuring play time
-    Graphics.frame_count = Marshal.load(file)
-    # Read each type of game object
-    $game_system        = Marshal.load(file)
-    $game_switches      = Marshal.load(file)
-    $game_variables     = Marshal.load(file)
-    $game_self_switches = Marshal.load(file)
-    $game_screen        = 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)
-    $game_followers     = Marshal.load(file)
-    $game_oneshot       = Marshal.load(file)
-    $game_fasttravel    = Marshal.load(file)
-	  $game_temp.footstep_sfx = Marshal.load(file)
-
-    # If magic number is different from when saving
-    # (if editing was added with editor)
-    if $game_system.magic_number != $data_system.magic_number
-      # Load map
-      $game_map.setup($game_map.map_id)
-      $game_player.center($game_player.x, $game_player.y)
-    end
-    # Refresh party members
-    $game_party.refresh
-
-	f_prev = $game_player
-    for f in $game_followers
-      f.leader = f_prev
-      f.moveto($game_player.x, $game_player.y)
-	  f_prev = f
-    end
-    load_perma_flags
-  end
-end