Ruby Quellcode

#==============================================================================
# BITMASK
#------------------------------------------------------------------------------
#  This class stores boolean information (true/false) as Integer bits, in
# order to save memory.
#==============================================================================
 
class Bitmask
  attr_reader :size
 
  def initialize(size = 1)
    @data = [0]
    resize(size)
  end
 
  def [](i)
    if i >= @size
      raise RangeError, "Bit ##{i} not defined (max = #{@size - 1}) in Bitmask#[]"
    end
    return @data[i >> 5][i % 32] == 1
  end
 
  def []=(i, b)
    case b
    when TrueClass, FalseClass
      if self[i] == b
        return nil
      else
        @data[i >> 5] ^= 2 ** (i % 32)
        return b
      end
    else
      raise TypeError, "TrueClass or FalseClass expected as parameters in Bitmask#[]="
    end
  end
 
  def &(other)
    bitmask = Bitmask.new(@size)
    for i in 0...@size
      bitmask[i] = self[i] & other[i]
    end
    return bitmask
  end
 
  def |(other)
    bitmask = Bitmask.new(@size)
    for i in 0...@size
      bitmask[i] = self[i] | other[i]
    end
    return bitmask
  end
 
  def each
    for i in 0...@size
      yield i if self[i]
    end
  end
 
	def each_false
    for i in 0...@size
      unless self[i]
        yield i
      end
    end
  end
 
  def resize(size)
    while (size >> 5) >= @data.size
      @data << 0
    end
    @size = size
  end
 
  def to_s
    str = String.new
    for i in 0...@size
      if i & 7 == 0
        str << " "
      end
      str << @data[i >> 5][i & 31].to_s
    end
    return str
  end
 
  def ==(other)
    case other
    when Bitmask
      #return true if @data == other.data
      return false unless @size == other.size
      for i in 0...@size
        return false unless self[i] == other[i]
      end
      return true
    end
    return false
  end
 
  alias :inspect :to_s
end
# ==============================================================================
# DIALOG BOXES
# ------------------------------------------------------------------------------
# Makes dialog boxes to give warning messages and confirm choices.
# ==============================================================================
 
module RPG
  def self.warn(str)
    $game_system.se_play($data_system.decision_se)
    Graphics.freeze
    message = []
    str.break_into_lines(65) do |s| message << s end
    height = 32 * (message.size + 2)
    window = Window_Base.new(32, (480 - height) / 2, 576, height)
    window.contents = Bitmap.new(window.width - 32, window.height - 32)
    for i in 0...message.size
      window.contents.draw_text(0, i * 32, window.width - 32, 32, message[i], 1)
    end
    window.contents.draw_text(0, window.contents.height - 32, 544, 32, "OK", 1)
    window.cursor_rect.set(208, window.contents.height - 32, 128, 32)
    window.active = true
    window.z = 5000
    Graphics.transition
    loop do
      Input.update
      Graphics.update
      window.update
      if Input.trigger?(Input::C) or Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        break
      end
    end
    Graphics.freeze
    window.dispose
    Graphics.transition
    return
  end
 
  def self.confirm(str)
    $game_system.se_play($data_system.buzzer_se)
    Graphics.freeze
    message = []
    str.break_into_lines(65) do |s| message << s end
    height = 32 * (message.size + 2)
    window = Window_Base.new(32, (480 - height) / 2, 576, height)
    window.contents = Bitmap.new(window.width - 32, window.height - 32)
    for i in 0...message.size
      window.contents.draw_text(0, i * 32, window.width - 32, 32, message[i], 1)
    end
    window.contents.draw_text(0, window.contents.height - 32, 272, 32, "OK", 1)
    window.contents.draw_text(272, window.contents.height - 32, 272, 32, "Cancel", 1)
    window.cursor_rect.set(72, window.contents.height - 32, 128, 32)
    window.active = true
    window.z = 5000
    Graphics.transition
    index = 0
    result = nil
    while result.nil?
      Input.update
      Graphics.update
      window.update
      if Input.repeat?(Input::LEFT) or Input.repeat?(Input::RIGHT)
        $game_system.se_play($data_system.cursor_se)
        index += 1
        index %= 2
        window.cursor_rect.set(72 + 272 * index, window.contents.height - 32, 128, 32)
      end
      if Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        result = index == 0
      end
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        result = false
      end
    end
    Graphics.freeze
    window.dispose
    Graphics.transition
    return result
  end
end
#==============================================================================
# FUNCTIONS
#------------------------------------------------------------------------------
#  These classes allow to compute a variable from another using a particular
# mathematical formula. Typically used to simulate movements (compute x/y from
# a time factor)
#==============================================================================
 
#==============================================================================
# ** Function_Affine
#------------------------------------------------------------------------------
#  This class handles constant functions (type y = a)
#==============================================================================
class Function_Constant
	attr_reader	:a
 
	#-----------------------------------------------------------------------------
	# * Initialize parameters
	#-----------------------------------------------------------------------------
	def initialize(a)
		@a = a
	end
 
	#-----------------------------------------------------------------------------
	# * Compute image
	#-----------------------------------------------------------------------------
	def [](x)
		return @a
	end
 
	#-----------------------------------------------------------------------------
	# * Check for equality
	#-----------------------------------------------------------------------------
	def ==(function)
		if not function.is_a?(Function_Constant)
			return false
		end
		if function.a == @a
			return true
		end
		return false
	end
end
 
#==============================================================================
# ** Function_Affine
#------------------------------------------------------------------------------
#  This class handles 1st degree polynomial functions (type y = ax + b)
#==============================================================================
class Function_Affine
	attr_reader	:a
	attr_reader	:b
 
	#-----------------------------------------------------------------------------
	# * Initialize parameters
	#-----------------------------------------------------------------------------
	def initialize(a, b)
		@a, @b = a, b
	end
 
	#-----------------------------------------------------------------------------
	# * Compute image
	#-----------------------------------------------------------------------------
	def [](x)
		return @a * x + @b
	end
 
	#-----------------------------------------------------------------------------
	# * Display function
	#-----------------------------------------------------------------------------
	def to_s
		s = "f(x) = #{@a}x"
		s += " + #{@b}" unless @b == 0
		return s
	end
 
	#-----------------------------------------------------------------------------
	# * Check for equality
	#-----------------------------------------------------------------------------
	def ==(function)
		# Return false if other function is not affine
		if not function.is_a?(Function_Affine)
			return false
		end
		# Return true if all parameters are equal
		if @a == function.a and @b == function.b
			return true
		end
		# In any other cases, return false
		return false
	end
 
	#-----------------------------------------------------------------------------
	# * Compute intersection point with another affine function
	#-----------------------------------------------------------------------------
	def inter(function)
		# Return nil if other function is not affine
		if not function.is_a?(Function_Affine)
			return nil
		end
		return (function.b - @b).to_f / (@a - function.a)
	end
 
	#-----------------------------------------------------------------------------
	# * Compute solution
	#-----------------------------------------------------------------------------
	def solve(y = 0)
		return (y - @b).to_f / @a
	end
 
	#-----------------------------------------------------------------------------
	# * Compute derivative
	#-----------------------------------------------------------------------------
	def derive
		# Return a new Function_Constant function
		return Function_Constant.new(@a)
	end
end
 
#==============================================================================
# ** Function_Trinome
#------------------------------------------------------------------------------
#  This class handles 2nd degree polynomial functions (type y = ax² + bx + c)
#==============================================================================
class Function_Trinome
	attr_reader	:a
	attr_reader	:b
	attr_reader	:c
 
	#-----------------------------------------------------------------------------
	# * Initialize parameters
	#-----------------------------------------------------------------------------
	def initialize(a, b, c)
		@a, @b, @c = a, b, c
	end
 
	#-----------------------------------------------------------------------------
	# * Compute image
	#-----------------------------------------------------------------------------
	def [](x)
		return @a * x ** 2 + @b * x + @c
	end
 
	#-----------------------------------------------------------------------------
	# * Display function
	#-----------------------------------------------------------------------------
	def to_s
		s = "f(x) = #{@a}x^2"
		s += " + #{@b}x" unless @b == 0
		s += " + #{@c}" unless @c == 0
		return s
	end
 
	#-----------------------------------------------------------------------------
	# * Check for equality
	#-----------------------------------------------------------------------------
	def ==(function)
		# Return false if other function is not a trinome
		if not function.is_a?(Function_Trinome)
			return false
		end
		# Return true if all parameters are equal
		if @a == function.a and @b == function.b and @c == function.c
			return true
		end
		# Return false in any other cases
		return false
	end
 
	#-----------------------------------------------------------------------------
	# * Comput delta
	#-----------------------------------------------------------------------------
	def delta
		return @b ** 2 - 4 * @a * @c
	end
 
	#-----------------------------------------------------------------------------
	# * Compute solutions
	#-----------------------------------------------------------------------------
	def solve(y = 0)
		if y != 0
			return Function_Trinome.new(@a, @b, @c - y).solve
		end
		# Compute delta
		d = delta
		# If positive delta, return two solutions
		if d > 0
			x1 = (-@b - Math::sqrt(d)).to_f / (2 * @a)
			x2 = (-@b + Math::sqrt(d)).to_f / (2 * @a)
			return x1, x2
		# If null delta, return one solution
		elsif d == 0
			x = -@b.to_f / (2 * @a)
			return x
		end
		# If negative delta, return nil
		return nil
	end
 
	#-----------------------------------------------------------------------------
	# * Compute derivative
	#-----------------------------------------------------------------------------
	def derive
		# Return a new affine function
		return Function_Affine.new(2 * @a, @b)
	end
end
 
#==============================================================================
# ** Function_Polynome
#------------------------------------------------------------------------------
#  This class handles polynomial functions of any arbitrary degree
#==============================================================================
class Function_Polynome
	attr_reader	:coeffs
 
	class << self
    #---------------------------------------------------------------------------
    # * Return an object of a more specific Function class if appropriate
    #---------------------------------------------------------------------------
		alias old_new new
		def new(*coeffs)
			while coeffs.last == 0
				coeffs.pop
			end
			case coeffs.size
			when 0
				return Function_Constant.new(0)
			when 1
				return Function_Constant.new(coeffs[0])
			when 2
				return Function_Affine.new(coeffs[1], coeffs[0])
			when 3
				return Function_Trinome.new(coeffs[2], coeffs[1], coeffs[0])
			end
			return old_new(*coeffs)
		end
	end
 
	#-----------------------------------------------------------------------------
	# * Initialize parameters
	#-----------------------------------------------------------------------------
	def initialize(*coeffs)
		coeffs.flatten! if coeffs[0].is_a?(Array)
		while coeffs.last == 0
			coeffs.pop
		end
		@coeffs = coeffs
	end
 
	#-----------------------------------------------------------------------------
	# * Compute image
	#-----------------------------------------------------------------------------
	def [](x)
		i = 0
		self.each { |n, coeff| i += coeff * x ** n }
		return i
	end
 
	#-----------------------------------------------------------------------------
	# * Display function
	#-----------------------------------------------------------------------------
	def to_s
		s = "f(x) = "
		a = []
		self.each { |n, coeff|
			next if coeff == 0
			a.push(case n
				when 0
					coeff.to_s
				when 1
					"#{coeff}x"
				else
					"#{coeff}x^#{n}"
				end
			)
		}
		s += a.join(" + ")
		return s
	end
 
	def degree
		return @coeffs.size - 1
	end
 
	def each
		for i in 0...@coeffs.size
			yield i, @coeffs[i]
		end
	end
 
  def derive
    coeffs = []
    for i in 1..@coeffs.size
      coeffs.push(i * @coeffs[i])
    end
    return Function_Polynome.new(*coeffs)
  end
end
 
class Function_Composite
  def initialize(data)
    @data = data
  end
 
  def [](x)
    @data.each do |range, function|
      if range.include?(x)
        return function[x]
      end
    end
    return nil
  end
end
# ==============================================================================
# RUBY EXPANSION
# ------------------------------------------------------------------------------
# Adds new functions to existing Ruby classes. Each new feature is commented
# individually.
# ==============================================================================
 
class Object
	# Make all objects respond to :display for compatibility purposes
  alias :display :inspect
end
 
class Array
	# Returns an item selected at random
  def sample
    return self[rand(self.size)]
  end
 
	# Return a copy with items shuffled
	def shuffle
		src = self.clone
		ary = Array.new()
		until src.empty?
			ary << src.delete(src.sample)
		end
		return ary
	end
 
	# Shuffle items
	def shuffle!
		self.replace(self.shuffle)
	end
end
 
class Dir
  # Returns all files matching given extensions in specified directory as an array
  #  - directory: directory to be searched
  #  - filters: strings representing extensions to be kept
  def self.files(directory = self.pwd, *filters)
    ary = []
    for filename in self.entries(directory)
      next if File.directory?(filename) or filename == "." or filename == ".."
      if filters.empty? or filters.include?(File.extname(filename))
        ary << filename
      end
    end
    return ary
  end
 
  # Returns all subdirectories in specified directory as an array
  def self.subdirectories(directory = self.pwd)
    ary = []
    for filename in self.entries(directory)
      if File.directory?(filename)
        ary << filename
      end
    end
    return ary
  end
end
 
class File
  # Assess whether a filename is a directory name or not
  def self.directory?(filename)
    return false if filename == "."
    return true if self.extname(filename) == ""
    return false
  end
end
 
class Integer
	# Computes self factorial
  def factorial
    f = 1
    for i in 1..self
      f *= i
    end
    return f
  end
 
	# Compute number of combinations from k in self
	#  - k: a positive integer less than or equal to self
  def combin(k)
    return self.factorial / (k.factorial * (n - k).factorial)
  end
end
 
class String
	# Breaks string into several lines
	#  - amount: max number of characters per line
  def break_into_lines(amount)
    if self.size <= amount
      yield self
    else
      i = 0
      until i >= self.size
        n = self[i, amount].reverse.index(" ")
        n = amount - (n.nil? ? 0 : n)
        yield self[i, n]
        i += n
      end
    end
  end
 
	# Make string into a symbol name
  def symbolize
    return :empty if self.empty?
    return self.downcase.gsub(" ", "_").to_sym
  end
end
 
class Symbol
	# Make symbol into a string ready fot display
  def display
    str = ""
    name = self.to_s
    name.split("_").each { |s| str += s.capitalize + " " }
    str = str.rstrip
    return str
  end
 
	# Comparison functions, included for compatiblity purposes
  def ===(other)
    return (self <=> other) == 0
  end
 
  def >(other)
    case other
    when Numeric
      return nil
    end
    return (self <=> other) == 1
  end
 
  def <(other)
    case other
    when Numeric
      return nil
    end
    return (self <=> other) == -1
  end
 
  def <=>(other)
    return self.to_s <=> other.to_s
  end
end
# ==============================================================================
# VARIABLES & SWITCHES COMMANDS
# ------------------------------------------------------------------------------
# This allows to bind commands to changes in game variables by events.
# ------------------------------------------------------------------------------
# EXAMPLE: by entering the following, the first actor's HP will automatically
# change to the content of game variable #0001 each time the variable is
# changed via an event.
#   $variables_command[1] = Proc.new { |v| $game_actors[1].hp = v }
# ==============================================================================
 
$switches_command = {}
$variables_command = {}
class Interpreter
  alias mp_common_command_121 command_121
  def command_121
    mp_common_command_121
    for i in @parameters[0]..@parameters[1]
			unless $switches_command[i].nil?
				$variables_command[i].call($game_switches[i])
			end
    end
  end
 
  alias mp_common_command_122 command_122
  def command_122
    mp_common_command_122
    for i in @parameters[0]..@parameters[1]
			unless $switches_command[i].nil?
				$variables_command[i].call($game_variables[i])
			end
    end
  end
end