rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/Cache.rb

@@ -0,0 +1,134 @@
+#==============================================================================
+# ** Cache
+#------------------------------------------------------------------------------
+#  This module loads graphics, creates bitmap objects, and retains them.
+# To speed up load times and conserve memory, this module holds the
+# created bitmap object in the internal hash, allowing the program to
+# return preexisting objects when the same bitmap is requested again.
+#==============================================================================
+
+module Cache
+  #--------------------------------------------------------------------------
+  # * Get Animation Graphic
+  #--------------------------------------------------------------------------
+  def self.animation(filename, hue)
+    load_bitmap("Graphics/Animations/", filename, hue)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Battle Background (Floor) Graphic
+  #--------------------------------------------------------------------------
+  def self.battleback1(filename)
+    load_bitmap("Graphics/Battlebacks1/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Battle Background (Wall) Graphic
+  #--------------------------------------------------------------------------
+  def self.battleback2(filename)
+    load_bitmap("Graphics/Battlebacks2/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Battle Graphic
+  #--------------------------------------------------------------------------
+  def self.battler(filename, hue)
+    load_bitmap("Graphics/Battlers/", filename, hue)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Character Graphic
+  #--------------------------------------------------------------------------
+  def self.character(filename)
+    load_bitmap("Graphics/Characters/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Face Graphic
+  #--------------------------------------------------------------------------
+  def self.face(filename)
+    load_bitmap("Graphics/Faces/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Parallax Background Graphic
+  #--------------------------------------------------------------------------
+  def self.parallax(filename)
+    load_bitmap("Graphics/Parallaxes/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Picture Graphic
+  #--------------------------------------------------------------------------
+  def self.picture(filename)
+    load_bitmap("Graphics/Pictures/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get System Graphic
+  #--------------------------------------------------------------------------
+  def self.system(filename)
+    load_bitmap("Graphics/System/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Tileset Graphic
+  #--------------------------------------------------------------------------
+  def self.tileset(filename)
+    load_bitmap("Graphics/Tilesets/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Title (Background) Graphic
+  #--------------------------------------------------------------------------
+  def self.title1(filename)
+    load_bitmap("Graphics/Titles1/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Title (Frame) Graphic
+  #--------------------------------------------------------------------------
+  def self.title2(filename)
+    load_bitmap("Graphics/Titles2/", filename)
+  end
+  #--------------------------------------------------------------------------
+  # * Load Bitmap
+  #--------------------------------------------------------------------------
+  def self.load_bitmap(folder_name, filename, hue = 0)
+    @cache ||= {}
+    if filename.empty?
+      empty_bitmap
+    elsif hue == 0
+      normal_bitmap(folder_name + filename)
+    else
+      hue_changed_bitmap(folder_name + filename, hue)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Create Empty Bitmap
+  #--------------------------------------------------------------------------
+  def self.empty_bitmap
+    Bitmap.new(32, 32)
+  end
+  #--------------------------------------------------------------------------
+  # * Create/Get Normal Bitmap
+  #--------------------------------------------------------------------------
+  def self.normal_bitmap(path)
+    @cache[path] = Bitmap.new(path) unless include?(path)
+    @cache[path]
+  end
+  #--------------------------------------------------------------------------
+  # * Create/Get Hue-Changed Bitmap
+  #--------------------------------------------------------------------------
+  def self.hue_changed_bitmap(path, hue)
+    key = [path, hue]
+    unless include?(key)
+      @cache[key] = normal_bitmap(path).clone
+      @cache[key].hue_change(hue)
+    end
+    @cache[key]
+  end
+  #--------------------------------------------------------------------------
+  # * Check Cache Existence
+  #--------------------------------------------------------------------------
+  def self.include?(key)
+    @cache[key] && !@cache[key].disposed?
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Cache
+  #--------------------------------------------------------------------------
+  def self.clear
+    @cache ||= {}
+    @cache.clear
+    GC.start
+  end
+end

data/lib/rgss3_default_scripts/DataManager.rb

@@ -0,0 +1,267 @@
+#==============================================================================
+# ** DataManager
+#------------------------------------------------------------------------------
+#  This module manages the database and game objects. Almost all of the 
+# global variables used by the game are initialized by this module.
+#==============================================================================
+
+module DataManager
+  #--------------------------------------------------------------------------
+  # * Module Instance Variables
+  #--------------------------------------------------------------------------
+  @last_savefile_index = 0                # most recently accessed file
+  #--------------------------------------------------------------------------
+  # * Initialize Module
+  #--------------------------------------------------------------------------
+  def self.init
+    @last_savefile_index = 0
+    load_database
+    create_game_objects
+    setup_battle_test if $BTEST
+  end
+  #--------------------------------------------------------------------------
+  # * Load Database
+  #--------------------------------------------------------------------------
+  def self.load_database
+    if $BTEST
+      load_battle_test_database
+    else
+      load_normal_database
+      check_player_location
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Load Normal Database
+  #--------------------------------------------------------------------------
+  def self.load_normal_database
+    $data_actors        = load_data("Data/Actors.rvdata2")
+    $data_classes       = load_data("Data/Classes.rvdata2")
+    $data_skills        = load_data("Data/Skills.rvdata2")
+    $data_items         = load_data("Data/Items.rvdata2")
+    $data_weapons       = load_data("Data/Weapons.rvdata2")
+    $data_armors        = load_data("Data/Armors.rvdata2")
+    $data_enemies       = load_data("Data/Enemies.rvdata2")
+    $data_troops        = load_data("Data/Troops.rvdata2")
+    $data_states        = load_data("Data/States.rvdata2")
+    $data_animations    = load_data("Data/Animations.rvdata2")
+    $data_tilesets      = load_data("Data/Tilesets.rvdata2")
+    $data_common_events = load_data("Data/CommonEvents.rvdata2")
+    $data_system        = load_data("Data/System.rvdata2")
+    $data_mapinfos      = load_data("Data/MapInfos.rvdata2")
+  end
+  #--------------------------------------------------------------------------
+  # * Load Battle Test Database
+  #--------------------------------------------------------------------------
+  def self.load_battle_test_database
+    $data_actors        = load_data("Data/BT_Actors.rvdata2")
+    $data_classes       = load_data("Data/BT_Classes.rvdata2")
+    $data_skills        = load_data("Data/BT_Skills.rvdata2")
+    $data_items         = load_data("Data/BT_Items.rvdata2")
+    $data_weapons       = load_data("Data/BT_Weapons.rvdata2")
+    $data_armors        = load_data("Data/BT_Armors.rvdata2")
+    $data_enemies       = load_data("Data/BT_Enemies.rvdata2")
+    $data_troops        = load_data("Data/BT_Troops.rvdata2")
+    $data_states        = load_data("Data/BT_States.rvdata2")
+    $data_animations    = load_data("Data/BT_Animations.rvdata2")
+    $data_tilesets      = load_data("Data/BT_Tilesets.rvdata2")
+    $data_common_events = load_data("Data/BT_CommonEvents.rvdata2")
+    $data_system        = load_data("Data/BT_System.rvdata2")
+  end
+  #--------------------------------------------------------------------------
+  # * Check Player Start Location Existence
+  #--------------------------------------------------------------------------
+  def self.check_player_location
+    if $data_system.start_map_id == 0
+      msgbox(Vocab::PlayerPosError)
+      exit
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Create Game Objects
+  #--------------------------------------------------------------------------
+  def self.create_game_objects
+    $game_temp          = Game_Temp.new
+    $game_system        = Game_System.new
+    $game_timer         = Game_Timer.new
+    $game_message       = Game_Message.new
+    $game_switches      = Game_Switches.new
+    $game_variables     = Game_Variables.new
+    $game_self_switches = Game_SelfSwitches.new
+    $game_actors        = Game_Actors.new
+    $game_party         = Game_Party.new
+    $game_troop         = Game_Troop.new
+    $game_map           = Game_Map.new
+    $game_player        = Game_Player.new
+  end
+  #--------------------------------------------------------------------------
+  # * Set Up New Game
+  #--------------------------------------------------------------------------
+  def self.setup_new_game
+    create_game_objects
+    $game_party.setup_starting_members
+    $game_map.setup($data_system.start_map_id)
+    $game_player.moveto($data_system.start_x, $data_system.start_y)
+    $game_player.refresh
+    Graphics.frame_count = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Set Up Battle Test
+  #--------------------------------------------------------------------------
+  def self.setup_battle_test
+    $game_party.setup_battle_test
+    BattleManager.setup($data_system.test_troop_id)
+    BattleManager.play_battle_bgm
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Existence of Save File
+  #--------------------------------------------------------------------------
+  def self.save_file_exists?
+    !Dir.glob('Save*.rvdata2').empty?
+  end
+  #--------------------------------------------------------------------------
+  # * Maximum Number of Save Files
+  #--------------------------------------------------------------------------
+  def self.savefile_max
+    return 16
+  end
+  #--------------------------------------------------------------------------
+  # * Create Filename
+  #     index : File Index
+  #--------------------------------------------------------------------------
+  def self.make_filename(index)
+    sprintf("Save%02d.rvdata2", index + 1)
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Save
+  #--------------------------------------------------------------------------
+  def self.save_game(index)
+    begin
+      save_game_without_rescue(index)
+    rescue
+      delete_save_file(index)
+      false
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Load
+  #--------------------------------------------------------------------------
+  def self.load_game(index)
+    load_game_without_rescue(index) rescue false
+  end
+  #--------------------------------------------------------------------------
+  # * Load Save Header
+  #--------------------------------------------------------------------------
+  def self.load_header(index)
+    load_header_without_rescue(index) rescue nil
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Save (No Exception Processing)
+  #--------------------------------------------------------------------------
+  def self.save_game_without_rescue(index)
+    File.open(make_filename(index), "wb") do |file|
+      $game_system.on_before_save
+      Marshal.dump(make_save_header, file)
+      Marshal.dump(make_save_contents, file)
+      @last_savefile_index = index
+    end
+    return true
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Load (No Exception Processing)
+  #--------------------------------------------------------------------------
+  def self.load_game_without_rescue(index)
+    File.open(make_filename(index), "rb") do |file|
+      Marshal.load(file)
+      extract_save_contents(Marshal.load(file))
+      reload_map_if_updated
+      @last_savefile_index = index
+    end
+    return true
+  end
+  #--------------------------------------------------------------------------
+  # * Load Save Header (No Exception Processing)
+  #--------------------------------------------------------------------------
+  def self.load_header_without_rescue(index)
+    File.open(make_filename(index), "rb") do |file|
+      return Marshal.load(file)
+    end
+    return nil
+  end
+  #--------------------------------------------------------------------------
+  # * Delete Save File
+  #--------------------------------------------------------------------------
+  def self.delete_save_file(index)
+    File.delete(make_filename(index)) rescue nil
+  end
+  #--------------------------------------------------------------------------
+  # * Create Save Header
+  #--------------------------------------------------------------------------
+  def self.make_save_header
+    header = {}
+    header[:characters] = $game_party.characters_for_savefile
+    header[:playtime_s] = $game_system.playtime_s
+    header
+  end
+  #--------------------------------------------------------------------------
+  # * Create Save Contents
+  #--------------------------------------------------------------------------
+  def self.make_save_contents
+    contents = {}
+    contents[:system]        = $game_system
+    contents[:timer]         = $game_timer
+    contents[:message]       = $game_message
+    contents[:switches]      = $game_switches
+    contents[:variables]     = $game_variables
+    contents[:self_switches] = $game_self_switches
+    contents[:actors]        = $game_actors
+    contents[:party]         = $game_party
+    contents[:troop]         = $game_troop
+    contents[:map]           = $game_map
+    contents[:player]        = $game_player
+    contents
+  end
+  #--------------------------------------------------------------------------
+  # * Extract Save Contents
+  #--------------------------------------------------------------------------
+  def self.extract_save_contents(contents)
+    $game_system        = contents[:system]
+    $game_timer         = contents[:timer]
+    $game_message       = contents[:message]
+    $game_switches      = contents[:switches]
+    $game_variables     = contents[:variables]
+    $game_self_switches = contents[:self_switches]
+    $game_actors        = contents[:actors]
+    $game_party         = contents[:party]
+    $game_troop         = contents[:troop]
+    $game_map           = contents[:map]
+    $game_player        = contents[:player]
+  end
+  #--------------------------------------------------------------------------
+  # * Reload Map if Data Is Updated
+  #--------------------------------------------------------------------------
+  def self.reload_map_if_updated
+    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)
+      $game_player.make_encounter_count
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Get Update Date of Save File
+  #--------------------------------------------------------------------------
+  def self.savefile_time_stamp(index)
+    File.mtime(make_filename(index)) rescue Time.at(0)
+  end
+  #--------------------------------------------------------------------------
+  # * Get File Index with Latest Update Date
+  #--------------------------------------------------------------------------
+  def self.latest_savefile_index
+    savefile_max.times.max_by {|i| savefile_time_stamp(i) }
+  end
+  #--------------------------------------------------------------------------
+  # * Get Index of File Most Recently Accessed
+  #--------------------------------------------------------------------------
+  def self.last_savefile_index
+    @last_savefile_index
+  end
+end

data/lib/rgss3_default_scripts/Game_Action.rb

@@ -0,0 +1,262 @@
+#==============================================================================
+# ** Game_Action
+#------------------------------------------------------------------------------
+#  This class handles battle actions. This class is used within the
+# Game_Battler class.
+#==============================================================================
+
+class Game_Action
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :subject                  # action subject
+  attr_reader   :forcing                  # forcing flag for battle action
+  attr_reader   :item                     # skill/item
+  attr_accessor :target_index             # target index
+  attr_reader   :value                    # evaluation value for auto battle
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize(subject, forcing = false)
+    @subject = subject
+    @forcing = forcing
+    clear
+  end
+  #--------------------------------------------------------------------------
+  # * Clear
+  #--------------------------------------------------------------------------
+  def clear
+    @item = Game_BaseItem.new
+    @target_index = -1
+    @value = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Get Allied Units
+  #--------------------------------------------------------------------------
+  def friends_unit
+    subject.friends_unit
+  end
+  #--------------------------------------------------------------------------
+  # * Get Enemy Units
+  #--------------------------------------------------------------------------
+  def opponents_unit
+    subject.opponents_unit
+  end
+  #--------------------------------------------------------------------------
+  # * Set Battle Action of Enemy Character
+  #     action : RPG::Enemy::Action
+  #--------------------------------------------------------------------------
+  def set_enemy_action(action)
+    if action
+      set_skill(action.skill_id)
+    else
+      clear
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Set Normal Attack
+  #--------------------------------------------------------------------------
+  def set_attack
+    set_skill(subject.attack_skill_id)
+    self
+  end
+  #--------------------------------------------------------------------------
+  # * Set Guard
+  #--------------------------------------------------------------------------
+  def set_guard
+    set_skill(subject.guard_skill_id)
+    self
+  end
+  #--------------------------------------------------------------------------
+  # * Set Skill
+  #--------------------------------------------------------------------------
+  def set_skill(skill_id)
+    @item.object = $data_skills[skill_id]
+    self
+  end
+  #--------------------------------------------------------------------------
+  # * Set Item
+  #--------------------------------------------------------------------------
+  def set_item(item_id)
+    @item.object = $data_items[item_id]
+    self
+  end
+  #--------------------------------------------------------------------------
+  # * Get Item Object
+  #--------------------------------------------------------------------------
+  def item
+    @item.object
+  end
+  #--------------------------------------------------------------------------
+  # * Normal Attack Determination
+  #--------------------------------------------------------------------------
+  def attack?
+    item == $data_skills[subject.attack_skill_id]
+  end
+  #--------------------------------------------------------------------------
+  # * Random Target
+  #--------------------------------------------------------------------------
+  def decide_random_target
+    if item.for_dead_friend?
+      target = friends_unit.random_dead_target
+    elsif item.for_friend?
+      target = friends_unit.random_target
+    else
+      target = opponents_unit.random_target
+    end
+    if target
+      @target_index = target.index
+    else
+      clear
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Set Confusion Action
+  #--------------------------------------------------------------------------
+  def set_confusion
+    set_attack
+  end
+  #--------------------------------------------------------------------------
+  # * Action Preparation
+  #--------------------------------------------------------------------------
+  def prepare
+    set_confusion if subject.confusion? && !forcing
+  end
+  #--------------------------------------------------------------------------
+  # * Determination if Action is Valid or Not
+  #    Assuming that an event command does not cause [Force Battle Action],
+  #    if state limitations or lack of items, etc. make the planned action
+  #    impossible, return false.
+  #--------------------------------------------------------------------------
+  def valid?
+    (forcing && item) || subject.usable?(item)
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Action Speed
+  #--------------------------------------------------------------------------
+  def speed
+    speed = subject.agi + rand(5 + subject.agi / 4)
+    speed += item.speed if item
+    speed += subject.atk_speed if attack?
+    speed
+  end
+  #--------------------------------------------------------------------------
+  # * Create Target Array
+  #--------------------------------------------------------------------------
+  def make_targets
+    if !forcing && subject.confusion?
+      [confusion_target]
+    elsif item.for_opponent?
+      targets_for_opponents
+    elsif item.for_friend?
+      targets_for_friends
+    else
+      []
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Target When Confused
+  #--------------------------------------------------------------------------
+  def confusion_target
+    case subject.confusion_level
+    when 1
+      opponents_unit.random_target
+    when 2
+      if rand(2) == 0
+        opponents_unit.random_target
+      else
+        friends_unit.random_target
+      end
+    else
+      friends_unit.random_target
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Targets for Opponents
+  #--------------------------------------------------------------------------
+  def targets_for_opponents
+    if item.for_random?
+      Array.new(item.number_of_targets) { opponents_unit.random_target }
+    elsif item.for_one?
+      num = 1 + (attack? ? subject.atk_times_add.to_i : 0)
+      if @target_index < 0
+        [opponents_unit.random_target] * num
+      else
+        [opponents_unit.smooth_target(@target_index)] * num
+      end
+    else
+      opponents_unit.alive_members
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Targets for Allies
+  #--------------------------------------------------------------------------
+  def targets_for_friends
+    if item.for_user?
+      [subject]
+    elsif item.for_dead_friend?
+      if item.for_one?
+        [friends_unit.smooth_dead_target(@target_index)]
+      else
+        friends_unit.dead_members
+      end
+    elsif item.for_friend?
+      if item.for_one?
+        [friends_unit.smooth_target(@target_index)]
+      else
+        friends_unit.alive_members
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Evaluate Value of Action (for Auto Battle)
+  #    @value and @target_index are automatically set.
+  #--------------------------------------------------------------------------
+  def evaluate
+    @value = 0
+    evaluate_item if valid?
+    @value += rand if @value > 0
+    self
+  end
+  #--------------------------------------------------------------------------
+  # * Evaluate Skill/Item
+  #--------------------------------------------------------------------------
+  def evaluate_item
+    item_target_candidates.each do |target|
+      value = evaluate_item_with_target(target)
+      if item.for_all?
+        @value += value
+      elsif value > @value
+        @value = value
+        @target_index = target.index
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Get Use Target Candidates for Skills/Items
+  #--------------------------------------------------------------------------
+  def item_target_candidates
+    if item.for_opponent?
+      opponents_unit.alive_members
+    elsif item.for_user?
+      [subject]
+    elsif item.for_dead_friend?
+      friends_unit.dead_members
+    else
+      friends_unit.alive_members
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Evaluate Skill/Item (Target Specification)
+  #--------------------------------------------------------------------------
+  def evaluate_item_with_target(target)
+    target.result.clear
+    target.make_damage_value(subject, item)
+    if item.for_opponent?
+      return target.result.hp_damage.to_f / [target.hp, 1].max
+    else
+      recovery = [-target.result.hp_damage, target.mhp - target.hp].min
+      return recovery.to_f / target.mhp
+    end
+  end
+end