Ômegazion Roguelike Battle System (ORBS)

ORBS Custumization [ Selecionar ] [ - ]

#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#                <<-- Omegazion's Roguelike Battle System -->>                 #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#   Author  : Omegazion (Julian Villaruz)                                      #
#   Version : 1.06                                                             #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#                          Part2 : Customization                               #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#

#==============================================================================
# ** Basic Settings
#==============================================================================
module ORBS

#------------------------------------------------------------------------------
# * Controls
#------------------------------------------------------------------------------
  ATTACK_KEY = "X"
  FACE_FIRST_KEY = "Y"
  NO_ACTION_KEY = "L"
#------------------------------------------------------------------------------
# * ORBS Basic Configuration
#------------------------------------------------------------------------------
  HEAL_ON_LEVEL_UP = true
  
  ORBS_ENABLED_MODE = 0
  
  EXP_TO_KILLER = 200
  
  SE_WHEN_UNABLE_TO_CAST = ["Buzzer1", 100, 80]
  
  ENEMY_HUE_DEPENDS_ON_DATABASE = true
  
  EIGHT_DIRECTION = true
  
  PARTY_FORMATION = 1
#------------------------------------------------------------------------------
# * ORBS Vocabulary
#------------------------------------------------------------------------------
  HOTKEY_SET_MESSAGE = "Skill set to key %d"
  
  MISS_TEXT = "Miss"
  EVADE_TEXT = "Evade"
  ZERODAMAGE_TEXT = "Guard"
  EXP_TEXT = "%dexp"
  GOLD_TEXT = "%dgold"
  LEVEL_UP_TEXT = "Level Up!"
#------------------------------------------------------------------------------
# * ORBS Graphics
#------------------------------------------------------------------------------
  HOTKEY_HUD_GRAPHIC = "HotkeyHUD.png"
  HOTKEY_POS = [224, 70]                # <- x, y position in the screen
  NUMBER_OF_HOTKEYS = 3                # 2 - 9
  HOTKEY_ICON_START_POS = [228, 74]       # <- Starting positions of icons
  HOTKEY_DISTANCE_X = 32
  HOTKEY_DISTANCE_Y = 0
  
  MISC_TEXT_FONT = ["Verdana", "Arial", "Courier New"]
  
  MISC_TEXT_SIZE = 18
  
  DMG_GRAPHIC_MOVE_MODE = 2
  
  LEVEL_UP_ANIM = 84 # 0 for none
  LEVEL_UP_ANIM_SIZE = 20

  REVIVE_FROM_KO_ANIM = 83
  REVIVE_FROM_KO_ANIM_SIZE = 20
  
#==============================================================================
# * Singe Action Definitions
#==============================================================================
  ACTION = {

# < Put new action definitions below here >

"SINGLE_EFFECT" => ["action_effect", 1, 1],
"USER_AREA_EFFECT" => ["action_effect", 0, 3],
"PROJECTILE_TILE_EFFECT" => ["action_effect", 2, 1],
"PROJECTILE_AREA_EFFECT" => ["action_effect", 2, 2],
"WHOLE_AREA_EFFECT" => ["action_effect", 0, 9999],
"MOVE_TILE_FORWARD" => ["target_set", 1 , 0, 0, 1],
"MOVE_TILE_LEFT"    => ["target_set", 1,  0, 1, 0],
"MOVE_TILE_RIGHT"   => ["target_set", 1,  0, -1, 0],
"MOVE_TILE_BACKWARD" => ["target_set", 1 , 0, 0, -1],
"HIT_ALLIES_ON" => ["option_set", "hit_allies", true],
"HIT_ENEMIES_OFF" => ["option_set", "hit_allies", false],
"DAMAGE_MOVE_RANDOM" => ["option_set", "damage_move_mode", 3],
"CHARGE_FORWARD"   => ["move_sprite", 0, 0, 0, 25,  5],
"STEP_BACK"        => ["move_sprite", 0, 0, 0, -16, 4],
"JUMP_UP"          => ["move_sprite", 0, 1, 0, -40, 5],
"BACK_TO_POSITION" => ["move_sprite", 0, 1, 0, 0,  5],
"POSITION_RESET"   => ["move_sprite", 0, 1, 0, 0, 1],
"FIXED_ANIMATION" => ["animation",    1 , 0  , 30, false,       true,     false],
"FIXED_ANIMATION_SELF" => ["animation", 0, 0, 30, false, true, false],
"NORMAL_ANIMATION" => ["animation", 1, 0, 30, false, true, true],
"PROJECTILE_ANIMATION" => ["animation",    2 ,    0  , 30, false, true,   false],
"BOW_PULL" => ["animation", 0, 88, 100, false, true, true],
"CAST_ANIMATION" => ["animation", 0, 43, 30, false, true, false],
"CAST_ANIMATION2" => ["animation", 0, 44, 40, false, true, false], 
"FINAL_ARROW_ANIM" => ["animation", 2, 16, 40, false, true, false],
"FINAL_SWORD_ANIM" => ["animation", 1, 10, 40, false, true, false],
"FIRE" => ["projectile_fire", 0, 5,  "!Flame",  4,  true, 0, 8, 2, true],
"FIRE_ARROW" => ["projectile_fire", 0, 4, "$Arrow", 0, true, 0, 8, 2, true],
"FIRE_SOUND" => ["sound", 0, "Fire2", 100, 80],

  }
#==============================================================================
# * Action Sequences Definitions
#==============================================================================
ACTION_SEQUENCES = {
  
# < Put new action sequences here >

"ATTACK" => ["CHARGE_FORWARD", "3" , "FIXED_ANIMATION", "5", "SINGLE_EFFECT" ,
                "4", "BACK_TO_POSITION", "25"],
                
"DOUBLE-ATTACK" => ["CHARGE_FORWARD", "3", "FIXED_ANIMATION", "5", "SINGLE_EFFECT", 
                  "16", "SINGLE_EFFECT", "10", "BACK_TO_POSITION", "25"],
                  
"FIRE_BALL"   => ["FIRE_SOUND", "FIRE", "PROJECTILE_ANIMATION", "4",
                  "PROJECTILE_AREA_EFFECT", "25"],
                  
"DOUBLE_SWIPE" => ["CAST_ANIMATION", "90", "NORMAL_ANIMATION", "MOVE_TILE_RIGHT", 
                  "4", "SINGLE_EFFECT", "MOVE_TILE_LEFT", "4", "SINGLE_EFFECT", 
                  "MOVE_TILE_LEFT", "4", "SINGLE_EFFECT", "MOVE_TILE_RIGHT", "36",
                  "SINGLE_EFFECT", "MOVE_TILE_FORWARD", "4", "SINGLE_EFFECT", 
                  "MOVE_TILE_FORWARD", "4", "SINGLE_EFFECT", "35"],
                  
"OMEGA" => ["CAST_ANIMATION", "88", "CHARGE_FORWARD", "5", "FIXED_ANIMATION", "8",
            "SINGLE_EFFECT", "16", "SINGLE_EFFECT", "20", "SINGLE_EFFECT", "16", 
            "SINGLE_EFFECT", "24", "BACK_TO_POSITION", "10", "CAST_ANIMATION2",
            "30", "CHARGE_FORWARD", "2", "FINAL_SWORD_ANIM", "8", "SINGLE_EFFECT",
            "30", "BACK_TO_POSITION", "12"],
            
"ARROW_FIRE" => ["STEP_BACK", "4", "BOW_PULL", "24", "FIRE_ARROW", 
                "PROJECTILE_ANIMATION", "PROJECTILE_TILE_EFFECT", "12", 
                "BACK_TO_POSITION", "25"],
                
"EARTH_SLAM" => ["CAST_ANIMATION", "88", "JUMP_UP", "10", "BACK_TO_POSITION",
                  "5", "FIXED_ANIMATION_SELF", "4", "USER_AREA_EFFECT", "4", 
                  "USER_AREA_EFFECT", "8", "USER_AREA_EFFECT", "30"],
                  
"TRIPLE_STRAFE" => ["CAST_ANIMATION", "88", "STEP_BACK", "4", "BOW_PULL", "24",
                    "FIRE_ARROW", "PROJECTILE_ANIMATION", "16", "PROJECTILE_TILE_EFFECT",
                    "16", "PROJECTILE_TILE_EFFECT", "12", "PROJECTILE_TILE_EFFECT",
                    "BACK_TO_POSITION", "30"],
                    
"LUCKY_SEVEN"  => ["CAST_ANIMATION", "88", "STEP_BACK", "4", "BOW_PULL", "24", 
                    "FIRE_ARROW", "PROJECTILE_ANIMATION", "8", "PROJECTILE_TILE_EFFECT",
                    "8", "PROJECTILE_TILE_EFFECT", "12", "PROJECTILE_TILE_EFFECT",
                    "12", "PROJECTILE_TILE_EFFECT", "12", "PROJECTILE_TILE_EFFECT",
                    "12", "PROJECTILE_TILE_EFFECT", "CAST_ANIMATION2", "30",
                    "BOW_PULL", "24", "FIRE_ARROW", "FINAL_ARROW_ANIM", "12",
                    "PROJECTILE_TILE_EFFECT", "36", "BACK_TO_POSITION", "25"],
                    
"HOLY_LIGHT" => ["CAST_ANIMATION", "88", "FIXED_ANIMATION_SELF", "40", 
                  "WHOLE_AREA_EFFECT", "30"],
                  
"THUNDER_SCYTHE" => ["STEP_BACK", "7", "CHARGE_FORWARD", "3", "NORMAL_ANIMATION",
                    "4", "MOVE_TILE_LEFT", "SINGLE_EFFECT", "MOVE_TILE_RIGHT", 
                    "BACK_TO_POSITION", "4", "SINGLE_EFFECT", "MOVE_TILE_RIGHT", 
                    "4", "SINGLE_EFFECT", "20"],
                    
"ULTIMATE_BEATING" => ["DAMAGE_MOVE_RANDOM", "CHARGE_FORWARD", "FIXED_ANIMATION", 
                      "2" ,"SINGLE_EFFECT", "2", "SINGLE_EFFECT", "4", "SINGLE_EFFECT", "4", 
                      "SINGLE_EFFECT", "4", "SINGLE_EFFECT", "4", "SINGLE_EFFECT",
                      "4", "SINGLE_EFFECT", "8", "SINGLE_EFFECT", "8", 
                      "SINGLE_EFFECT", "12", "SINGLE_EFFECT", "8", "SINGLE_EFFECT", 
                      "4", "SINGLE_EFFECT", "8", "SINGLE_EFFECT", "8", 
                      "SINGLE_EFFECT", "8", "SINGLE_EFFECT", "8", "SINGLE_EFFECT",
                      "BACK_TO_POSITION", "8", "SINGLE_EFFECT", "30"],

}
end
module RPG
  
#==============================================================================
# * Weapon Action sequences
#==============================================================================
class Weapon
  def action_sequence
    case @id
    # < Insert weapon sequences here >
    
    when 34 ; return "ARROW_FIRE" 
    when 35 ; return "DOUBLE-ATTACK"
      
    # Default sequence
    else ; return "ATTACK"
    end
  end
end
#==============================================================================
# * Skill Action sequences
#==============================================================================
class Skill
  def action_sequence
    case @id
    # < Insert skill sequences here >
    
    when 86 ; return "DOUBLE_SWIPE"
    when 87 ; return "OMEGA"
    when 88 ; return "HOLY_LIGHT"
    when 89 ; return "EARTH_SLAM"
    when 90 ; return "FIRE_BALL"
    when 91 ; return "TRIPLE_STRAFE"
    when 92 ; return "LUCKY_SEVEN"
      
    # default sequence
    else ; return "ATTACK"
    end
  end
end
end
#==============================================================================
# * Actor Barehand settings
#==============================================================================
class Game_Actor
#------------------------------------------------------------------------------
# Actor Barehand Attack Sequences
#------------------------------------------------------------------------------
  def bare_hand_attack_sequence
    case @actor_id
    # < Insert actor barehand attack sequences here >
    
    when 1 ; return "ATTACK"
    
    # Default Barehand attack sequence
    else ; return "ATTACK"
    end
  end
#------------------------------------------------------------------------------
# Actor Barehand Attack Animation Settings
#------------------------------------------------------------------------------
  def bare_hand_attack_animation
    case @actor_id
    # < Insert bare hand attack animations here >
    
    when 1 ; return 1
      
    # Default barehand attack animation
    else ; return 1
    end
  end
end
#==============================================================================
# * Enemy's Settings
#==============================================================================
class Game_Enemy
#------------------------------------------------------------------------------
# Enemy Normal Attack Sequence
#------------------------------------------------------------------------------
  def normal_attack_sequence
    case @enemy_id
    # < Insert attack sequences here >
    
    when 1 ; return "ATTACK"
    when 4 ; return "THUNDER_SCYTHE"
    when 5 ; return "ULTIMATE_BEATING"
      
    # Default normal attack sequence
    else ; return "ATTACK"
    end
  end
#------------------------------------------------------------------------------
# Enemy Attack Animation Settings
#------------------------------------------------------------------------------
  def atk_animation_id
    case @enemy_id
    # < Insert normal attack animations here >
    
    when 1 ; return 1
    when 4 ; return 90
    when 5 ; return 6
      
    # Default animation id
    else ; return 1
    end
  end
end
module ORBS
#==============================================================================
# * AI Configuration
#==============================================================================
class AI
  #---------------------------------------------------------------------------
  #  Actor's AI
  #---------------------------------------------------------------------------
  def actor_specific_initializations(id)
    case id
    # < Insert new settings for actors below here >
    when 2
      @active_range = 7
      @approach_enemy_range = 2
      @skill_use_rate = 25
    else # Default values below
      @active_range = 4
      @approach_enemy_range = 2
      @skill_use_rate = 25
    end
  end
  #---------------------------------------------------------------------------
  #  Enemy's AI
  #---------------------------------------------------------------------------
  def enemy_specific_initializations(id)
    case id
    # < Insert new settings for enemies below here >
    when 31
      @active_range = 10
      @approach_enemy_range = 0
      @skill_use_rate = 25
      @immobile = true
      @nonhostile = true
    when 4
      @active_range = 10
      @approach_enemy_range = 0
      @skill_use_rate = 100
      @immobile = false
      @nonhostile = false
    else # Default values below
      @active_range = 10
      @approach_enemy_range = 10
      @skill_use_rate = 25
      @immobile = false
      @nonhostile = false
    end
  end
end
end

ORBS Engine Main Script [ Selecionar ] [ - ]

#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#                <<-- Omegazion's Roguelike Battle System -->>                 #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#   Author  : Omegazion (Julian Villaruz)                                      #
#   Version : 1.06                                                             #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#
#                     Part3 : ORBS Engine Main Script                          #
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=#

# Set global hash that logs scripts made by me.
$oz_script = {} if $oz_script.nil? 
$oz_script["ORBS"] = true

#==============================================================================
# ** F12 Stack Overflow Fix
#------------------------------------------------------------------------------
#  Fixes the original reset method, which just restarts the execution from the
# top, thus any alias methods will alias itself again, creating a stack overflow
#==============================================================================
unless $oz_script["F12 Stack Overflow Fix"]

unless $@.nil?               # This variable is set with an array upon reset 
  Thread.new{system("Game")} # Create a new thread
  exit                       # Exit this current thread
end

end

#==============================================================================
# ** Extra Cache Commands
#==============================================================================
unless $oz_script["Extra Cache Commands"]

#==============================================================================
# ** Cache
#------------------------------------------------------------------------------
#  This module loads each of graphics, creates a Bitmap object, and retains it.
# 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 Icon Graphic
  def self.icon(icon_index)
    @icon_cache = {} if @icon_cache.nil?
    if @icon_cache[icon_index].nil? or @icon_cache[icon_index].disposed?
      @icon_cache[icon_index] = Bitmap.new(24, 24)
      bitmap = Cache.system("Iconset")
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      @icon_cache[icon_index].blt(0, 0, bitmap, rect)
    end
    return @icon_cache[icon_index]
  end

  def self.hued_character(filename, hue)
    load_bitmap("Graphics/Characters/", filename, hue)
  end

end

#==============================================================================
# ** Sprite_Icon
#------------------------------------------------------------------------------
#  A sprite for showing icons.
#==============================================================================
class Sprite_Icon < Sprite
  
  # * Object Initialization
  def initialize(icon_index, viewport = nil)
    super(viewport)
    self.bitmap = Cache.icon(icon_index)
  end

end

end

#==============================================================================
# ** Randomizing Methods
#------------------------------------------------------------------------------
#  Methods for Enumerable classes (like Array), for creating randomized entries 
#==============================================================================
unless $oz_script["Randomizing Methods"]
  
$oz_script["Randomizing Methods"] = true

#==============================================================================
# ** Enumerable
#------------------------------------------------------------------------------
#  This module is a mixin which provides collection classes with several 
# traversal and searching methods, and with the ability to sort, via the 
# method each.
#==============================================================================
module Enumerable
  
  # * Returns an array of mixed entries in the collection
  def shuffle
    array = self.entries
    return Array.new(self.size){ array.delete_at(rand(array.size)) }
  end

end

#==============================================================================
# ** Array
#------------------------------------------------------------------------------
#  This class handles Ruby's Array objects, which are ordered, integer-indexed 
# collections of any object.
#==============================================================================
class Array
  
  # * Destructively shuffles the order of the elements in the array.
  def shuffle!
    array = self.shuffle
    result = array == self ? nil : self
    clear()
    self.concat(array)
    return result
  end
  
  # * Iterates through all of the elements of the array randomly
  def random_each
    array = self.shuffle
    for obj in array
      yield obj 
    end
  end
  
  # * Iterates through all of the elements randomly with an index
  def random_each_with_index
    array = self.shuffle
    array.each_with_index do |obj, i|
      yield obj, i
    end
  end
  
end

end

#==============================================================================
# ** Misc. Text Spawner Snippet Script
#------------------------------------------------------------------------------
#  Author  : Omegazion
#------------------------------------------------------------------------------
#  This script allows you to spawn small texts in the map, to signify events
# instead of using messages.
#------------------------------------------------------------------------------

unless $oz_script["Misc Text Spawner"]
  
$oz_script["Misc Text Spawner"] = true

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles system-related data. Also manages vehicles and BGM, etc.
# The instance of this class is referenced by $game_system.
#==============================================================================
class Game_Temp
  
  # * Added Public Instance Variables
  attr_reader :text_spawner_font
  
  # * Alias List
  alias oz_mts_init initialize
  
  # * Object Initialization
  def initialize
    oz_mts_init
    @text_spawner_font = Font.new(Font.default_name, Font.default_size)
  end
  
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  An interpreter for executing event commands. This class is used within the
# Game_Map, Game_Troop, and Game_Event classes.
#==============================================================================
class Game_Interpreter
  
  # * Spawn text command, as explained in the instructions
  def spawn_text(*args)
    $scene.spawn_text_scm(args)
  end

end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs the map screen processing.
#==============================================================================
class Scene_Map
  
  # * Pass control to spriteset map
  def spawn_text_scm(args)
    @spriteset.spawn_text_spm(args)
  end
  
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc. It's used
# within the Scene_Map class.
#==============================================================================
class Spriteset_Map
  
  # * Alias List
  alias oz_mts_init initialize
  alias oz_mts_update update
  alias oz_mts_dispose dispose
  
  # * Object Initialization
  def initialize
    @spawned_text_sprites = []
    oz_mts_init
  end
  
  # * Frame Update
  def update
    oz_mts_update
    for sprite in @spawned_text_sprites.clone
      if sprite.moving?
        sprite.update
      else
        @spawned_text_sprites.delete(sprite)
        sprite.dispose
      end
    end
  end
  
  def dispose
    for sprite in @spawned_text_sprites do sprite.dispose end
    oz_mts_dispose
  end
  
  # * Spawn text
  def spawn_text_spm(args)
    sprite = Sprite_MiscTextSpawn.new(*args)
    sprite.viewport = @viewport2
    @spawned_text_sprites << sprite
  end
  
end

#==============================================================================
# ** Sprite_MiscTextSpawn
#------------------------------------------------------------------------------
#  This sprite is used to display spawned texts
#==============================================================================
class Sprite_MiscTextSpawn < Sprite
  
  # * Object Initialization
  def initialize(mapx, mapy, vertmov, horizmov, fade, dur, text)
    super(nil)
    b = Bitmap.new(32, 32)
    sx = ($game_map.adjust_x(mapx * 256) + 8007) / 8 - 1000
    sy = ($game_map.adjust_y(mapy * 256) + 8007) / 8 - 1000
    if $oz_script["ORBS"] and ORBS.turn_running
      font = ORBS.misc_font
    else
      font = $game_temp.text_spawner_font
    end
    b.font = font
    w, h = b.text_size(text).width, b.text_size(text).height
    self.bitmap = Bitmap.new(w, h)
    self.bitmap.font = font
    self.bitmap.draw_text(0, 0, w, h, text)
    self.x = sx + 16 - w/2
    self.y = sy + 16 - h/2
    @vertmov = vertmov
    @horizmov = horizmov
    @fade = fade.abs
    @dur = dur
    if dur.nil? and @fade == 0
      print "spawn_text command used with nil duration and 0 fade"
      exit
    end
    b.dispose
  end
  
  # * Frame Update
  def update
    super
    self.y += @vertmov
    self.x += @horizmov
    self.opacity -= @fade
    @dur -= 1 unless @dur.nil?
  end
  
  # * Determine if moving
  def moving?
    return (@dur.nil? ? self.opacity > 0 : @dur > 0)
  end
  
  # * Dispose Method
  def dispose
    self.bitmap.dispose
    super
  end
  
end

end # <- End of $oz_script hash log

#==============================================================================
# ** Keyboard Input
#------------------------------------------------------------------------------
#  A script for taking control of the whole keyboard.
#==============================================================================
#  Credits to:
#   shun, for his simple input script
#   MACL Keyboard scripts, for the key constants
#==============================================================================
=begin

Keys

* 0-9 - replace by any number between 0 - 9
* A-Z - replace by any letter

Input::A               = Default RMVX A-Button
Input::B               = Default RMVX B-Button
Input::C               = Default RMVX C-Button
Input::X               = Default RMVX X-Button
Input::Y               = Default RMVX Y-Button
Input::Z               = Default RMVX Z-Button
Input::L               = Default RMVX L-Button
Input::R               = Default RMVX R-Button
Input::Numberpad[0-9]  = Number pad, when Num lock is not on
Input::Numlockpad[0-9] = Number pad, when Num lock is on
Input::Numbers[0-9]    = Numbers on the normal keyboard.
Input::Letters["A-Z"]  = Letters
Input::F1 - F12        = Function keys
Input::MouseLeft      = Left Click
Input::MouseRight     = Right Click
Input::Back            = Backspace key
Input::Tab             = Tab key
Input::Enter           = Enter key 
Input::Shift           = Shift key
Input::Ctrl            = Ctrl key
Input::Alt             = Alt key
Input::Capslock        = Capslock key 
Input::Esc             = Escape key
Input::Space           = Space key
Input::End             = End key
Input::Home            = Home key 
Input::Left            = Left Arrow key
Input::Right           = Right Arrow key
Input::Del             = Delete key
Input::Collon          = : ;
Input::Quote           = " '
Input::Equal           = + =     
Input::Comma           = < ,
Input::Underscore      = _ -     
Input::Dot             = > .
Input::Backslash       = ? /   
Input::Tilde           = ~ `
Input::Lb              = { [     
Input::Rb              = } ]
Input::Forwardslash    = | \\

#==============================================================================
=end
unless $oz_script["Keyboard Input"]

$oz_script["Keyboard Input"] = true

#==============================================================================
# ** Input
#------------------------------------------------------------------------------
#  A module that handles input data from a gamepad or keyboard.
#==============================================================================
module Input
  
  # Values between 1 - 27 are changed to 131 - 157 for compatability with older
  # controls

  # Keys in the Numlockpad when Num Lock is on
  Numlockpad = []             
  Numlockpad[0] = 96
  Numlockpad[1] = 97          
  Numlockpad[2] = 98
  Numlockpad[3] = 99          
  Numlockpad[4] = 100
  Numlockpad[5] = 101         
  Numlockpad[6] = 102
  Numlockpad[7] = 103        
  Numlockpad[8] = 104
  Numlockpad[9] = 105
  
 # Keys in the numpad when Num Lock is off
  Numberpad       = []        
  Numberpad[0]    = 45
  Numberpad[1]    = 35        
  Numberpad[2]    = 40
  Numberpad[3]    = 34        
  Numberpad[4]    = 37
  Numberpad[5]    = 142       
  Numberpad[6]    = 39
  Numberpad[7]    = 36        
  Numberpad[8]    = 38
  Numberpad[9]    = 33
    
  # Numbers not in the numpad
  Numbers      = []           
  Numbers[0]   = 48
  Numbers[1]   = 49
  Numbers[2]   = 50
  Numbers[3]   = 51
  Numbers[4]   = 52
  Numbers[5]   = 53
  Numbers[6]   = 54
  Numbers[7]   = 55
  Numbers[8]   = 56
  Numbers[9]   = 57
  
  # Letters
  Letters         = {}        
  Letters['A']    = 65
  Letters['B']    = 66        
  Letters['C']    = 67
  Letters['D']    = 68        
  Letters['E']    = 69
  Letters['F']    = 70        
  Letters['G']    = 71
  Letters['H']    = 72        
  Letters['I']    = 73
  Letters['J']    = 74        
  Letters['K']    = 75
  Letters['L']    = 76        
  Letters['M']    = 77
  Letters['N']    = 78        
  Letters['O']    = 79
  Letters['P']    = 80        
  Letters['Q']    = 81
  Letters['R']    = 82        
  Letters['S']    = 83
  Letters['T']    = 84        
  Letters['U']    = 85
  Letters['V']    = 86        
  Letters['W']    = 87
  Letters['X']    = 88        
  Letters['Y']    = 89
  Letters['Z']    = 90
  
  # Function keys
  F1        = 112             
  F2        = 113     
  F3        = 114             
  F4        = 115      
  F10       = 121             
  F11       = 122
  F12       = 123
  
  # Other keys
  Back            = 138       
  Tab             = 139
  Enter           = 143       
  Shift           = 146
  Ctrl            = 147       
  Alt             = 148
  Capslock        = 150       
  Esc             = 157
  Space           = 32        
  End             = 35
  Home            = 36        
  Left            = 37
  Right           = 39        
  Del             = 46      
  Collon          = 186       
  Quote           = 222
  Equal           = 187       
  Comma           = 188
  Underscore      = 189       
  Dot             = 190
  Backslash       = 191       
  Tilde           = 192
  Lb              = 219       
  Rb              = 221
  Forwardslash    = 220
  
  # Mouse
  MouseLeft      = 131   
  MouseRight     = 132
  
  State = Win32API.new("user32", "GetAsyncKeyState", ["i"], "i") 
  PressDuration = {} # A hash for pressed keys and their durations

end

class << Input
  
  # * Alias List
  alias oz_key_press press?
  alias oz_key_trigger trigger?
  alias oz_key_repeat repeat?
  alias oz_key_update update
  
end

module Input

  module_function
  
  # * Frame Update
  def update
    oz_key_update
    for key in PressDuration.keys
      (State.call(key).abs & 0x8000 == 0x8000) ? PressDuration[key] += 
        1 : PressDuration.delete(key)
    end
  end
  
  # * Check if a key is being pressed, then register to the hash
  def key_pressed?(key)
    if (State.call(key).abs & 0x8000 == 0x8000)
      PressDuration[key] = 0
      return true
    else
      return false
    end
  end
  
  # * Used to fix the compatability to normal keys
  def comp_fix(numkey)
    numkey -= 130 if numkey.between?(130, 158)
    return numkey
  end
  
  # * Determines whether the button numkey is currently being pressed.
  def press?(numkey)
    return oz_key_press(numkey) if numkey < 30
    realkey = comp_fix(numkey)
    return true unless PressDuration[realkey].nil?
    return key_pressed?(realkey)
  end

  # * Determines whether the button numkey is being pressed again.
  def trigger?(numkey)
    return oz_key_trigger(numkey) if numkey < 30
    realkey = comp_fix(numkey)
    count = PressDuration[realkey]
    return ((count == 0) or (count.nil? ? key_pressed?(realkey) : false))
  end
  
  # * Determines whether the button numkey is being pressed again or held down.
  def repeat?(numkey)
    return oz_key_repeat(numkey) if numkey < 30
    realkey = comp_fix(numkey)
    count = PressDuration[realkey]
    return true if count == 0
    return (count.nil? ? key_pressed?(realkey) : (count >= 23 and 
      (count - 23) % 6 == 0))
  end
  
end

end

#==============================================================================
# ** Coords
#------------------------------------------------------------------------------
#  A class whose instance consists of two variables x, y for easier coordinate
# notation, instead of a 2-element array.
#==============================================================================
unless $oz_script["Coords Class"]

$oz_script["Coords Class"] = true

class Coords
  
  # * Public Instance Variables
  attr_accessor :x
  attr_accessor :y
  
  # * Object Initialization
  def initialize(x = 0, y = 0)
    @x = x
    @y = y
  end
  
  # * Check if equal to other
  def ==(other)
    return (other.x == @x and other.y == @y)
  end
  
  # * Set x and y
  def set(x, y)
    @x = x
    @y = y
  end
  
  # * Check if equal to x and y
  def pos?(x, y)
    return (@x == x and @y == y)
  end
  
  # * Set an objects coordinates with itself
  def set_to(obj)
    obj.x = @x
    obj.y = @y
  end
end

end

$oz_script["ORBS"] = true
$orbs_addons = {}

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc. It's used
# within the Scene_Map class.
#==============================================================================
class Spriteset_Map
  
  # * Alias List
  alias oz_rbs_create_chars create_characters
  alias oz_rbs_init initialize
  alias oz_rbs_update update
  alias oz_rbs_dispose dispose
  
  # * Object Initialization
  def initialize
    @sprite_anim_dummies = []
    @sprite_hotkey_hud = ORBS::Sprite_HotkeyHUD.new
    @sprite_char_huds = []
    @sprite_projectiles = []
    for i in 0..3
      @sprite_char_huds << ORBS::Sprite_CharacterHUD.new(i)
    end
    oz_rbs_init
    for hud in @sprite_char_huds
      hud.viewport = @viewport2
    end
    @sprite_hotkey_hud.viewport = @viewport2
    ORBS.map_spriteset = $scene.is_a?(Scene_Map) ? self : nil
  end
  
  # * Refresh hotkey tones which signify usability of skills.
  def refresh_hotkey_tones
    @sprite_hotkey_hud.refresh_hotkey_tones
  end
  
  # * Refresh the graphics that show the battler's info
  # In the next version, the argument should be a Game_Character
  def refresh_battler_info(battler)
    if battler.is_a?(Game_Enemy)
      return # Might put a hp bar add-on later
    else
      for hud in @sprite_char_huds
        hud.refresh(true) if battler == hud.battler
      end
    end
  end
  
  # * Create a projectile sprite
  def create_projectile(projectile, graphic, graphic_index)
    @sprite_projectiles << ORBS::Sprite_Projectile.new(projectile, graphic, graphic_index, @viewport2)
  end
  
  # * Frame Update - Added dummy sprites animation updating
  def update
    oz_rbs_update
    @sprite_hotkey_hud.update
    for hud in @sprite_char_huds
      hud.update
    end
    for sprite in @sprite_projectiles.clone
      unless sprite.animation?
        @sprite_projectiles.delete(sprite)
        sprite.dispose
      else
        sprite.update
      end
    end
    for sprite in @sprite_anim_dummies.clone
      unless sprite.animation?
        @sprite_anim_dummies.delete(sprite)
        sprite.dispose
      else
        sprite.update
      end
    end
  end

  # * Show an animation at given coordinates, using a dummy sprite
  def show_rbs_anim_at(sx, sy, animation, zoom = 1.00, mirror = false, additional_angle = 0)
    sprite = ORBS::Sprite_AnimDummy.new(@viewport1)
    sprite.x = sx
    sprite.y = sy
    sprite.start_animation(animation, zoom, mirror, additional_angle)
    @sprite_anim_dummies << sprite
  end

  # * Dispose - Added disposal of animation dummies
  def dispose
    for sprite in @sprite_anim_dummies
      sprite.dispose
    end
    for hud in @sprite_char_huds
      hud.dispose
    end
    @sprite_hotkey_hud.dispose
    oz_rbs_dispose
    ORBS.map_spriteset = nil
  end
  
  # * Create characters - Added creation of character sprites of other actors
  def create_characters
    oz_rbs_create_chars
    for member in $game_members
      @character_sprites << (Sprite_Character.new(@viewport1, member))
    end
  end

end

#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
#  Added damage sprites processing.
#==============================================================================
class Sprite_Character
  
  # * Alias List
  alias oz_rbs_sc_update update
  alias oz_rbs_sc_update_bmp update_bitmap
  alias oz_rbs_sc_init initialize
  
  # * Object Initialization - Added damage sprites array initialization
  def initialize(*args)
    @rbs_dmg_sprites = []
    @forward_charge_duration = 0
    @old_hue = 0
    oz_rbs_sc_init(*args)
  end
  
  # * Update Transfer Origin Bitmap - Add hue setting when the graphic changes
  def update_bitmap
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name
      @old_hue = 0
    end
    oz_rbs_sc_update_bmp
  end
  
  # * Frame Update - Added damage sprites updating 
  def update
    oz_rbs_sc_update
    if ORBS::ENEMY_HUE_DEPENDS_ON_DATABASE and @character.is_a?(Game_Event)
      if @old_hue != @character.enemy_hue
        if @character.enemy_hue == 0
          self.bitmap = Cache.character(@character.character_name)
        else
          self.bitmap = Cache.hued_character(@character.character_name,
            @character.enemy_hue)
        end
        @old_hue = @character.enemy_hue
        update_src_rect
      end
    end
    for sprite in @rbs_dmg_sprites.clone
      unless sprite.animating
        @rbs_dmg_sprites.delete(sprite)
        #ORBS.map_spriteset.refresh_battler_info(character.battler)
        sprite.dispose
      else
        sprite.update
      end
    end
    until @character.rbs_damages.empty?
      dmg_data = @character.rbs_damages.shift
      dmg_data << self
      @rbs_dmg_sprites << ORBS::Sprite_Damage.new(*dmg_data)
    end
  end
  
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  An interpreter for executing event commands. This class is used within the
# Game_Map, Game_Troop, and Game_Event classes.
#==============================================================================
class Game_Interpreter
  
  # * Alias List
  alias oz_rbs_gi_chng_hp command_311
  
  # * Change HP
  def command_311
    result = oz_rbs_gi_chng_hp
    if $game_party.members[0].nil? or $game_party.members[0].dead?
      $game_temp.next_scene = "gameover"
    end
    return result
  end
  
end

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs the title screen processing.
#==============================================================================
class Scene_Title
  
  # * Alias List
  alias oz_rbs_create_game_objs create_game_objects
  #alias oz_rbs_st_start start
  
  # * Add ORBS engine start to game objects creation
  def create_game_objects
    ORBS.char_objs = []
    oz_rbs_create_game_objs
    ORBS.start
  end
  
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs the map screen processing.
#==============================================================================
class Scene_Map
  
  # * Alias List
  alias oz_rbs_update update
  alias oz_rbs_call_gameover call_gameover
  alias oz_rbs_sm_upd_sc_chng update_scene_change

  # * Execute Screen Switch - Return if turn is running
  def update_scene_change
    if ORBS.turn_running and (not $game_temp.next_scene == "gameover")
      return $game_temp.next_scene = nil 
    end
    oz_rbs_sm_upd_sc_chng
  end
  
  # * Call gameover - refresh the data first before gameover
  def call_gameover
    for member in [$game_player] + $game_members
      next if member.battler.nil?
      @spriteset.refresh_battler_info(member.battler)
    end
    oz_rbs_call_gameover
  end
  
  # * Frame Update
  def update
    for battler in ORBS.recently_revived.clone
      ORBS.recently_revived.delete(battler)
      next unless ORBS.enabled?
      member = nil
      for mem in $game_members
        member = mem if mem.battler.id == battler.id
      end
      next if member.nil?
      dirs = [2, 4, 6, 8].shuffle
      has_moved = false
      for char in [$game_player] + $game_members
        next if char == member
        next unless (char == $game_player or char.exist?)
        for i in dirs
          coords = char.coords_at_dir(i)
          if member.passable?(coords.x, coords.y)
            has_moved = true
            break rbs_member_revive(member, coords.x, coords.y, char)
          end
        end
        break if has_moved
      end
      unless has_moved
        for n in 1...($game_map.width + $game_map.height)
          for m in 0..n
            for xy in [[m, n - m], [-m, n - m], [m, m - n], [-m, n - m]]
              coord = [$game_player.x + xy[0], $game_player.y + xy[1]]
              if member.passable?(*coord)
                has_moved = true
                break rbs_member_revive(member, coord[0], coord[1])
              end
            end
          end
          break Graphics.frame_reset if has_moved
        end
      end
    end
    oz_rbs_update
    if ORBS.enabled?
      call_gameover if $game_player.battler.nil?
      for character in $game_members
        character.update
      end
    end
  end
  
  # Revive a member at a certain position, and show an revive animation
  def rbs_member_revive(member, x, y, turn_towards = $game_player)
    animation = $data_animations[ORBS::REVIVE_FROM_KO_ANIM]
    member.moveto(x, y)
    member.turn_towards(turn_towards)
    member.update
    unless animation.nil?
      sx = ($game_map.adjust_x(x * 256) + 8007) / 8 - 1000
      sy = ($game_map.adjust_y(y * 256) + 8007) / 8 - 1000
      @spriteset.show_rbs_anim_at(sx, sy, animation, 
        ORBS::REVIVE_FROM_KO_ANIM_SIZE.to_f / 100.0)
      ((animation.frame_max - 1)*( Graphics.frame_rate / 15)).times do
        update_basic
      end
    end
  end  
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This class performs the save and load screen processing.
#==============================================================================
class Scene_File
  
  # * Alias List
  alias oz_rbs_wrt_sav_dat write_save_data
  alias oz_rbs_read_sav_dat read_save_data
  def write_save_data(file)
    oz_rbs_wrt_sav_dat(file)
    Marshal.dump($game_members, file)
  end
  
  def read_save_data(file)
    oz_rbs_read_sav_dat(file)
    $game_members = Marshal.load(file)
  end
end

#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
#  This class performs the skill screen processing.
#==============================================================================
class Scene_Skill
  
  # * Alias List
  alias oz_rbs_hk_update_skill_select update_skill_selection
  
  # * Update skill selection - add hotkey assignment
  def update_skill_selection
    if @actor_index == 0 
      for i in 1..(ORBS::NUMBER_OF_HOTKEYS)
        if Input.trigger?(Input::Numbers[i]) and (not @skill_window.skill.nil?) and
          (@skill_window.skill.occasion != 3)
          Sound.play_decision
          ORBS.hotkey_objects[i - 1] = @skill_window.skill
          @help_window.set_text(sprintf(ORBS::HOTKEY_SET_MESSAGE, i))
          30.times do
            Graphics.update
            Input.update
          end
          return
        end
      end
    end
    oz_rbs_hk_update_skill_select
  end
  
end

#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
#  This class deals with characters. It's used as a superclass of the
# Game_Player and Game_Event classes.
#==============================================================================
class Game_Character

  # * Added Public Instance Variables
  attr_reader :rbs_ai
  attr_reader :rbs_damages
  attr_accessor :action_x_plus
  attr_accessor :action_y_plus
  attr_reader :rbs_char_obj
  attr_reader :battling
  
  # * Alias List
  alias oz_rbs_gc_init initialize
  alias oz_rbs_gc_update update
  alias oz_rbs_gc_sc_x screen_x
  alias oz_rbs_gc_sc_y screen_y
  alias oz_rbs_gc_set_dir set_direction
  alias oz_rbs_gc_collid_with_chars collide_with_characters?
  
  def set_direction(dir)
    if dir % 2 == 1
      oz_rbs_gc_set_dir((dir * 2) % 10)
    else
      oz_rbs_gc_set_dir(dir)
    end
  end
  
  # * Object Initialization - Added damages array
  def initialize
    @battling = false
    oz_rbs_gc_init
    @rbs_char_obj = ORBS::CharObj.new(self)
    @rbs_damages = []
    @action_x_plus = 0
    @action_y_plus = 0
    @action_x_per_update = 0
    @action_y_per_update = 0
    @action_move_duration = -1
  end
  
  def collide_with_characters?(x, y)
    for member in $game_members
      next unless member.pos?(x, y)
      next unless member.exist?
      return true unless member.battler.movable?
    end
    return oz_rbs_gc_collid_with_chars(x, y)
  end

  # * Set character sprite to move per frame by x/y_per_update for duration frames
  def action_move(x_per_update, y_per_update, duration)
    @action_move_duration = duration
    @action_x_per_update = x_per_update
    @action_y_per_update = y_per_update
  end
  
  # * Return the coordinates of the character as an object of class Coords
  def coords_obj
    return Coords.new(@x, @y)
  end
  
  # * Frame update
  def update
    oz_rbs_gc_update
    if @action_move_duration > 0
      @action_move_duration -= 1
      @action_x_plus += @action_x_per_update
      @action_y_plus += @action_y_per_update
    elsif @action_move_duration == 0
      @action_move_duration -= 1
    end
  end
  
  # * X-Position from screen. Add action's X addition
  def screen_x
    osx = oz_rbs_gc_sc_x
    return (oz_rbs_gc_sc_x + @action_x_plus.to_i)
  end
  
  # * Y-Position from screen. Add action's Y addition
  def screen_y
    osy = oz_rbs_gc_sc_y
    return (oz_rbs_gc_sc_y + @action_y_plus.to_i)
  end
  
  # * A shortcut method to return the coordinates at a given direction
  def coords_at_dir(dir)
    case dir
    when 1 ; return Coords.new(@x - 1, @y + 1)
    when 2 ; return Coords.new(@x, @y + 1)
    when 3 ; return Coords.new(@x + 1, @y + 1)
    when 4 ; return Coords.new(@x - 1, @y)
    when 6 ; return Coords.new(@x + 1, @y)
    when 7 ; return Coords.new(@x - 1, @y - 1) 
    when 8 ; return Coords.new(@x, @y - 1)
    when 9 ; return Coords.new(@x + 1, @y - 1)
    end
  end
  
  # * Move command without passability check, for simultaneous movement
  def force_move_to_dir(dir)
    #set_direction(dir)
    prev_through = @through
    @through = true
    case dir
    when 1 ; move_lower_left
    when 2 ; move_down
    when 3 ; move_lower_right
    when 4 ; move_left
    when 6 ; move_right
    when 7 ; move_upper_left
    when 8 ; move_up
    when 9 ; move_upper_right
    end
    @through = prev_through
  end
    
end

#==============================================================================
# ** Game_Member
#------------------------------------------------------------------------------
#  This class deals with the characters representing the other members of the 
# party. The instances of this class are in the global array $game_members
#==============================================================================
class Game_Member < Game_Character
  
  # * Public Instance Variables
  attr_reader :member_index
  attr_reader :after_update_dead
  
  # * Object Initialization
  def initialize(index)
    @member_index = index + 1
    @rbs_ai = ORBS::ActorAI.new(self)
    super()
    @battling = true
    @old_battler = battler()
    @after_update_dead = false
  end
  
  # * Add collision with members
  def collide_with_characters?(x, y)
    for member in $game_members
      return true if member.pos?(x, y) and member.exist?
    end
    return super
  end
  
  # * Bug Fix
  def check_event_trigger_touch(x, y)
  end
  
  # * Sync dashing with player
  def dash?
    return $game_player.dash?
  end
  
  # * Frame update - removes character graphic if dead
  def update
    super
    if exist?
      if @old_battler != battler or @character_name != @old_battler.character_name or
        @character_index != @old_battler.character_index
        @old_battler = battler
        @character_name = @old_battler.character_name
        @character_index = @old_battler.character_index
        unless ORBS.map_spriteset.nil?
          ORBS.map_spriteset.refresh_battler_info(@old_battler) if $scene.is_a?(
            Scene_Map)
        end
        @rbs_ai.actor_specific_initializations(@old_battler.id)
      end
      @after_update_dead = false
    else
      @character_name = ""
      @character_index = 0
      @after_update_dead = true unless ORBS.sequence_processor.running
    end
  end
  
  # * Determine if existing
  def exist?
    return false if battler.nil?
    return false unless battler.exist?
    return false unless ORBS.enabled?
    #return false if battler.removed_states.include?(1)
    return true
  end
  
  # * Determine transparency
  def transparent
    return false unless exist?
    return super
  end
  
  # * Determine if through
  def through
    return false unless exist?
    return super
  end
  
  # * Turn to the most relative direction towards character
  def turn_towards(character)
    dx = @x - character.x ; dy = @y - character.y
    if dx.abs < dy.abs
      dy > 0 ? turn_up : turn_down
    else
      dx > 0 ? turn_left : turn_right
    end
  end
  
  
  # * Get battler corresponding to the member object
  def battler
    return $game_party.members[@member_index]
  end
  
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles the player. It includes event starting determinants and map
# scrolling functions. The instance of this class is referenced by $game_player.
#==============================================================================
class Game_Player
  
  # * Alias List
  alias oz_rbs_moveto moveto
  alias oz_rbs_move_by_input move_by_input
  alias oz_rbs_gp_init initialize
  alias oz_rbs_gp_chck_ev_trig_tch check_event_trigger_touch
  alias oz_rbs_gp_get_on_boat get_on_boat
  alias oz_rbs_gp_get_on_ship get_on_boat
  alias oz_rbs_gp_get_on_airship get_on_boat
  alias oz_rbs_gp_get_off_vehicle get_off_vehicle
  alias oz_rbs_gp_upd update
  alias oz_rbs_gp_ref refresh
  
  # * Object Initialization - Added AI handler initialization
  def initialize
    oz_rbs_gp_init
    @rbs_ai = ORBS::ActorAI.new(self) # For confuse/berserk states
    @battling = true
  end
  
  def refresh
    oz_rbs_gp_ref
    @rbs_ai.actor_specific_initializations(battler.id)
  end
  
  unless method_defined?(:exist?)
    # * Determine Existence
    def exist?
      return true
    end
  end
  
  def update
    last_in_vehicle = in_vehicle?
    oz_rbs_gp_upd
    if last_in_vehicle and (not in_vehicle?)
      ORBS.refresh_caterpillar
      #p $game_player.x, $game_player.y
      for member in $game_members
        member.update
      end
    end
  end
  
  def get_on_boat
    enabled = ORBS.enabled?
    oz_rbs_gp_get_on_boat
    ORBS.refresh_caterpillar if enabled
  end
  
  def get_on_ship
    enabled = ORBS.enabled?
    oz_rbs_gp_get_on_ship
    ORBS.refresh_caterpillar if enabled
  end
  
  def get_on_airship
    enabled = ORBS.enabled?
    oz_rbs_gp_get_on_airship
    ORBS.refresh_caterpillar if enabled
  end
  
  def check_event_trigger_touch(*args)
    return if ORBS.turn_running
    oz_rbs_gp_chck_ev_trig_tch(*args)
  end
    
  # * Determine if it is dead after the revival update
  def after_update_dead
    return false
  end
  
  # * Processing of Movement via input from the Directional Buttons
  def move_by_input
    return if ORBS.turn_running
    return if $game_map.interpreter.running?
    return unless movable?
    if Input.press?(ORBS.face_key)
      set_direction(Input.dir8)
    elsif ORBS.enabled?
      evaluate_action_rbs
    elsif ORBS::EIGHT_DIRECTION
      move_by_input_dir8
    else
      oz_rbs_move_by_input
    end
  end
  
  def move_by_input_dir8
    return unless movable?
    return if $game_map.interpreter.running?
    case Input.dir4
    when 1 ; move_lower_left
    when 2 ; move_down
    when 3 ; move_lower_right
    when 4 ; move_left
    when 6 ; move_right
    when 7 ; move_upper_left
    when 8 ; move_up
    when 9 ; move_upper_right
    end
  end
  
  # * Evaluate if input is will perform an action
  def evaluate_action_rbs
    return ORBS.turn_process if ORBS.enabled? and (not battler.inputable?)
    if Input.trigger?(ORBS.no_action_key)
      battler.action.set_wait
      return ORBS.turn_process
    end
    dir = ORBS::EIGHT_DIRECTION ? Input.dir8 : Input.dir4
    if dir != 0
      coords = coords_at_dir(dir)
      if passable?(coords.x, coords.y)
        if dir % 2 == 1
          return unless passable_dir8?(dir)
        end
        force_move_to_dir(dir)
        battler.action.set_move
        check_member_swap(dir, coords.x, coords.y)
        ORBS.turn_process
      else
        set_direction(dir)
      end
    elsif Input.trigger?(ORBS.attack_key)
      ORBS.turn_running = true
      ORBS.action_process(self, @direction)
      ORBS.turn_process
    else
      for i in 1..(ORBS::NUMBER_OF_HOTKEYS)
        action_obj = ORBS.hotkey_objects[i - 1]
        if Input.trigger?(Input::Numbers[i]) and (not action_obj.nil?)
          if self.battler.rbs_skill_can_use?(action_obj)
            ORBS.turn_running = true
            ORBS.action_process(self, @direction, action_obj.id)
            ORBS.turn_process
          else
            sound = ORBS::SE_WHEN_UNABLE_TO_CAST
            Audio.se_play("Audio/SE/" + sound[0], sound[1], sound[2])
          end
        end
      end
    end
  end
  
  def passable_dir8?(direction)
    case direction
    when 1
      return ((passable?(@x, @y+1) and passable?(@x-1, @y+1)) or
       (passable?(@x-1, @y) and passable?(@x-1, @y+1)))
    when 3
      return ((passable?(@x, @y+1) and passable?(@x+1, @y+1)) or
       (passable?(@x+1, @y) and passable?(@x+1, @y+1)))
    when 7
      return ((passable?(@x, @y-1) and passable?(@x-1, @y-1)) or
       (passable?(@x-1, @y) and passable?(@x-1, @y-1)))
    when 9 
      return ((passable?(@x, @y-1) and passable?(@x+1, @y-1)) or
       (passable?(@x+1, @y) and passable?(@x+1, @y-1)))
    else ; return true
    end
  end
  
  # * Move player to coordinates, Add caterpillar refresh
  def moveto(*args)
    oz_rbs_moveto(*args)
    ORBS.refresh_caterpillar
    for member in $game_party.members
      member.remove_states_battle
    end
  end
  
  # * Player's battler object is the first member
  def battler
    return $game_party.members[0]
  end
  
  # * Check if a member exists on a tile, then swap positions with it
  def check_member_swap(dir, x, y)
    for member in $game_members
      if x == member.x and y == member.y
        #member.set_direction((@direction - 10)*(-1))
        member.force_move_to_dir((dir - 10)*(-1))
        member.battler.action.set_move
        member.rbs_ai.executed = true
        return
      end
    end
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  This class deals with events. It handles functions including event page 
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#==============================================================================
class Game_Event
    
  # * Added Public Instance Variables
  attr_reader :battler
  attr_reader :enemy_hue
  
  # * Alias List
  alias oz_rbs_ge_init initialize
  alias oz_rbs_setup setup
  alias oz_rbs_ge_dash dash?
  alias oz_rbs_start start
  alias oz_rbs_ge_col_with_char collide_with_characters?
  
  # * Object Initialization
  def initialize(*args)
    @enemy_hue = 0
    @battler = nil
    #@rbs_ai = ORBS::EnemyAI.new(self)
    oz_rbs_ge_init(*args)
    @battling = true
  end
  
  # * Start Event - Stop starting of event if battler is still alive
  def start
    return if ((not @battler.nil?) and ORBS.enabled?)
    oz_rbs_start
  end

  # * Sync dashing with player
  def dash?
    if @battler.nil?
      return oz_rbs_ge_dash
    else
      return $game_player.dash?
    end
  end
  
  # * Determine character collision - Add collision with members
  def collide_with_characters?(x, y)
    for member in $game_members
      if member.pos?(x, y) and member.exist?
        return true 
      end
    end
    unless @battler.nil?
      for event in $game_map.events_xy(x, y)          # Matches event position
        unless event.through                          # Passage OFF?
          return true if event.priority_type == 1     # Target is normal char
        end
      end
      if @priority_type == 1                          # Self is normal char
        return true if $game_player.pos_nt?(x, y)     # Matches player position
        return true if $game_map.boat.pos_nt?(x, y)   # Matches boat position
        return true if $game_map.ship.pos_nt?(x, y)   # Matches ship position
      end
      return false
    end
    return oz_rbs_ge_col_with_char(x, y)
  end

  # * Battler destruction process
  def destroy_battler
    @battler = nil
    oz_rbs_start
    $game_map.enemies.delete(self)
  end
  
  # * Setup Event - check if enemy
  def setup(*args)
    oz_rbs_setup(*args)
    unless @list.nil?
      for item in @list
        if item.code == 108 or item.code == 408
          next if item.parameters[0].nil?
          if item.parameters[0].downcase =~ /^\\s*enemy\\s*([0-9]+)/
            $game_map.enemies << self
            prev_enabled = ORBS.enabled?
            @battler = Game_Enemy.new(nil, $1.to_i)
            @enemy_hue = @battler.enemy.battler_hue
            @rbs_ai = ORBS::EnemyAI.new(self) if @rbs_ai.nil?
            @rbs_ai.enemy_specific_initializations(@battler.id)
            ORBS.enemy_exists = true
            ORBS.refresh_caterpillar if (not prev_enabled) and (ORBS.enabled?)
          end
        end
      end
    end
  end
end

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass of the Game_Actor
# and Game_Enemy classes.
#==============================================================================
class Game_Battler
  
  # * Alias List
  alias oz_rbs_atk_effective attack_effective?
  alias oz_rbs_skl_effective skill_effective?
  
  # * Determine Whether to Apply a Normal Attack - Always if in ORBS mode
  def attack_effective?(*args)
    return true if ORBS.turn_running
    oz_rbs_atk_effective(*args)
  end
  
  # * Determine Whether to Apply a skill - Always if in ORBS mode
  def skill_effective?(*args)
    return true if ORBS.turn_running
    oz_rbs_skl_effective(*args)
  end
  
  # * Consume the skill's cost
  def consume_skill_cost(skill)
    self.mp -= calc_mp_cost(skill)
  end
  
  # * Determine if skill can be used in the ORBS field
  def rbs_skill_can_use?(skill)
    return false unless skill.is_a?(RPG::Skill)
    return false unless movable?
    return false if silent? and skill.spi_f > 0
    return false if calc_mp_cost(skill) > mp
    return false if skill.occasion == 3
    return true
  end
  
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================
class Game_Actor
  
  # * Alias List
  alias oz_rbs_atk_animation_id atk_animation_id
  alias oz_rbs_ga_remove_state remove_state

  # * Get action sequence corresponding to the action
  def get_action_sequence(action)
    if action == 0
      return weapons[0].action_sequence unless weapons[0].nil?
      if two_swords_style
        return weapons[1].action_sequence unless weapons[1].nil?
      end
      return bare_hand_attack_sequence
    else
      return $data_skills[action].action_sequence
    end
  end
  
  # * Get attack animation id, based on the one in the configuration
  def atk_animation_id
    if weapons[0].nil? and weapons[1].nil?
      return bare_hand_attack_animation
    else
      return oz_rbs_atk_animation_id 
    end
  end
  
  # * Remove state - If incapacitated state removed, queue up for animation
  def remove_state(state_id)
    return unless state?(state_id)
    if state_id == 1 and @hp == 0
      has_revived = false
      for revived in ORBS.recently_revived
        has_revived = true if revived.id == self.id
      end
      ORBS.recently_revived << self unless has_revived
    end
    oz_rbs_ga_remove_state(state_id)
  end
    
end

#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
#  This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy
  
  # * Get action sequence corresponding to action
  def get_action_sequence(action)
    if action == 0
      return normal_attack_sequence
    else
      return $data_skills[action].action_sequence
    end
  end
  
  # * For convenient notation
  def id
    return @enemy_id
  end
  
end

#==============================================================================
# ** Game_BattleAction
#------------------------------------------------------------------------------
#  This class handles battle actions. This class is used within the
# Game_Battler class.
#==============================================================================
class Game_BattleAction
  
  # * Set action to normal movement
  def set_move
    @kind = 0
    @basic = 5
  end
  
  def set_wait
    @kind = 0
    @basic = 3
  end
  
  # * Determine if action is a normal movement
  def move?
    return (@kind == 0 and @basic == 5)
  end
  
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================
class Game_Map
  
  # * Alias List
  alias oz_rbs_setup setup
  
  # * Added Public Instance Variable
  attr_reader :enemies
  
  # * Setup map, set ORBS enabled flag to false by default.
  def setup(*args)
    ORBS.map_turn_count = 0
    ORBS.enemy_exists = false
    @enemies = []
    oz_rbs_setup(*args)
  end
  
end

#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
#  This class handles the party. It includes information on amount of gold 
# and items. The instance of this class is referenced by $game_party.
#==============================================================================
class Game_Party
  
  # * Alias List
  alias oz_rbs_gp_on_player_walk on_player_walk
  
  # * Processing Performed When Player Takes 1 Step
  def on_player_walk
    oz_rbs_gp_on_player_walk
    for actor in members
      if actor.slip_damage? or (actor.auto_hp_recover and actor.hp > 0)
        ORBS.map_spriteset.refresh_battler_info(actor) if ORBS.map_turn_count % 10 == 0
      end
    end
  end
end

#==============================================================================
# ** Game_Troop
#------------------------------------------------------------------------------
#  This class handles enemy groups and battle-related data. Also performs
# battle events. The instance of this class is referenced by $game_troop.
#==============================================================================
class Game_Troop
  
  # * Alias List
  alias oz_rbs_gt_turn_cnt turn_count
  
  # * Turn count
  def turn_count
    if $scene.is_a(Scene_Map)
      return ORBS.map_turn_count
    end
    return oz_rbs_gt_turn_cnt
  end
end

#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
#  A module containing RPGVX Data Structures.
#==============================================================================
module RPG
#==============================================================================
# ** RPG::State
#------------------------------------------------------------------------------
#  Data class for state.
#==============================================================================
class State
  
  # * Determine if the state has a negative effect (in theory)
  def negative_state?
    return true if @atk_rate + @def_rate + @agi_rate + @spi_rate <= 380
    return true if @restriction > 0 or @slip_damage or @reduce_hit_ratio
    return false
  end
  
  # * Determine if the state has a negative effect (in theory)
  def positive_state?
    return false unless @nonresistance
    return true if @atk_rate + @def_rate + @agi_rate + @spi_rate >= 420
    return false
  end
  
end
end

$orbs_addons = {}

# * Make Class Instance
class << ORBS
  
  # * Public Instance Variables
  attr_accessor :turn_running
  attr_accessor :map_spriteset
  attr_accessor :map_turn_count
  attr_accessor :char_objs
  attr_reader   :attack_key
  attr_reader   :face_key
  attr_reader   :no_action_key
  attr_reader   :hotkey_objects
  attr_reader   :window 
  attr_reader   :misc_font
  attr_reader   :recently_revived
  attr_reader   :gtext_color
  attr_reader   :etext_color
  attr_reader   :zerodamage_color
  attr_reader   :sequence_processor
  attr_writer   :enemy_exists
  attr_reader   :vehicle_route
  
  # * Start ORBS Initialization
  def start
    $game_members = []
    for i in 0..2
      $game_members << Game_Member.new(i)
    end
    @attack_key = eval("Input::" + ORBS::ATTACK_KEY)
    @face_key   = eval("Input::" + ORBS::FACE_FIRST_KEY)
    @no_action_key = eval("Input::" + ORBS::NO_ACTION_KEY)
    @enemy_exists = false
    @hotkey_objects = []
    @turn_running = false
    @map_spriteset = nil
    @recently_revived = []
    @window = Window_Base.new(-64, -64, 64, 64)
    @window.visible = false
    @misc_font = Font.new(ORBS::MISC_TEXT_FONT, ORBS::MISC_TEXT_SIZE)
    @misc_font.bold = true
    @etext_color = Color.new(60, 200, 200)
    @gtext_color = Color.new(200, 200, 80)
    @zerodamage_color = Color.new(210, 60, 60, 200)
    @sequence_processor = ORBS::SequenceProcessor.new
    @map_turn_count = 0
    #@vehicle_route = []
  end
  
  # * Determine if the engine is enabled
  def enabled?
    return false if $game_player.in_vehicle?
    case ORBS::ORBS_ENABLED_MODE
    when 0 ; return @enemy_exists
    when 1 ; return true
    end
  end
  
  # * Reset the objects used by the AI in data manipulation
  def reset_char_objs
    for char in @char_objs
      char.refresh
    end
  end
  
  # * Refresh caterpillar positions
  def refresh_caterpillar
    chars = [$game_player] + $game_members
    for member in $game_members
      next if member.battler.nil?
      next unless member.battler.exist?
      member.rbs_ai.actor_specific_initializations(member.battler.id)
      totail = nil
      if ORBS::PARTY_FORMATION == 0
        for i in 0..member.member_index - 1
          totail = chars[i] if chars[i].exist?
        end
        dirs = [2, 4, 6, 8].shuffle
        front = dirs.delete(totail.direction)
        dirs.unshift(dirs.delete((totail.direction - 10)*(-1)))
        dirs << front
      elsif ORBS::PARTY_FORMATION == 1
        totail = $game_player
        backdir = (-1)*($game_player.direction - 10)
        dirs = [backdir]
        case backdir
        when 2 ; dirs += ([1, 3].shuffle + [4, 6].shuffle) 
        when 4 ; dirs += ([7, 1].shuffle + [2, 8].shuffle) 
        when 6 ; dirs += ([3, 9].shuffle + [2, 8].shuffle) 
        when 8 ; dirs += ([9, 7].shuffle + [4, 6].shuffle) 
        end
      end
      has_moved = false
      for dir in dirs
        c = totail.coords_at_dir(dir)
        members_in_c = members_xy(c.x, c.y)
        members_in_c.delete(member)
        if member.passable?(c.x, c.y) and members_in_c.empty?
          member.moveto(c.x, c.y)
          member.turn_towards(totail)
          member.update
          has_moved = true
          break
        end
      end
      unless has_moved
        for n in 1...($game_map.width + $game_map.height)
          for m in 0..n
            for coord in [[m, n - m], [-m, n - m], [m, m - n], [-m, m - n]]
              x = $game_player.x + coord[0]
              y = $game_player.y + coord[1]
              if member.passable?(x, y)
                has_moved = true
                member.moveto(x, y)
                member.turn_towards($game_player)
                member.update
              end
            end
          end
          break Graphics.frame_reset if has_moved
        end
      end
    end
  end
  
  def members_xy(x, y)
    result = []
    for member in $game_members
      result << member if member.pos?(x, y)
    end
    return result
  end
  
  # * Main turn processing
  def turn_process
    @turn_running = true
    $game_player.battler.remove_states_auto
    ORBS.map_spriteset.refresh_battler_info(
      $game_player.battler) unless $game_player.battler.removed_states.empty?
    turn_units = make_turn_units
    no_one_executed = false
    until no_one_executed
      no_one_executed = true
      for unit in turn_units.clone
        next if unit.battler.nil?
        next unless unit.battler.exist? # check if died in the turn loop
        unit.rbs_ai.action_perform
        if unit.rbs_ai.executed
          unit.battler.remove_states_auto
          ORBS.map_spriteset.refresh_battler_info(unit.battler) unless unit.battler.removed_states.empty?
          turn_units.delete(unit)
          no_one_executed = false
          if $game_party.members[0].nil? or $game_party.members[0].dead?
            return $game_temp.next_scene = "gameover"
          end
        end
      end
    end
    play_movement
    @turn_ending = true # Will be used in the future
    for character in [$game_player] + $game_members + $game_map.enemies
      next if character.battler.nil?
      character.battler.action.clear
      character.rbs_ai.executed = false
    end
    ORBS.map_turn_count += 1
    @turn_ending = false
    @turn_running = false
  end
  
  # * Make units that will execute a turn
  def make_turn_units
    turn_units = []
    for character in [$game_player] + $game_members + $game_map.enemies
      battler = character.battler
      next if battler.nil?
      turn_units << character if battler.exist? and battler.action.nothing?
    end
    turn_units.sort!{|a, b| a.battler.agi <=> b.battler.agi}
    return turn_units
  end
  
  # * Process Normal Action
  def action_process(character, target_dir, action = 0)
    play_movement
    if action == 0
      character.battler.action.set_attack
    else
      character.battler.action.set_skill(action)
    end
    character.set_direction(target_dir)
    character.rbs_ai.executed = true
    sequence = ORBS::ACTION_SEQUENCES[character.battler.get_action_sequence(action)]
    character.battler.consume_skill_cost($data_skills[action]) if action > 0
    @map_spriteset.refresh_battler_info(character.battler)
    @sequence_processor.process(sequence, character, (action > 0 ? $data_skills[action] : nil))
    for char in [$game_player] + $game_members + $game_map.enemies
      char.action_x_plus = 0
      char.action_y_plus = 0
    end
    for char in $game_map.enemies.clone
      battler = char.battler
      if battler.dead?
        char.destroy_battler
        interpreter_update_loop
        members = ([$game_player] + $game_members).shuffle
        members.unshift(members.delete(character))
        unless battler.exp == 0
          for _character in members
            next if _character.battler.nil? or (not _character.battler.exist?)
            exp = battler.exp
            exp *= ORBS::EXP_TO_KILLER.to_f / 100.0 if _character == character
            text = sprintf(ORBS::EXP_TEXT, exp.to_i)
            ORBS.misc_font.color = ORBS.etext_color
            $game_map.interpreter.spawn_text(_character.x, _character.y, -1, 0, 3,
              nil, text)
            $scene.update_basic
            c_bat = _character.battler
            prevlevel = c_bat.level
            c_bat.gain_exp(exp.to_i, false)
            if prevlevel < c_bat.level
              4.times do $scene.update_basic end
              animation = $data_animations[ORBS::LEVEL_UP_ANIM]
              unless animation.nil?
                sx = ($game_map.adjust_x(_character.x * 256) + 8007) / 8 - 1000
                sy = ($game_map.adjust_y(_character.y * 256) + 8007) / 8 - 1000
                @map_spriteset.show_rbs_anim_at(sx, sy, 
                  $data_animations[ORBS::LEVEL_UP_ANIM], 
                  ORBS::LEVEL_UP_ANIM_SIZE.to_f / 100.0)
              end
              text = ORBS::LEVEL_UP_TEXT
              $game_map.interpreter.spawn_text(_character.x, _character.y,
                -1, 0, 3, nil, text)
              if ORBS::HEAL_ON_LEVEL_UP
                c_bat.recover_all
                ORBS.map_spriteset.refresh_battler_info(c_bat)
              end
              Graphics.frame_reset
            end
            6.times do $scene.update_basic end
          end
        end
        unless battler.gold == 0
          text = sprintf(ORBS::GOLD_TEXT, battler.gold)
          ORBS.misc_font.color = ORBS.gtext_color
          $game_map.interpreter.spawn_text($game_player.x, $game_player.y, -1, 0, 
            3, nil, text)
          $game_party.gain_gold(battler.gold)
          10.times do $scene.update_basic end
        end
      end
    end
    ORBS.map_spriteset.refresh_hotkey_tones if character == $game_player
  end
  
  # * Get battling character at coordinates
  def get_character_at_coords(coords)
    for character in [$game_player] + $game_members + $game_map.enemies
      return character if (character.pos?(coords.x, coords.y) and 
        (not character.battler.nil?) and character.battler.exist?)
    end
    return nil
  end
  
  # * Update Interpreter Until the event is done
  def interpreter_update_loop
    while $game_map.interpreter.running?
      Graphics.update
      Input.update
      $scene.update
    end
    $scene.update_basic
  end

  # * Play all movement until no one is moving
  def play_movement
    loop do
      someone_moving = false
      for character in [$game_player] + $game_members + $game_map.enemies
        if character.moving?
          someone_moving = true
          break
        end
      end
      return unless someone_moving
      $scene.update_basic
      for character in [$game_player] + $game_members #+ $game_map.enemies
        character.update if character.moving?
      end
    end
  end
end

#==============================================================================
#  << ORBS Engine >>
#==============================================================================

#==============================================================================
# ** ORBS
#------------------------------------------------------------------------------
#  A module for storing all data and custom classes needed by ORBS.
#==============================================================================
module ORBS
#==============================================================================
# ** ORBS::Sprite_AnimDummy
#------------------------------------------------------------------------------
#  Empty sprites for showing animations in map.
#==============================================================================
class Sprite_AnimDummy < Sprite_Base
  
  # * Object Initialization
  def initialize(viewport)
    super(viewport)
    self.bitmap = Cache.load_bitmap("Graphics/", "")
  end
  
  # * Start animation , saves the zoom factor in an instance variable
  def start_animation(animation, zoom = 1.00, mirror = false, additional_angle = 0)
    @zoom = zoom
    @additional_angle = additional_angle
    super(animation, mirror)
  end
  
  # * Overriden to alter animation sizes
  def animation_set_sprites(frame)
    cell_data = frame.cell_data
    for i in 0..15
      sprite = @animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern.nil? or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @animation_bitmap1
      else
        sprite.bitmap = @animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if @animation_mirror
        sprite.x = @animation_ox - cell_data[i, 1] * @zoom
        sprite.y = @animation_oy + cell_data[i, 2] * @zoom
        sprite.angle = (360 - cell_data[i, 4])
        sprite.angle += @additional_angle
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = @animation_ox + cell_data[i, 1] * @zoom
        sprite.y = @animation_oy + cell_data[i, 2] * @zoom
        sprite.angle = cell_data[i, 4]
        sprite.angle += @additional_angle
        sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + 300 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / 100.0 * @zoom
      sprite.zoom_y = cell_data[i, 3] / 100.0 * @zoom
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end
  
end

#==============================================================================
# ** ORBS::Sprite_HotkeyHUD
#------------------------------------------------------------------------------
#  This sprite is used to show the hotkey HUD and the hotkey icons.
#==============================================================================
class Sprite_HotkeyHUD < ::Sprite
  
  # * Object Initialization
  def initialize(viewport = nil)
    super(viewport)
    self.bitmap = Cache.system(HOTKEY_HUD_GRAPHIC)
    pos = Coords.new(*(HOTKEY_POS))
    pos.set_to(self)
    @hotkey_sprites = []
    ORBS.hotkey_objects.each_with_index do |obj, i|
      unless obj.nil?
        sprite = Sprite_Icon.new(obj.icon_index)
        sprite.x = HOTKEY_ICON_START_POS[0] + (HOTKEY_DISTANCE_X * i)
        sprite.y = HOTKEY_ICON_START_POS[1] + (HOTKEY_DISTANCE_Y * i)
        sprite.z += 1
        @hotkey_sprites[i] = sprite
      end
    end
    self.opacity = ORBS.enabled? ? 255 : 0
    refresh_hotkey_tones
  end
  
  # * Frame Update
  def update
    self.opacity += ORBS.enabled? ? 5 : -5
    super
  end
  
  # * Refresh hotkey tones
  def refresh_hotkey_tones
    ORBS.hotkey_objects.each_with_index do |obj, i|
      unless obj.nil?
        if $game_player.battler.rbs_skill_can_use?(obj) 
          @hotkey_sprites[i].tone.set(0, 0, 0)
        else
          @hotkey_sprites[i].tone.set(-60, -60, -60)
        end
      end
    end
  end
  
  # * Dispose method - Adds the disposal of the hotkey icon sprites
  def dispose
    for sprite in @hotkey_sprites
      sprite.dispose unless sprite.nil?
    end
    super
  end
  
  # * Set Visibility - also sets hotkey sprite's visibility along with it
  def opacity=(op)
    super(op)
    for sprite in @hotkey_sprites 
      sprite.opacity = op unless sprite.nil?
    end
  end
  
  # * Set viewport - Also sets the hotkey sprite's viewport along with it
  def viewport=(viewport)
    super(viewport)
    for sprite in @hotkey_sprites
      sprite.viewport = (viewport) unless sprite.nil?
    end
  end
  
end

#==============================================================================
# ** ORBS::Sprite_CharacterHUD
#------------------------------------------------------------------------------
#  This sprite shows the character's HP/MP and states on the screen.
#==============================================================================
class Sprite_CharacterHUD < ::Sprite

  # * Public Instance Variables
  attr_reader :battler
  
  # * Object initialization
  def initialize(index, viewport = nil)
    super(viewport)
    @index = index
    @new_battler = @battler = $game_party.members[index]
    self.bitmap = Bitmap.new(134, 80)
    self.x = 1 + index * 136
    self.y = 2
    refresh
    self.opacity = ORBS.enabled? ? 255 : 0
  end
  
  # * Refresh Contents
  def refresh(bitmap_only = false)
    self.bitmap.clear
    @character_sprite.dispose unless @character_sprite.nil? or bitmap_only
    return if @battler.nil? 
    self.bitmap.fill_rect(0, 0, 136, 64, Color.new(0, 0, 0, 128))
    unless bitmap_only
      @character_sprite = Sprite.new(viewport)
      @character_sprite.x = self.x + 2
      @character_sprite.y = self.y + 2
      @character_sprite.z = self.z + 2
      bmp = @character_sprite.bitmap = Cache.character(@battler.character_name)
      i = @battler.character_index
      sign = @battler.character_name[/^[\\!\\$]./]
      if sign != nil and sign.include?('$')
        @cs_cw = bmp.width / 3
        cs_ch = bmp.height / 4
        @offset_x = 0
        offset_y = 0
      else
        @cs_cw = bmp.width / 12
        cs_ch = bmp.height / 8
        @offset_x = (@cs_cw * 3) * (i % 4) 
        offset_y = (cs_ch * 4) * (i / 4)
      end
      @character_sprite.src_rect.set(@cs_cw + @offset_x, offset_y, @cs_cw, cs_ch)
    end
    ORBS.window.contents = self.bitmap
    ORBS.window.draw_actor_hp_gauge(@battler, 40, -6, 84)
    ORBS.window.draw_actor_mp_gauge(@battler, 40, 4, 84)
    ORBS.window.draw_actor_state(@battler, 3, 37, 120)
    ORBS.window.contents = nil
  end
  
  # * Set Viewport
  def viewport=(viewport)
    super
    @character_sprite.viewport = viewport unless @character_sprite.nil?
  end
  
  # * Dispose method
  def dispose
    @character_sprite.dispose unless @character_sprite.nil?
    super
  end
  
  # * Set Visibility - Change visibility of the character sprite as well
  def opacity=(op)
    super(op)
    @character_sprite.opacity = op unless @character_sprite.nil?
  end
  
  # * Frame Update
  def update
    super
    self.opacity += ORBS.enabled? ? 5 : -5
    @new_battler = $game_party.members[@index]
    if @new_battler != @battler
      @battler = @new_battler
      refresh
    end
    return if @battler.nil?
    @character_sprite.update
    if @battler.dead?
      @character_sprite.src_rect.x = @cs_cw + @offset_x
      @character_sprite.tone.set(-50, -50, -50, 50)
    else
      case Graphics.frame_count % 60
      when 0, 30 ; @character_sprite.src_rect.x = @cs_cw + @offset_x
      when 15 ; @character_sprite.src_rect.x = @offset_x
      when 45 ; @character_sprite.src_rect.x = @cs_cw * 2 + @offset_x
      end
      @character_sprite.tone.set(0, 0, 0, 0)
    end
  end

end

#==============================================================================
# ** ORBS::Sprite_Damage
#------------------------------------------------------------------------------
#  Sprites used for showing damage animation.
#==============================================================================
class Sprite_Damage < ::Sprite
  
  # * Public Instance Variables
  attr_reader :animating
  
  # * Object initialization - The bitmap is also created here
  def initialize(damage_sprite, damage, movemode, origin)
    super(origin.viewport)
    @animating = true
    self.z = origin.z + 400
    self.opacity = 0
    @movemode = movemode
    @duration = 0
    @origin = Coords.new(origin.x, origin.y)
    @heal_anim = damage < 0
    digits = []
    damage.to_s.each_byte{|c| digits << (c - 48) }
    digits.shift if @heal_anim
    num_bmp = Cache.system(damage_sprite)
    rect = Rect.new(0, 0, num_bmp.width / 10, num_bmp.height)
    self.bitmap = Bitmap.new((rect.width)*digits.size, 
      num_bmp.height)
    for i in 0...digits.size
      rect.x = digits[i] * rect.width
      self.bitmap.blt(i * rect.width, 0, num_bmp, rect)
    end
    self.y = origin.y - origin.height/2 - self.height/2
    Graphics.frame_reset
  end
  
  # * Frame update
  def update
    super
    if @duration == 0
      self.opacity = 255 
      self.x = @origin.x - self.width / 2
      @duration = 1
    elsif @heal_anim
      self.y -= 1
      self.opacity -= 10
      @animating = false if self.opacity <= 0
      @duration += 1
    else
      if @movemode != 1
        self.x = @origin.x - self.width / 2 + (@movemode == 0 ? -1 : 1)*@duration
      end
      self.y -= (@duration*17 - @duration*@duration)/17
      self.opacity -= @duration if @duration > 17
      @animating = false if self.opacity <= 0
      @duration += 1
    end
  end
  
  # * Add the disposal of the bitmap
  def dispose
    self.bitmap.dispose
    super
  end
  
end

#==============================================================================
# ** ORBS::Sprite_Projectile
#------------------------------------------------------------------------------
#  Sprites used for showing projectiles. Observes an instance of 
# ORBS::Game_Projectile, and automatically changes sprite conditions.
#==============================================================================
class Sprite_Projectile < ::Sprite
  
  # * Object Initialization
  def initialize(projectile, graphic, graphic_index, viewport = nil)
    super(viewport)
    self.x -= 1
    @projectile = projectile
    self.bitmap = Cache.character(graphic)
    sign = graphic[/^[\\!\\$]./]
    if sign != nil and sign.include?('$')
      @cw = bitmap.width / 3
      @ch = bitmap.height / 4
    else
      @cw = bitmap.width / 12
      @ch = bitmap.height / 8
    end
    @index = graphic_index
    @pattern = 1
    @pattern_count = 0
    update
  end
  
  # * Frame update
  def update
    super
    self.opacity = 0 if @projectile.transparent
    @pattern_count += 1
    if @pattern_count == @projectile.frames_to_next_tile
      @pattern_count = 0
      @pattern = (@pattern + 4) % 3
    end
    sx = (@index % 4 * 3 + @pattern) * @cw
    sy = (@index / 4 * 4 + (@projectile.direction - 2) / 2) * @ch
    self.src_rect.set(sx, sy ,@cw, @ch)
    self.x = @projectile.screen_x
    self.y = @projectile.screen_y
  end
  
  # * Determine if still animating
  def animation?
    return @projectile.moving
  end
end


#==============================================================================
# ** ORBS::SequenceProcessor
#------------------------------------------------------------------------------
#  Class used for processing action sequences and for checking for valid to cast
# action sequences
#==============================================================================
class SequenceProcessor
  
  # @args should be removed in the next version, Object.send will use the 
  # arguments directly.
  
  attr_reader :running
  
  # * Object Initialization
  def initialize
    @testing_commands = ["set_direction", "target_set", "action_effect", 
      "projectile_fire", "option_set"]
    @testing = false
    @running = false
  end
  
  # * Start Processing
  def start(sequence, skill)
    @sequence = sequence
    @target_tile = @user.coords_at_dir(@user.direction)
    @skill = skill
    if (not @testing) and @user.battler.confusion? 
      @hit_allies = @hit_enemies = true
    elsif skill.nil?
      @hit_allies = false
      @hit_enemies = true
    else
      @hit_allies = skill.for_friend?
      @hit_enemies = skill.for_opponent?
    end
    @damage_move_mode = ORBS::DMG_GRAPHIC_MOVE_MODE
    @hit_self_mode = 1
    @projectiles = {}
    @will_break = false
  end
  
  # * Process a sequence
  def process(sequence, user, skill = nil)
    unless @testing
      @user = user
      for char in [$game_player] + $game_members
        char.update
      end
      $scene.update_basic
    end
    start(sequence, skill)
    @running = true
    for action_name in sequence
      if action_name =~ /^[0-9]+$/
        @action_name = action_name
        action = action_name.to_i
        action.times do
          unless @testing
            for char in [$game_player] + $game_members
              char.update
            end
            $scene.update_basic
          end
          @projectiles.each do |key, projectile|
            projectile.update(@hit_allies, @hit_enemies, @hit_self_mode == 2)
            return @test_result = false if projectile.has_expired
          end
        end
        next
      end
      @args = ORBS::ACTION[action_name].clone
      command = @args.shift.downcase
      if @testing
        self.send(command) if (@testing_commands.include?(command))# call command name
      else
        self.send(command)
      end
      break if @will_break or (@testing and (not @test_result.nil?))
    end
    @running = false
  end
  
  # * Determine if a sequence will hit at least one valid character
  def hits_one_char?(sequence, user, direction, skill = nil)
    return true if user.battler.confusion?
    ORBS.reset_char_objs
    @testing = true
    @user = user.rbs_char_obj
    @user.direction = direction
    #start(sequence, skill)
    @test_result = nil
    process(sequence, nil, skill)
    @testing = false
    return @test_result
  end
  
  # * Set the target tile's location
  def target_set
    @target_tile = evaluate_coords_to_use(@args[0])
    x, y = @args[2], @args[3]
    if @args[1] == 0
      #_coords = evaluate_coords_to_use(@args[4])
      #base_dir = get_character_at_coords(_coords)
      #next if base_dir.nil?
      #base_dir = base_dir.rbs_char_obj if @testing
      case @user.direction
      when 4 ; x, y = y , x
      when 6 ; x, y = -y , -x
      when 8 ; x, y = -x, -y
      end
    end
    @target_tile.x += x
    @target_tile.y += y
  end
  
  # * Move character sprite
  def move_sprite
    coords = evaluate_coords_to_use(@args[0])
    target = get_character_at_coords(coords)
    return if target.nil?
    x , y = @args[2], @args[3]
    dur = @args[4]
    if @args[1] == 0
      #_coords = evaluate_coords_to_use(@args[5])
      #base_dir = get_character_at_coords(_coords)
      #return if base_dir.nil?
      case @user.direction
      when 4 ; x, y = -y , x
      when 6 ; x, y = y , -x
      when 8 ; x, y = -x, -y
      end
    end
    xdist = (x - target.action_x_plus)
    ydist = (y - target.action_y_plus)
    x_per_update = xdist.to_f/dur ; y_per_update = ydist.to_f/dur
    target.action_move(x_per_update, y_per_update, dur)
  end

  # * Set character direction
  def set_direction
    coords = evaluate_coords_to_use(@args[0])
    target = get_character_at_coords(coords)
    return if target.nil?
    target = target.rbs_char_obj if @testing
    if @args[1] >= 10
      _coords = evaluate_coords_to_use(@args[1] - 10,
        @user, @target_tile, @projectiles)
      _target = get_character_at_coords(_coords)
      return if _target.nil?
      _target = target.rbs_char_obj if @testing
      target.set_direction(_target.direction)
    else
      case @args[1]
      when -1 ; target.turn_right_90
      when 0 ; target.turn_180
      when 1 ; target.turn_left_90
      else ; target.set_direction(@args[2])
      end
    end
  end
  
  # * Fire a projectile
  def projectile_fire
    coords = evaluate_coords_to_use(@args[0])
    character_at_tile = get_character_at_coords(coords)
    if @testing
      character_at_tile = character_at_tile.rbs_char_obj unless character_at_tile.nil?
    end
    case @args[5]
    when 2, 4 , 6, 8 ; direction = @args[5]
    when 0 ; direction = @user.direction
    when -1 ; direction = 
      character_at_tile.nil? ? @user.direction : character_at_tile.direction
    end
    user = @testing ? @user.character : @user
    projectile = ORBS::Game_Projectile.new(coords, direction, @args[6], 
      @args[1], user, @args[8])
    projectile.transparent = true if @testing
    ORBS.map_spriteset.create_projectile(projectile, @args[2], @args[3])
    @projectiles[@args[7]] = projectile
    if @args[4]
      while projectile.moving
        unless @testing
          for char in [$game_player] + $game_members
            char.update
          end
          $scene.update_basic
        end
        @projectiles.each do |key, _projectile|
          _projectile.update(@hit_allies, @hit_enemies, @hit_self_mode == 2)
          if _projectile.has_expired
            @test_result = false
            break @will_break = true
          end
        end
      end
    end
  end
  
  # * Show an animation
  def animation
    coords = evaluate_coords_to_use(@args[0])
    target = get_character_at_coords(coords)
    return if (not @args[4]) and target.nil?
    sx = ($game_map.adjust_x(coords.x * 256) + 8007) / 8 - 1000
    sy = ($game_map.adjust_y(coords.y * 256) + 8007) / 8 - 1000
    if @args[1] == 0
      if @user.battler.action.attack?
        anim_id = @user.battler.atk_animation_id
      elsif @user.battler.action.skill?
        anim_id = @user.battler.action.skill.animation_id
      elsif @user.battler.action.item?
        anim_id = @user.battler.action.item.animation_id
      end
    else
      anim_id = @args[1]
    end
    additional_angle = 0
    if @args[5]
      case @user.direction
      when 2 ; additional_angle = 270
      when 4 ; additional_angle = 180
      when 8 ; additional_angle = 90
      end
    end
    anim_id = @user.battler.atk_animation_id if anim_id == -1
    ORBS.map_spriteset.show_rbs_anim_at(sx, sy, $data_animations[anim_id], 
      @args[2].to_f / 100.0, @args[3], additional_angle) unless $data_animations[anim_id].nil?
  end
  
  # * Apply action's effects
  def action_effect
    coords = evaluate_coords_to_