#==============================================================================
# ** Math Module
#==============================================================================
module Math
  #-------------------------------------------------------------------------
  #   Name:      Nth Root
  #   Info:      Finds the nth root
  #   Author:    Icarus Featherfight
  #   Call Info: Numeric nth and other
  #   Returns:   An interger of the nth root rounded to the nearest whole number
  #   Example:   Math.√ 3, 729 => 9
  #-------------------------------------------------------------------------
  def Math.root(n, other, both = false)
    return nil if other < 0 and n % 2 == 0
    case n
    when 0
      raise ZeroDivisionError, "You cannot find the zeroith root of a number"
    when 1
      return other
    when 2
      return both ? [sqrt(other), -(sqrt(other))] : sqrt(other)
    else
      # Make an initial guess
      g = 15
      if other < g**n and (g**n - other).abs > ((g-5)**n - other).abs
        g -= 5
      elsif other > g**n and (g**n - other).abs > ((g+5)**n - other).abs
        g += 5
      end
      # Return if the guess is now correct
      return (n % 2 == 0 && both ? [g, -g] : g) if other == g**n
      # If not, refine the guess...
      if other < (g.√ 2)**n
        g = g.√ 2
      elsif other > g**2**n
        g **= 2
      end
      # and use nth root algorithm to iteratively find the nth root x
      x = [g.to_f]
      until x[-2] != nil and (x[-2]*100_000).round == (x[-1]*100_000).round
        x.push 1.to_f/n * ((n-1).to_f * x[-1] + other.to_f / x[-1]**(n-1))
      end
      x = x.pop.round
      return n % 2 == 0 && both ? [x, -x] : x
    end
  end
end

Expand to see the code.

#==============================================================================
# ** Numeric
#==============================================================================
class Numeric
  #-------------------------------------------------------------------------
  #   Name:      ? (plus-minus)
  #   Info:      Both adds and subtacts
  #   Author:    Icarus Featherfight
  #   Call Info: One Argument: other
  #   Returns:   An array of both the addition and the subtraction values
  #   Example:   4.? 7 => [11, -3]
  #-------------------------------------------------------------------------
  def ?(other)
    return [self + other, self - other]
  end
  #-------------------------------------------------------------------------
  #   Name:      Nth Root
  #   Info:      Finds the nth root
  #   Author:    Icarus Featherfight
  #   Call Info: A Numeric other
  #   Returns:   An interger of the nth root rounded to the nearest whole number
  #   Example:   3.√ 729 => 9
  #              3.root 729 => 9
  #-------------------------------------------------------------------------
  def √(other)
    return Math.root(self, other)
  end
  alias_method :root, :√
end

Expand to see the code.

=begin
==============================================================================
** Array.math
------------------------------------------------------------------------------
Description:
------------
  More Mathematical methods for the Array class. These methods however assume
  all objects in the array are of class Numeric.
 
Method List:
------------
  Arithmetic operators (+, -, ?, *, /, **, √)
==============================================================================
=end
class Array
  #-------------------------------------------------------------------------
  #   Names:     Arithmetic operators (+, -, ?, *, /, %, **, √)
  #   Info:      Preforms basic mathamatical operations on the array
  #   Author:    Icarus Featherfight
  #   Call Info: A Numeric other
  #   Returns:   The Array self with each element modified
  #   Examples:  [6, 2, 4] + 1      =>  [7, 3, 5]
  #              [0, 3, 2] - 1      =>  [-1, 2, 1]
  #              [5, 6, 3].? 2      =>  [[7, 3], [8, 4], [5, 1]]
  #              [9, 1, 7] * 3      =>  [27, 3, 21]
  #              [6, 12, 9] / 3     =>  [2, 4, 3]
  #              [3, 5, 10] ** 3    =>  [27, 125, 1000)
  #              [25, 4, 9].√ 2     =>  [5, 2, 3]
  #              [25, 4, 9].root 2  =>  [5, 2, 3]
  #-------------------------------------------------------------------------
  alias_method :icarus_macl_add, :+
  def +(other)
    if other.is_a? Numeric
      result = []
      self.each_index {|index| result[index] = self[index] + other}
      return result
    else
      icarus_macl_add(other)
    end
  end
  #-------------------------------------------------------------------------
  alias_method :icarus_macl_subtract, :-
  def -(other)
    if other.is_a? Numeric
      result = []
      self.each_index {|index| result[index] = self[index] - other}
      return result
    else
      icarus_macl_subtract(other)
    end
  end
  #-------------------------------------------------------------------------
  def ?(other)
    result = []
    self.each_index {|index| result[index] = self[index].? other}
    return result
  end
  #-------------------------------------------------------------------------
  def *(other)
    result = []
    self.each_index {|index| result[index] = self[index] * other}
    return result
  end
  #-------------------------------------------------------------------------
  def /(other)
    result = []
    self.each_index {|index| result[index] = self[index] / other}
    return result
  end
  #-------------------------------------------------------------------------
  def %(other)
    result = []
    self.each_index {|index| result[index] = self[index] % other}
    return result
  end
  #-------------------------------------------------------------------------
  def **(other)
    result = []
    self.each_index {|index| result[index] = self[index] ** other}
    return result
  end
  #-------------------------------------------------------------------------
  def √(nth)
    result = []
    self.each_index {|index| result[index] = other.√ self[index]}
    return result
  end
  alias_method :root, :√
end

Expand to see the code.

#==============================================================================
# ** Array
#==============================================================================
class Array
  #-------------------------------------------------------------------------
  #   Name:      []
  #   Info:      Modifies [key] when key is a range expression
  #              Return an array of indexed values within the range
  #   Author:    Icarus Featherfight
  #   Example:   @data = [6, nil, true, 'max', 4]
  #              p @data[-1..2] => [4, 6, true]
  #-------------------------------------------------------------------------
  alias_method :icarus_macl_index, :[]
  def [](key)
    if key.is_a? Range
      array = []
      for index in key do array << self[index] end
      return array
    else
      icarus_macl_index(key)
    end
  end
  #-------------------------------------------------------------------------
  #   Name:      []=
  #   Info:      Modifies [key]=(value) when key is a range expression
  #              Sets each index within the key (range) to value
  #   Author:    Icarus Featherfight
  #   Example:   @data = []
  #              @data[1..5] = 2
  #              p @data => [nil, 2, 2, 2, 2, 2]
  #-------------------------------------------------------------------------
  alias_method :icarus_macl_indexequals, :[]=
  def []=(key, value)
    if key.is_a? Range
      for index in key do self[index] = value end
    else
      icarus_macl_indexequals(key, value)
    end
  end
end

Expand to see the code.

=begin
==============================================================================
** unsort
------------------------------------------------------------------------------
Description:
------------
  this method can unsort all types of Enumerable

Class List:
-----------
  Enumerable
  Array

Method List: (avaiable for all classes)
------------
  unsort

==============================================================================
=end

module Enumerable
  #-------------------------------------------------------------------------
  #   Name      : unsort
  #   Info      : return a array of mixed elements
  #   Author    : Hanmac
  #   Call Info : with no Arguments
  #   Comments  : can make nosense with strings
  #-------------------------------------------------------------------------
  def unsort
    Array.unsort(self.entries)
  end
end

class Array
  #-------------------------------------------------------------------------
  #   Name      : self.unsort
  #   Info      : return a array of mixed elements
  #   Author    : Hanmac
  #   Call Info :  with min one Argument from type can this be everything
  #-------------------------------------------------------------------------
   def self.unsort(*arrays)
      array = arrays.flatten
      Array.new(array.size) {
         zufall = rand(array.size)
         array.delete_at(zufall)
      }
   end
  #-------------------------------------------------------------------------
  #   Name      : unsort
  #   Info      : return a array of mixed elements
  #   Author    : Hanmac
  #   Call Info : with no Arguments
  #-------------------------------------------------------------------------
   def unsort
      self.class.unsort(self)
   end
end

Expand to see the code.

=begin
==============================================================================
** Range.sort
------------------------------------------------------------------------------
Description:
------------
  with this you can sort Ranges

Class List:
-----------
  Range

Method List:
------------
  <=>

==============================================================================
=end

class Range
  include(Comparable)
  def <=>(other)
    temp = first <=> other.first
    temp = last <=> other.last if temp = 0
    return temp
  end
end

Expand to see the code.

  #-------------------------------------------------------------------------
  # * Name      : To HSB
  #   Info      : Converts to Hue, Saturation, and Brightness
  #               returns an array setup like so: [hue, sat, bright]
  #   Author    : Trickster
  #   Call Info : No Arguments
  #-------------------------------------------------------------------------
  def to_hsb
    return self.class.to_hsb(red, green, blue)
  end

Expand to see the code.

#==============================================================================
# ** RGSS.Table
#------------------------------------------------------------------------------
# Description:
# ------------
# Adds new features to the Table class. [] and []= methods now accept
# coordinate key arrays and negative coordinate indexes. It also adds
# iteration methods, the Enumerable module and several miscellaneous methods
# all objects in the array are of class Numeric.
#
# Modified Methods:
# -----------------
# initialize
# []
# []=
# _dump
# self._load
#
# Methods Added:
# ------------
# Enumerable (see below)
# each
# each_coordinates
# each_with_coordinates
# coordinates
# each_index
# index
# clear
# nitems
# compact
# compact!
# plane
# column
# row
#==============================================================================
#==============================================================================
# ** Table
#==============================================================================
class Table
  #-------------------------------------------------------------------------
  # Include
  # * Names     : all?, any?, collect, map, each_with_index,  find, detect,
  #               find_all, select, grep, inject, member?, include?, max,
  #               min, partition, reject, sort, sort_by, to_a, entries, zip
  #------------------------------------------------------------------------- 
  include Enumerable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :negitive_read            # allow negitive index reading?
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias_method :icarus_table_initialize, :initialize
  def initialize(*args)
    icarus_table_initialize(*args)
    # Default value for negitive index reading
    @negitive_read = true
    # Store number of axis for each coordinate method
    @axis = args.size
  end
  #-------------------------------------------------------------------------
  # * []
  #-------------------------------------------------------------------------
  alias_method :icarus_table_nth, :[]
  def [](*args)
    # Remove nil arguments from the end of the array
    args.delete_at(-1) while args[-1].nil?
    # If negitive reading is enabled
    if @negitive_read
      # Modify arguments if they are negative indexes
      args[0] += self.xsize unless                 args[0] >= 0
      args[1] += self.ysize unless args[1].nil? or args[1] >= 0
      args[2] += self.zsize unless args[2].nil? or args[2] >= 0
    end
    # Call original method with modified arguments
    return icarus_table_nth(*args)
  end
  #-------------------------------------------------------------------------
  # * []=
  #-------------------------------------------------------------------------
  alias_method :icarus_table_nthequals, :[]=
  def []=(*args)
    # Modify arguments if they are negative indexes
    args[0] += self.xsize unless                 args[0] >= 0
    args[1] += self.ysize unless args[2].nil? or args[1] >= 0
    args[2] += self.zsize unless args[3].nil? or args[2] >= 0
    # Call original method with modified arguments
    icarus_table_nthequals(*args)
  end
  #-------------------------------------------------------------------------
  # * _dump
  #-------------------------------------------------------------------------
  alias_method :icarus_table_dump, :_dump
  def _dump(i)
    return icarus_table_dump(i) + '~~' +
           Marshal.dump(@negitive_read) + '~~' + Marshal.dump(@axis)
  end
  #-------------------------------------------------------------------------
  # * self._load
  #-------------------------------------------------------------------------
  class << self
    alias_method :icarus_table_load, :_load
  end
  def self._load(string)
    array = string.split('~~')
    table = self.icarus_table_load(array[0])
    unless array[1].nil?
      table.instance_variable_set(:@negitive_read, Marshal.load(array[1]))
      table.instance_variable_set(:@axis, Marshal.load(array[2]))
    end
    return table
  end
  #-------------------------------------------------------------------------
  # * Name      : Each
  #   Info      : Iterates through all coordinates, yielding each value
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #   Comments  : Provides the basis for included Enumerable methods
  #-------------------------------------------------------------------------
  def each
    each_coordinates{|key| yield self[*key]}
  end
  #-------------------------------------------------------------------------
  # * Name      : Each Coordinates
  #   Info      : Iterates through all coordinates in the table
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #   Comments  : See Each or Coordinates methods for proper block setup
  #-------------------------------------------------------------------------
  def each_coordinates
    for x in 0...self.xsize
      if @axis == 1
        yield [x]
      else
        for y in 0...self.ysize
          if @axis == 2
            yield [x, y]
          else
            for z in 0...self.zsize
              yield [x, y, z]
            end
          end
        end
      end
    end
    return nil
  end
  #-------------------------------------------------------------------------
  # * Name      : Each With Coordinates
  #   Info      : Iterates through table, yielding each value and key
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def each_with_coordinates
    each_coordinates{|key| yield (self[*key], key)}
  end
  #-------------------------------------------------------------------------
  # * Name      : Coordinates
  #   Info      : Finds the first coordinates to contain a value
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def coordinates(value)
    each_coordinates{|key| return key if self[*key] == value}
  end
  #-------------------------------------------------------------------------
  # * Name      : Each Index
  #   Info      : Iterates through all indexes in a table array
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #-------------------------------------------------------------------------
  def each_index
    self.to_a.each_index{|index| yield(index)}
  end
  #-------------------------------------------------------------------------
  # * Name      : Index
  #   Info      : Finds the first index to contain a value
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def index(value)
    each_with_index{|val, index| return index if val == value}
  end
  #-------------------------------------------------------------------------
  # * Name      : Clear
  #   Info      : Reinitializes table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #   Comments  : See Array.clear
  #-------------------------------------------------------------------------
  def clear
    # Reset table
    if self.ysize == 1    then initialize(self.xsize)
    elsif self.zsize == 1 then initialize(self.xsize, self.ysize)
    else                       initialize(self.xsize, self.ysize, self.zsize)
    end
    return self
  end
  #-------------------------------------------------------------------------
  # * Name      : NItems
  #   Info      : Iterates through index, counting all non-zero elements
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def nitems
    n = 0
    each{|value| n += 1 unless value == false}
    return n
  end
  #-------------------------------------------------------------------------
  # * Name      : Compact
  #   Info      : Returns a new table with nil elements removed from positive
  #               extremities of table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def compact
    return self.dup.compact!
  end
  #-------------------------------------------------------------------------
  # * Name      : Compact!
  #   Info      : Removes nil elements from positive extremities of table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def compact!
    if self.zsize == 1
      x = self.xsize
      y = self.ysize
      x -= 1 while row(x - 1).all?{|item| item.nil?} && x > 1
      y -= 1 while column(y - 1).all?{|item| item.nil?} && y > 1
      resize(x, y)
    else
      planes = []
      for z in 0...self.zsize
        planes[z] = plane(z).compact!
      end
      planes.delete_at(-1) while planes[-1].all?{|item| item.nil?}
      xmax, ymax = 1, 1
      planes.each{|table|
                  xmax = table.xsize if xmax < table.xsize
                  ymax = table.ysize if ymax < table.ysize
                  }
      resize(xmax, ymax, planes.size)
    end
    return self
  end
  #-------------------------------------------------------------------------
  # * Name      : Plane
  #   Info      : On a 3D table returns the 2D plane at z value
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical z
  #-------------------------------------------------------------------------
  def plane(z)
    return if self.ysize == 1 || self.zsize == 1 || z.nil? || z >= self.zsize
    if self.class == Object_Table
      plane = Object_Table.new(self.xsize, self.ysize)
    else
      plane = Table.new(self.xsize, self.ysize)
    end
    for x in 0...self.xsize
      for y in 0...self.ysize
        plane[x, y] = self[x, y, z]
      end
    end
    return plane
  end
  #-------------------------------------------------------------------------
  # * Name      : Column
  #   Info      : On a 3D or 2D table returns the array at y and z values.
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical y and an optional z for 3D tables
  #-------------------------------------------------------------------------
  def column(x, z = nil)
    column = []
    for y in 0...self.ysize
      column[y] = self[x, y, z]
    end
  end
  #-------------------------------------------------------------------------
  # * Name      : Row
  #   Info      : On a 3D or 2D table returns the array at x and z values.
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical x and an optional z for 3D tables
  #-------------------------------------------------------------------------
  def row(y, z = nil)
    row = []
    for x in 0...self.xsize
      row[x] = self[x, y, z]
    end
  end
end

Expand to see the code.

#==============================================================================
# ** Object Table                                        By Icarus Featherfight
#------------------------------------------------------------------------------
#  The multidimensional array class; extended to hold objects.
#   - when resizing table, all data from before the size change is retained
#==============================================================================
class Object_Table < Table
  #-------------------------------------------------------------------------
  # Include ObjectSpace
  # * Names     : _id2ref, define_finalizer, each_object, garbage_collect,
  #               undefine_finalizer
  #------------------------------------------------------------------------- 
  include ObjectSpace
  #-------------------------------------------------------------------------
  # * Name      : Initialize
  #   Info      : Creates main table and additional depth table
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate maximums (xsize[, ysize[, zsize]])
  #-------------------------------------------------------------------------
  def initialize(*args)
    super
    # Creates depth table
    @depth = Table.new(*args)
    # Initialize table with nil values
    self.each_coordinates{|key| self[*key] = nil}
  end
  #-------------------------------------------------------------------------
  # * Name      : Element Reference
  #   Info      : Extends method to return objects; stored as ids
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate arguments or one coordinate key array
  #   Comments  : Prevents ArgumentErrors when using a coordinate key array
  #-------------------------------------------------------------------------
  def [](*args)
    # Abort if coordinates are outside of table
    return nil if super.nil?
    # Returns original object after recalculating its id
    return _id2ref(super + (32_768 * @depth[*args]))
  end
  #-------------------------------------------------------------------------
  # * Name      : Element Assignment
  #   Info      : Extends method to store an objects id
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate arguments or array and value
  #   Comments  : Prevents ArgumentErrors when using a coordinate key array
  #-------------------------------------------------------------------------
  def []=(*args)
    # Free current contents for GC
    a = args.dup
    a.pop
    undefine_finalizer(self[*a]) unless self[*a] == false
    # Define finalizer to prevent GC
    define_finalizer(args[-1], proc {|id| p "Object Table Entry: #{id}" })
    # Replace object with its id
    args[-1] = args[-1].id
    # Create key for secondary depth table
    key = args.dup
    key.pop
    # Store depth and reduce id integer to effective range of table
    @depth[*key] = args[-1] / 32_768
    args[-1] %= 32_768
    # Store modified object id value
    return super(*args)
  end
  #-------------------------------------------------------------------------
  # * Name      : _dump
  #   Info      : Marshals Object_Table data
  #   Author    : Icarus Featherfight
  #   Call Info : An Interger i
  #   Comments  : Adds @depth Table to dump
  #-------------------------------------------------------------------------
  def _dump(i)
    return super(i) + '~|~' + Marshal.dump(@depth)
  end
  #-------------------------------------------------------------------------
  # * Name      : self._load
  #   Info      : Retores Object_Table from a marshaled string
  #   Author    : Icarus Featherfight
  #   Call Info : A String string
  #   Comments  : Restores @depth Table
  #-------------------------------------------------------------------------
  def self._load(string)
    array = string.split('~|~')
    table = super(array[0])
    table.instance_variable_set(:@depth, Marshal.load(array[1]))
    return table
  end
  #-------------------------------------------------------------------------
  # * Name      : Resize
  #   Info      : Resizes main table and additional depth table
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate maximums (xsize[, ysize[, zsize]])
  #   Comments  : All data from before the size change is retained
  #-------------------------------------------------------------------------
  def resize(*args)
    # Resize main table
    super
    # Resize depth table
    @depth.resize(*args)
  end
  #-------------------------------------------------------------------------
  # * Name      : Clear
  #   Info      : Reinitializes table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #   Comments  : See Array.clear
  #-------------------------------------------------------------------------
  def clear
    self.each{|obj| undefine_finalizer(obj)}
    super
  end
  #-------------------------------------------------------------------------
  # * Name      : Expand
  #   Info      : Returns the tables array with nested arrays expanded
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def expand
    array = self.to_a
    array.each_index{|i| array[i, 1] = array[i] if array[i].class == Array}
    return array
  end
end

Expand to see the code.

#==============================================================================
# ** Object Table                                        By Icarus Featherfight
#------------------------------------------------------------------------------
#  The multidimensional array class; can hold all objects.
#   - when resizing table, all data from before the size change is retained
#   - negative coordinate indexes can be used
#   - includes the Enumerable module
#==============================================================================
class Object_Table
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :negative_read            # allow negative index reading?
  attr_reader   :data                     # data array
  attr_reader   :xsize, :ysize, :zsize    # numerical coordinate maximums
  #-------------------------------------------------------------------------
  # * Name      : Initialize
  #   Info      : Initializes Object_Table
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 Numeric coordinate maximums (xsize[, ysize[, zsize]])
  #-------------------------------------------------------------------------
  def initialize(*args)
    # Store number of axis and axial maximums
    @axis = args.size
    @xsize, @ysize, @zsize = args[0], args[1], args[2]
    # Create data table array
    @data = []
    if @axis >= 2
      for x in 0...@xsize
        @data[x] = []
      end
      if @axis == 3
        for x in 0...@xsize
          for y in 0...@ysize
            @data[x][y] = []
          end
        end
      end
    end
    # Default value for negative index reading
    @negative_read = true
  end
  #-------------------------------------------------------------------------
  # * Name      : Element Reference
  #   Info      : Returns Object stored at coordinates
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 Numeric coordinate arguments
  #-------------------------------------------------------------------------
  def [](*args)
    # Raise ArgumentError if there is the wrong number of arguments
    raise ArgumentError if args.size != @axis
    # Return nil if negative reading is disabled and a coordinate is negative
    return nil if @negative_read == false and args.any?{|num| num < 0}
    # Return Object stored at coordinates
    case @axis
    when 1
      return @data[args[0]]
    when 2
      return nil if @data[args[0]].nil?
      return @data[args[0]][args[1]]
    when 3
      return nil if @data[args[0]].nil? or @data[args[0]][args[1]].nil?
      return @data[args[0]][args[1]][args[2]]
    end
  end
  #-------------------------------------------------------------------------
  # * Name      : Element Assignment
  #   Info      : Stores Object at designated coordinates
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate arguments and a Object value
  #-------------------------------------------------------------------------
  def []=(*args)
    # Raise ArgumentError if there is the wrong number of arguments
    raise ArgumentError if args.size - 1 != @axis
    # Raise IndexError if coordinates are out of range
    raise IndexError    if                   args[0] >= @xsize or
                           args[1] != nil && args[1] >= @ysize or
                           args[2] != nil && args[2] >= @zsize
    # Store Object at coordinates
    case @axis
    when 1
      return @data[args[0]]                   = args[-1]
    when 2
      return @data[args[0]][args[1]]          = args[-1]
    when 3
      return @data[args[0]][args[1]][args[2]] = args[-1]
    end
  end
  #-------------------------------------------------------------------------
  # Include
  # * Names     : all?, any?, collect, map, each_with_index,  find, detect,
  #               find_all, select, grep, inject, member?, include?, max,
  #               min, partition, reject, sort, sort_by, to_a, entries, zip
  #------------------------------------------------------------------------- 
  include Enumerable
  #-------------------------------------------------------------------------
  # * Name      : Each
  #   Info      : Iterates through all coordinates, yielding each value
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #   Comments  : Provides the basis for included Enumerable methods
  #-------------------------------------------------------------------------
  def each
    each_coordinates{|key| yield self[*key]}
  end
  #-------------------------------------------------------------------------
  # * Name      : Each Coordinates
  #   Info      : Iterates through all coordinates in the table
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #   Comments  : See Each or Coordinates methods for proper block setup
  #-------------------------------------------------------------------------
  def each_coordinates
    for x in 0...@xsize
      if @axis == 1
        yield [x]
      else
        for y in 0...@ysize
          if @axis == 2
            yield [x, y]
          else
            for z in 0...@zsize
              yield [x, y, z]
            end
          end
        end
      end
    end
    return nil
  end
  #-------------------------------------------------------------------------
  # * Name      : Each With Coordinates
  #   Info      : Iterates through table, yielding each value and key
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def each_with_coordinates
    each_coordinates{|key| yield (self[*key], key)}
  end
  #-------------------------------------------------------------------------
  # * Name      : Coordinates
  #   Info      : Finds the first coordinates to contain a value
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def coordinates(value)
    each_coordinates{|key| return key if self[*key] == value}
  end
  #-------------------------------------------------------------------------
  # * Name      : Each Index
  #   Info      : Iterates through all indexes in a table array
  #   Author    : Icarus Featherfight
  #   Call Info : A block
  #-------------------------------------------------------------------------
  def each_index
    self.to_a.each_index{|index| yield(index)}
  end
  #-------------------------------------------------------------------------
  # * Name      : Index
  #   Info      : Finds the first index to contain a value
  #   Author    : Icarus Featherfight
  #   Call Info : One numeric value to be found
  #-------------------------------------------------------------------------
  def index(value)
    each_with_index{|val, index| return index if val == value}
  end
  #-------------------------------------------------------------------------
  # * Name      : Clear
  #   Info      : Reinitializes table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #   Comments  : See Array.clear
  #-------------------------------------------------------------------------
  def clear
    initialize(@xsize, @ysize, @zsize)
  end
  #-------------------------------------------------------------------------
  # * Name      : Resize
  #   Info      : Resizes main table and additional depth table
  #   Author    : Icarus Featherfight
  #   Call Info : 1..3 coordinate maximums (xsize[, ysize[, zsize]])
  #   Comments  : All data from before the size change is retained
  #-------------------------------------------------------------------------
  def resize(*args)
    # Abort if new dimentions equal the old
    return if args[0] == @xsize and args[1] == @ysize and args[2] == @zsize
    # Destroy axis
    if args[1].nil?
      case @axis
      when 2
        # Destroy y axis
        for x in 0...@xsize
          @data[x] = @data[x][0]
        end
      when 3
        # Destroy y and z axis
        for x in 0...@xsize
          @data[x] = @data[x][0][0]
        end
      end
      @axis = 1
      @ysize, @zsize = nil, nil
    elsif args[2].nil?
      if @axis = 3
        # Destroy z axis
        for x in 0...@xsize
          for y in 0...@ysize
            @data[x][y] = @data[x][y][0]
          end
        end
      end
      @axis = 2
      @zsize = nil
    end
    # Resize x axis
    if args[0] < @xsize
      # Crop table
      for x in args[0]...@xsize
        @data.delete_at(x)
      end
    elsif args[0] > @xsize and @axis >= 2
      # Extend table
      for x in @xsize...args[0]
        @data[x] = []
      end
      if @axis == 3
        for x in @xsize...args[0]
          for y in @ysize...args[1]
            @data[x][y] = []
          end
        end
      end
    end
    return if @axis == 1
    # Resize y axis
    if args[1] < @ysize
      # Crop table
      for x in 0...args[0]
        for y in args[1]...@ysize
          @data[x].delete_at(y)
        end
      end
    elsif args[1] > @ysize and @axis == 3
      # Extend table
      for x in @xsize...args[0]
        for y in @ysize...args[1]
          @data[x][y] = []
        end
      end
    end
    return if @axis != 3
    # Resize z axis
    if args[2] < @zsize
      # Crop table
      for x in 0...args[0]
        for y in args[1]...@ysize
          for z in args[2]...@zsize
            @data[x][y].delete_at(z)
          end
        end
      end
    elsif args[2] > @zsize
      # Extend table
      for x in @xsize...args[0]
        for y in @ysize...args[1]
          @data[x][y] = []
        end
      end
    end
  end
  #-------------------------------------------------------------------------
  # * Name      : NItems
  #   Info      : Iterates through index, counting all non-zero elements
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def nitems
    n = 0
    each{|value| n += 1 unless value == false}
    return n
  end
  #-------------------------------------------------------------------------
  # * Name      : Compact
  #   Info      : Returns a new table with nil elements removed from positive
  #               extremities of table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def compact
    return self.dup.compact!
  end
  #-------------------------------------------------------------------------
  # * Name      : Compact!
  #   Info      : Removes nil elements from positive extremities of table
  #   Author    : Icarus Featherfight
  #   Call Info : No arguments
  #-------------------------------------------------------------------------
  def compact!
    if @zsize == nil
      x = @xsize
      y = @ysize
      x -= 1 while row(x - 1).all?{|item| item.nil?} && x > 1
      y -= 1 while column(y - 1).all?{|item| item.nil?} && y > 1
      resize(x, y)
    else
      planes = []
      for z in 0...@zsize
        planes[z] = plane(z).compact!
      end
      planes.delete_at(-1) while planes[-1].all?{|item| item.nil?}
      xmax, ymax = 1, 1
      planes.each{|table|
                  xmax = table.xsize if xmax < table.xsize
                  ymax = table.ysize if ymax < table.ysize
                  }
      resize(xmax, ymax, planes.size)
    end
    return self
  end
  #-------------------------------------------------------------------------
  # * Name      : Plane
  #   Info      : On a 3D table returns the 2D plane at z value
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical z
  #-------------------------------------------------------------------------
  def plane(z)
    return if @ysize == 1 || @zsize == 1 || z.nil? || z >= @zsize
    plane = Object_Table.new(@xsize, @ysize)
    for x in 0...@xsize
      for y in 0...@ysize
        plane[x, y] = @data[x][y][z]
      end
    end
    return plane
  end
  #-------------------------------------------------------------------------
  # * Name      : Column
  #   Info      : On a 3D or 2D table returns the array at y and z values.
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical y and an optional z for 3D tables
  #-------------------------------------------------------------------------
  def column(x, z = nil)
    column = []
    if z.nil?
      for y in 0...@ysize
        column[y] = @data[x][y]
      end
    else
      for y in 0...@ysize
        column[y] = @data[x][y][z]
      end
    end
  end
  #-------------------------------------------------------------------------
  # * Name      : Row
  #   Info      : On a 3D or 2D table returns the array at x and z values.
  #   Author    : Icarus Featherfight
  #   Call Info : A numerical x and an optional z for 3D tables
  #-------------------------------------------------------------------------
  def row(y, z = nil)
    row = []
    if z.nil?
      for x in 0...@xsize
        row[x] = @data[x][y]
      end
    else
      for x in 0...@xsize
        row[x] = @data[x][y][z]
      end
    end
  end
end

Expand to see the code.

  module Point_Slope
    #------------------------------------------------------------------------
    # * Generate Curve
    #
    #   Args : min_level, max_level, start value, inflation
    #------------------------------------------------------------------------
    def self.generate_curve(min_l, max_level, start_value, inflation)
      # Creates Table
      table = {}
      # Fills Table
      for level in min_l..max_l
        table[level] = start_value + inflation * level
      end
      # Return Table
      return table
    end
  end

Expand to see the code.

  module Point_Slope
    #------------------------------------------------------------------------
    # * Generate Curve
    #
    #   Args : min_l, max_l, start value, inflation
    #------------------------------------------------------------------------
    def self.generate_curve(min_l, max_l, start_value, inflation)
      # Creates Table
      table = {}
      # Fills Table
      for level in min_l..max_l
        table[level] = start_value + inflation * level
      end
      # Return Table
      return table
    end
  end

Expand to see the code.

module Curve_Generator
  #-------------------------------------------------------------------------
  # * Save Table
  #-------------------------------------------------------------------------
  def self.save_table(type, args, table)
    # Collects Saved Tables
    tables = self.load_tables
    # Creates Hash of Type (If non present)
    tables[type] = {} unless tables.has_key?(type)
    # Saves Table Data
    tables[type][args] = curve
    # Resaves Tables to File
    save_data(tables, 'Data/Curve Generator.rxdata')   
  end
end

Expand to see the code.

module Curve_Generator
  #-------------------------------------------------------------------------
  # * Save Table
  #-------------------------------------------------------------------------
  def self.save_table(type, args, table)
    # Collects Saved Tables
    tables = self.load_tables
    # Creates Hash of Type (If non present)
    tables[type] = {} unless tables.has_key?(type)
    # Saves Table Data
    tables[type][args] = table
    # Resaves Tables to File
    save_data(tables, 'Data/Curve Generator.rxdata')   
  end
end

Expand to see the code.

#==============================================================================
# ** Kernel    
#==============================================================================

module Kernel
  #-------------------------------------------------------------------------
  # * Name      : Class Defined?
  #   Info      : Check if a specific class has been defined
  #   Author    : David Garamond <lists@zara.6.isreserved.com>
  #   Call Info : One Argument
  #               Class name : String representing the class name
  #-------------------------------------------------------------------------
  def class_defined?(classname)
    m = Class
    classname.split("::").each { |c|
      m.constants.include?(c) or return false
      m = m.const_get c
    }
    return true
  end
end

Expand to see the code.

#===============================================================================
# ** Window_Base
#-------------------------------------------------------------------------------
# * Additional Methods
#   o move_to()
#   o x_move_to()
#   o y_move_to()
#   o fade_opacity()
#   o upgrade_color
#   o downgrade_color
#===============================================================================
class Window_Base < Window
  #-----------------------------------------------------------------------------
  # * Move To (X, Y, Speed, Opacity)
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Moves this window to designated X and Y Coordinates.
  # o Call Info   : x coordinate, y coordinate
  # o Optional    : speed (1..100), opacity (0...255)
  #-----------------------------------------------------------------------------
  def move_to(new_x, new_y, speed = 10, opacity = nil)
    unless self.x == new_x
      self.x -= ((self.x - new_x + 9) / speed).abs if self.x > new_x
      self.x += ((self.x - new_x + 0) / speed).abs if self.x < new_x
    end
    unless self.y == new_y
      self.y -= ((self.y - new_y + 9) / speed).abs if self.y > new_y
      self.y += ((self.y - new_y + 0) / speed).abs if self.y < new_y
    end
    fade_opacity(opacity, speed) unless opacity.nil?
  end
  #-----------------------------------------------------------------------------
  # * X Move To (Destination, Speed, Opacity)
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Moves this window to designated X Coordinate.
  # o Call Info   : x coordinate
  # o Optional    : speed (1..100), opacity (0...255)
  #-----------------------------------------------------------------------------
  def x_move_to(n = 0, speed = 10, opacity = nil)
    unless self.x == n
      self.x -= ((self.x - n + 9) / speed).abs if self.x > n
      self.x += ((self.x - n + 0) / speed).abs if self.x < n
    end
    fade_opacity(opacity, speed) unless opacity.nil?
  end
  #-----------------------------------------------------------------------------
  # * Y Move To (Destination, Speed, Opacity)
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Moves this window to designated X Coordinate.
  # o Call Info   : x coordinate
  # o Optional    : speed (1..100), opacity (0...255)
  #-----------------------------------------------------------------------------
  def y_move_to(n = 0, speed = 10, opacity = nil)
    unless self.y == n
      self.y -= ((self.y - n + 9) / speed).abs if self.y > n
      self.y += ((self.y - n + 0) / speed).abs if self.y < n
    end
    fade_opacity(opacity, speed) unless opacity.nil?
  end
  #-----------------------------------------------------------------------------
  # * Fade Opacity
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Fades this windows opacity in a certain ammount of frames.
  # o Optional    : n (Integer), speed (Integer)
  #-----------------------------------------------------------------------------
  def fade_opacity(n = nil, speed = 10)
    unless self.opacity == n or n.nil?
      self.opacity -= ((self.opacity - n) / speed).abs if self.opacity > n
      self.opacity += ((self.opacity - n) / speed).abs if self.opacity < n
    end
  end
  #-----------------------------------------------------------------------------
  # * Get Upgrade Text Color
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Common CMS method, defines equipment "upgrade color"
  #-----------------------------------------------------------------------------
  def upgrade_color
    return Color.new(0, 255, 0, 255)
  end
  #-----------------------------------------------------------------------------
  # * Get Downgrade Text Color
  #-----------------------------------------------------------------------------
  # o Written by  : Kain Nobel
  # o Description : Common CMS method, defines equipment "downgrade color"
  #-----------------------------------------------------------------------------
  def downgrade_color
    return Color.new(255, 0, 0, 255)
  end
end

Expand to see the code.

#===============================================================================
# ** Window_Command
#-------------------------------------------------------------------------------
#   This window deals with general command choices. This class's initialize
# method has been replaced to make command windows scrollable and default size
# to be set to a specified set of showable commands.
#===============================================================================
class Window_Command < Window_Selectable
  #-----------------------------------------------------------------------------
  # * Object Initialization
  #     width    : window width
  #     commands : command text string array
  #     size     : how many commands to be shown at a time (optional)
  #-----------------------------------------------------------------------------
  def initialize(width, commands, size = 1)
    # If Size isn't equal to 1, then use specified size to determine Command
    # Height, else return the commands size X 32
    height = size != 1 ? 32 + size * 32 : 32 + commands.size * 32
    # Compute window height from command quantity
    super(0, 0, width, height)
    @item_max = commands.size
    @commands = commands
    self.contents = Bitmap.new(width - 32, @item_max * 32)
    refresh
    self.index = 0
  end
end

Expand to see the code.