[VX/VXA Script] LILY'S MEGA DATA!

MegaData

Code:
#==============================================================================

# ** LILY'S MEGA DATA!

#------------------------------------------------------------------------------

#    by DerVVulfman

#    version 1.0

#    08-22-2017 (mm/dd/yyyy)

#    RUBY - RGSS / RGSS2 / RGSS3 (RMXP, RMVX & RMVXAce)

#==============================================================================

#

#  Introduction:

#  =============

#

#  Are you bummed by the 999 database limit for skills, items, actors and the

#  like?  If so, then you may want to make a mega-data database.

#

#  This script alters the load_data kernel to recognize key databases used by

#  the RPGMaker engines which use Ruby Scripting, and allows additional data-

#  base records to be added upon game load.

#

#  This script may also generate a txt file (or set of text files) which will

#  list all the items within your mega databases.

#

#                                == * == * ==

#

#  The MegaData Module:

#  ====================

#  

#  This module is your configuration section, controlling how the script runs

#  and holds the lists of any additional  RPGMaker databases  which are being

#  imported into the project.

#

#  The first set of values are the two within the BASIC SETTINGS category and

#  are as follows:

#

#  * RGSS_SYSTEM:  This setting lets you use this system for whichever version

#                  of RPGMaker you choose,  as long as it uses Ruby Scripting.

#

#                  A value of 0 (by default)  informs the script that it is in

#                  an RPGMaker XP project.   Meanwhile,  a value of 1 will set

#                  the system to read and recognize RPGMaker VX data files,and

#                  a value of 2 informs the script that it is being used in an

#                  RPGMaker VXAce project.

#

#  * LIST_SYSTEM:  This is a simple true/false setting that determines if the

#                  project will generate any database output text files.

#

#                  Generated output files  will be created  in your project's

#                  root folder, and always begin with "MEGA" in its name. The

#                  file(s)  are only generated  for those databases  that are

#                  being appended by outside database files.

#

#                  Remember to turn the feature off for your completed games.

#

#  The second set of values are arrays,  each meant to hold  the filenames of

#  additional database being loaded.  These extra databases attach themselves

#  to your existing ones, never overwriting them.

#

#  The List of arrays are as follows:

#

#  * ACTOR_LIST   - To let you go beyond 999 actors.

#  * SKILL_LIST   - To let you learn more than 999 skills.

#  * ITEM_LIST    - To let you have more than 999 items.

#  * WEAP_LIST    - To let you have more than 999 weapons in your armory.

#  * ARMOR_LIST   - To let you go beyond 999 pieces of armor.

#  * ENEMY_LIST   - To let you increase your bestiary beyond 999 foes.

#  * ANIM_LIST    - To let you go beyond 999 battle animations.

#  * TILES_LIST   - To let you have more than 999 tilesets (RMXP Only).

#

#  When adding a database filename to the list,  you only enter  the filename

#  itself without either the Data pathway or the file's extension. It is made

#  this way to let the system work more easily  with the multiple RUBY script

#  platforms.  An example appears in the script by default.

#

#  EX:  SKILL_LIST  = ["Skills2"]

#

#  So not only will the project load the default 'Data\Skills.rxdata' file, but

#  also an accompanying Skills2.rxdata file within the Data folder. This, assu-

#  ming that a Skills2.rxdata file exists, otherwise an error will occur.

#

#

#                                == * == * ==

#

#  USAGE:

#  ======

#  

#  This master script is designed to allow you  to increase the size  of your

#  available data.  However, the default RPGMaker editors only work with data

#  up to record 999.  Ergo, you will need to use script commands and/or addi-

#  tional code to mimic typical map event commands like 'Change Actor' or the

#  like.

#

#                                == * == * ==

#

#  COMPATIBILITY:

#  ==============

#

#  This script should be usable for all Ruby-Scripting versions of RPGMaker,

#  and it merely attaches code  to the 'load_data' method  within the Kernel

#  module itself.  

#

#                                == * == * ==

#

#  CREDITS AND THANKS:

#  ===================

#

#  Thanks goes to a dear friend who inquired just this past week if one could

#  get past the 999 item or skill limit.

#

#==============================================================================

#

#  TERMS AND CONDITIONS:

#  =====================

#

#  Free for use, even in commercial games.  Due credit is all that's required.

#

#==============================================================================

module MegaData

  # BASIC SETTINGS

  # ==============

  # Basic control switches determining the Ruby based engine in use, or if the

  # system outputs a file containing the whole list of 'records' of a combined

  # mega database.

  #

    RGSS_SYSTEM   = 0       # 0 = RGSS/RMXP, 1 = RGSS2/RMVX, 2 = RGSS3/RMVXAce

    LIST_SYSTEM   = true    # If true, outputs a txt file for the combined data

  # ADDITIONAL FILES

  # ================

  # Each is an array containing the filenames of additional database files with

  # its records being added into the database for the current project. Only the

  # name of the extra file is needed as the script recognizes that each file is

  # within the Data folder, and attaches the suitable file extension ( .rxdata,

  # .rvdata, rvdata2).  The arrays may be set to nil or [] (empty).

  #

    ACTOR_LIST  = nil

    SKILL_LIST  = ["Skills2"]   # <--- example for having 'Data\Skills2.rxdata'

    ITEM_LIST   = nil 

    WEAP_LIST   = nil

    ARMOR_LIST  = nil

    ENEMY_LIST  = nil

    ANIM_LIST   = nil

    TILES_LIST  = nil

end

#==============================================================================

# ** Kernel

#------------------------------------------------------------------------------

#  The Kernel module is a child of the Object class, allowing all methods and

#  values within to be globally accessible unless overridden.

#==============================================================================

module Kernel

  #--------------------------------------------------------------------------

  # * Alias / Renamed Method Listings with F12 anti-stack support

  #--------------------------------------------------------------------------

  if @kernel_mega_load_data_stack.nil?

    @kernel_mega_load_data_stack = true

    alias kernel_mega_load_data load_data

  end

  #--------------------------------------------------------------------------

  # * load data

  #     filename : name of data file - able to read encrypted game data.

  #--------------------------------------------------------------------------

  def load_data(filename)

    # Acquire position of filename's period

    parse_cnt = filename.index(".")

    # Crop away file extension for non-biased system test

    testname = filename[0,parse_cnt]

    # Branch on filename, retrieving data (expanded or otherwise)

    case testname

    when "Data/Actors"

      effective = load_mega("Data/Actors", MegaData::ACTOR_LIST)

    when "Data/Skills"

      effective = load_mega("Data/Skills", MegaData::SKILL_LIST)

    when "Data/Items"

      effective = load_mega("Data/Items", MegaData::ITEM_LIST)

    when "Data/Weapons"

      effective = load_mega("Data/Weapons", MegaData::WEAP_LIST)

    when "Data/Armors"

      effective = load_mega("Data/Armors", MegaData::ARMOR_LIST)

    when "Data/Enemies"

      effective = load_mega("Data/Enemies", MegaData::ENEMY_LIST)

    when "Data/Animations"

      effective = load_mega("Data/Animations", MegaData::ANIM_LIST)

    when "Data/Tilesets"

      effective = load_mega("Data/Tilesets", MegaData::TILES_LIST)

    else

      effective = kernel_mega_load_data(filename)

    end

    # Return database data

    return effective

  end

  #--------------------------------------------------------------------------

  # * load mega data

  #     filename  : name of data file - able to read encrypted game data.

  #     arraylist : list of additional data files added 

  #--------------------------------------------------------------------------

  def load_mega(filename, arraylist)

    # Keep old filename for output (minus data folder)

    oldfilename = filename[5,filename.length]

    # Attach filename extension based on RGSS used

    filename = load_mega_extension(filename)

    # Acquire records from default datafile

    effective = kernel_mega_load_data(filename)

    # Set our counter

    counter = 0

    # Sort through datafile records

    for record in effective

      # Skip null record

      next if record.nil?

      # Increase counter for each viable record

      counter += 1

    end

    # Exit with normal data if array list is nil

    return effective if  arraylist.nil? or arraylist == []

    # Generate a list, if enabled

    if MegaData::LIST_SYSTEM == true

      # Create the new text file for the given data

      f = File.new("MEGA " + oldfilename+".txt",  "w+")

      f.puts "Initial Project Data:"

      # Sort through the new data records

      for record in effective

        # Skip null record

        next if record.nil?

        # Create a formatted string of the ID and record data name

        formatted = "ID: " + (record.id).to_s + " - " + record.name

        # Output to the file

        f.puts formatted

      end  

      # Add 1 line spacing

      f.puts " "

    end

    # Sort through each filename

    for datafile in arraylist

      # Apply Data folder prefix to datafile name

      renamed_datafile = "Data/" + datafile

      # Attach filename extension based on RGSS used

      renamed_datafile = load_mega_extension(renamed_datafile)

      # Acquire records from acquired filename

      tempeffective = kernel_mega_load_data(renamed_datafile)

      # Generate file heading for report if enabled

      if MegaData::LIST_SYSTEM == true

        f.puts "Data from: " + datafile

      end

      # Sort through datafile records

      for record in tempeffective

        # Skip null record

        next if record.nil?

        # Increase counter for viable record

        counter += 1

        # Redefine current record's ID by counter

        record.id = counter

        # Add record data to default datafile

        effective.push record

        # Output record for report if enabled

        if MegaData::LIST_SYSTEM == true

          # Create a formatted string of the ID and record data name

          formatted = "ID: " + (record.id).to_s + " - " + record.name

          # Output to the file

          f.puts formatted

        end

      end

      # Add 1 line spacing

      if MegaData::LIST_SYSTEM == true

        f.puts " "

      end    

    end

    # Close Report generator if enabled

    if MegaData::LIST_SYSTEM == true

      f.close

    end    

    # Exit with expanded datafile

    return effective

  end

  #--------------------------------------------------------------------------

  # * load mega datafile extension

  #     filename  : name of data file to have the extension attached

  #--------------------------------------------------------------------------

  def load_mega_extension(filename)

    # Attach filename extension based on RGSS used

    case MegaData::RGSS_SYSTEM

    when 1

      effective = filename + ".rvdata"

    when 2

      effective = filename + ".rxdata2"

    else

      effective = filename + ".rxdata"

    end

    return effective

  end

end

Example RMXP addon

Code:
#==============================================================================

# ** Interpreter

#------------------------------------------------------------------------------

#  This interpreter runs event commands. This class is used within the

#  Game_System class and the Game_Event class.

#==============================================================================

class Interpreter

  #--------------------------------------------------------------------------

  # * Test Party for an Actor

  #     actor_id : actor ID

  #--------------------------------------------------------------------------

  def mega_actor_test(actor_id)

    return true if $game_party.actors.include?(actor)

    return false

  end  

  #--------------------------------------------------------------------------

  # * Change Actor

  #     actor_id : actor ID

  #     remove   : (optional: If true, removes actor from party)

  #--------------------------------------------------------------------------

  def mega_actor_change(actor_id=1, remove=false)

    unless remove

      $game_party.add_actor(actor_id)

    else

      $game_party.remove_actor(actor_id)

    end

  end    

  #--------------------------------------------------------------------------

  # * Change Actor HP Increase

  #     actor_id    : actor ID

  #     value       : Value of HP gain (or loss if negative)

  #     allow_death : if knockout allows death

  #--------------------------------------------------------------------------

  def mega_actor_HP(actor_id=1, value=0, allow_death=false)

    actor = $game_actors[actor_id]

    return if actor.nil?

    $game_actors[actor_id].hp += value

    if allow_death == false and $game_actors[actor_id].hp == 0

      $game_actors[actor_id].hp = 1    

    end

    # Determine game over

    $game_temp.gameover = $game_party.all_dead?

  end

  #--------------------------------------------------------------------------

  # * Change Actor SP Increase

  #     actor_id    : actor ID

  #     value       : Value of SP gain (or loss if negative)

  #--------------------------------------------------------------------------

  def mega_actor_HP(actor_id=1, value=0)

    actor = $game_actors[actor_id]

    return if actor.nil?

    $game_actors[actor_id].sp += value

  end    

  #--------------------------------------------------------------------------

  # * Change Enemy HP Increase

  #     enemy_id    : enemy ID

  #     value       : Value of HP gain (or loss if negative)

  #--------------------------------------------------------------------------

  def mega_actor_HP(enemy_id=1, value=0)

    enemy = $game_troop.enemies[enemy_id]

    return if enemy.nil?

    $game_troop.enemies[enemy_id].hp += value

  end

  #--------------------------------------------------------------------------

  # * ChangeEnemy SP Increase

  #     enemy_id    : enemy ID

  #     value       : Value of SP gain (or loss if negative)

  #--------------------------------------------------------------------------

  def mega_actor_HP(enemy_id=1, value=0)

    enemy = $game_troop.enemies[enemy_id]

    return if enemy.nil?

    $game_troop.enemies[enemy_id].sp += value

  end      

  #--------------------------------------------------------------------------

  # * Test Actor for a Skill

  #     actor_id : actor ID

  #     skill_id : skill ID

  #--------------------------------------------------------------------------

  def mega_skill_test(actor_id=1, skill_id=1)

    actor = $game_actors[actor_id]

    return false if actor.nil?

    return true if actor.skills.include?(skill_id)

    return false

  end

  #--------------------------------------------------------------------------

  # * Change Skill

  #     actor_id : actor ID

  #     skill_id : skill ID

  #     remove   : (optional: If true, removes skill from actor)

  #--------------------------------------------------------------------------

  def mega_skill_change(actor_id=1, skill_id=1, remove=false)

    actor = $game_actors[actor_id]

    return if actor.nil?

    unless remove

      actor.learn_skill(skill_id)

    else

      actor.forget_skill(skill_id)

    end

  end

  #--------------------------------------------------------------------------

  # * Test Party for an Item

  #     item_id : item ID

  #--------------------------------------------------------------------------

  def mega_item_test(item_id=1)

    return true if $game_party.items.include?(item_id)

    return false

  end  

  #--------------------------------------------------------------------------

  # * Change Item

  #     item_id : item ID

  #     remove   : (optional: If true, removes item from party)

  #--------------------------------------------------------------------------

  def mega_item_change(item_id=1, qty=1, remove=false)

    unless remove

      $game_party.gain_item(item_id, qty)

    else

      $game_party.lose_item(item_id, qty)

    end

  end  

  #--------------------------------------------------------------------------

  # * Test Party for a Weapon

  #     weapon_id : item ID

  #--------------------------------------------------------------------------

  def mega_weapon_test(weapon_id=1)

    return true if $game_party.weapons.include?(weapon_id)

    return false

  end  

  #--------------------------------------------------------------------------

  # * Change Weapon

  #     weapon_id : weapon ID

  #     remove    : (optional: If true, removes weapon from party)

  #--------------------------------------------------------------------------

  def mega_weapon_change(weapon_id=1, qty=1, remove=false)

    unless remove

      $game_party.gain_weapon(weapon_id, qty)

    else

      $game_party.lose_weapon(weapon_id, qty)

    end

  end 

  #--------------------------------------------------------------------------

  # * Test Party for a Armor

  #     armor_id : armor ID

  #--------------------------------------------------------------------------

  def mega_armor_test(armor_id=1)

    return true if $game_party.armors.include?(armor_id)

    return false

  end

  #--------------------------------------------------------------------------

  # * Change Armor

  #     armor_id : armor ID

  #     remove   : (optional: If true, removes armor from party)

  #--------------------------------------------------------------------------

  def mega_armor_change(armor_id=1, qty=1, remove=false)

    unless remove

      $game_party.gain_armor(armor_id, qty)

    else

      $game_party.lose_armor(armor_id, qty)

    end

  end

  #--------------------------------------------------------------------------

  # * Show Animation

  #  anim_id : animation ID

  #  event_id : event ID (-1 = player, 0 = this event, 1+ identified on map)

  #--------------------------------------------------------------------------

  def mega_animation_event(anim_id, event_id=0)

    # Get character

    character = get_character(event_id)

    # If no character exists

    if character == nil

      # Continue

      return true

    end

    # Set animation ID

    character.animation_id = anim_id

    # Continue

    return true

  end  

end