CP's Battle Engine v1.2b

##----------------------------------------------------------------------------##
## CP's Battle Engine v1.2b
## Created by Neon Black
##
## Only for non-commercial use.  See full terms of use and contact info at:
## http://cphouseset.wordpress.com/liscense-and-terms-of-use/
##----------------------------------------------------------------------------##
                                                                              ##
##----------------------------------------------------------------------------##
##    Revision Info:
## v1.2a+ in progress
##  1.2b released 1.26.2013 - Fixes vanishing enemy glitch
## v1.2 - 1.14.2013
##  Added new actor/enemy tags similar to 2k3 options
##  Added a simple sideview mode
##  Added in battle party change options
##  Changed battle animation queue into an array
##  Changed the fix for the "to screen" overlay bug
##  Numerous other small changes.
## v1.1 - 11.14.2012
##  Added mode 5 to replicate VX/2k styles
##  Removed compatibility with Foe Info View and Pop-ups v1.0 and v1.1
##  Fixed a bug related to skill and item window sizes
##  Slight tweaks and bugfixes
## v1.0a - 10.16.2012
##  Single line fix
## v1.0 - 9.11.2012
##  Final bugfixes and cleanup
## v0.3 - 9.10.2012
##  Numerous bugfixes
## v0.2 - 8.23.2012
##  Reorganized script
## v0.1 - 8.30.2012
##  Wrote and debugged main script
##----------------------------------------------------------------------------##
                                                                              ##
$imported = {} if $imported.nil?                                              ##
$imported["CP_BATTLEVIEW_2"] = 1.2                                            ##
                                                                              ##
##----------------------------------------------------------------------------##
##    Instructions:
## Place this script in the script editor below "Materials" and above "Main".
## This script modifies the battle system to be more visually pleasing and
## gives it a few different additional features.  There are numerous notebox
## tags available to change how several aspects of the battle system work.
##
##------
##    Notebox Tags:
##      Monster note tags:
##
## attack[x]
##  - Sets a monster's normal attack animation to animation "x".  This affects
##    skills set to "normal attack" animation.
## attack skill[x]
##  - Sets the monster's normal attack skill to skill "x".  This is the skill
##    they will use when they are berserk or confused.
## defend skill[x]
##  - Same as above, but with defend.  Doesn't really have any effect on
##    monsters.
##
##      Actor/Class note tags:
##    Note that Actor takes priority in all these tags.
## battler[name]
##  - Sets the actor's battler graphic to graphic "name".  Note that it must be
##    a file present in the folder "graphics/battlers".  This only has effect
##    in mode 4.
## side battler[name]
##  - Sets the name of the image to use for battlers in sideview mode.  If this
##    is not set, the character's left facing graphic is used.
## attack skill[x]
##  - Sets the actor's basic attack skill to kill "x".  This affects the basic
##    attack command as well as any party attack command or other command that
##    makes the actor auto attack.  Class version of this tag takes priority
##    over Actor version.
## defend skill[x]
##  - Same as above only with the defend skill.  Class version of this tag
##    takes priority over Actor version.
## hide mp  -or-  hide tp
##  - Hides the stat reguardless of any other conditions.  This stat will not
##    appear for the character during battle.
##
##      Monster and Actor/Class note tags:
## <flying>
##  - Causes the actor or enemy to bob up and down in battle as if they are
##    flying or floating.
## <transparent>
##  - Causes the actor or enemy to become partially transparent.
## <mirror>
##  - Mirrors the actor or enemy's battler sprite.
##
##      Skill note tags:
## cast anim[x]
##  - Sets the skill's casting animation to animation "x".  This plays on the
##    user of the skill before it is cast.
##
##    Weapon note tags:
## attack skill[x]
##  - Sets a characters default attack skill to skill ID "x" while the weapon
##    is equipped.  This takes priority over Actor and Class tags.
##
##------
##    Setting up Actor Command Blocks:
## The commands an actor has in battle can be modified using the notebox.  Note
## that you do not need to define this on any actor and actors that do not have
## this in their notebox will use the array at line 292 instead.  This will
## allow you to have certain commands on certain characters but not on other
## characters.  To do this, set up a section of the notebox in the following
## format:
##
##   <commands>
##   :attack
##   :defend
##   :skill
##   Name => 10
##   :item
##   :party
##   </commands>
##
## <commands>
##  - Designates the start of the actor's commands.  Must be used before any
##    skills are checked for.
## :attack
##  - The basic attack command will go here in the menu.
## :defend
##  - The basic defend command will go here in the menu.
## :skill
##  - All skill subsets an actor has will be placed here.  These are the basic
##    skill subsets that house the normal gameplay skills.
## :item
##  - The items command will go here in the menu.
## :party
##  - Allows the party member to switch out on their turn.
## Name => 10
##  - Used to designate a special skill.  The format is (I feel) relatively
##    simple.  The "Name" part is the name of the skill that will display in
##    the command window.  The number is the ID of the skill.  Note that the
##    skill conditions must still be met in order for the skill to be used.
##----------------------------------------------------------------------------##
                                                                              ##
module CP       # Do not touch                                                ##
module BATTLERS #  these lines.                                               ##
                                                                              ##
##----------------------------------------------------------------------------##
##    Config:
## The config options are below.  You can set these depending on the flavour of
## your game.  Each option is explained in a bit more detail above it.
##
##------
#    Graphical Config:

# First things first.  This is the number of battlers you will have in battle.
# Be careful as this may have undesired effects with certain scripts outside
# of battle.
BATTLERS_MAX = 4

# Allows members from the system tab to be added during test battles to
# increase the party size.
ADD_SYSTEM_MEMBERS = false

# This is the number of frames a single frame of battle animation will last.
# Lower numbers produce quicker and smoother animations.  3 or 4 are the best
# values.
ANIM_RATE = 4

# This is the option for determining battle style.  There are 4 modes it can be
# set to based on the values you choose.
# Mode 1 = Looks like the default battle engine.
# Mode 2 = Similar but displays faces in the status window.
# Mode 3 = Displays character battlers.  See above for note tags to set these.
# Mode 4 = Displays faces outside any window.
# Mode 5 = Simulates RM2K and RMVX styles with slight variations.
BATTLE_STYLE = 1

# This variable holds the battle style.  You can change this in game to change
# the battle style.
VARIABLE = 51

# In mode 2, this is the opacity of the status window.  In modes 3 and 4, this
# is the opacity of the actor command window.
WINDOW_OPACITY = 100

# If this option is set to true, the help window will always be open during
# actor command selection.
SHOW_HELP_WINDOW = false

# This is the size of the text for name, hp, mp, and tp in modes 2, 3, and 4.
LINE_HEIGHT = 16

# This determines if MP and TP are hidden when the user has no skills that use
# those types of pools.  For example, if a user does not have any skills that
# use MP, MP will be hidden until one is obtained.
HIDE_UNUSED_POOLS = false

# Determines if the skill and item windows will have variable sizes based on
# the number available.  If true, it will start with 1 row and add more if
# there are more items.  In modes 1 and 2 this will try to fill the screen, in
# modes 3 and 4 this will cap at 4 rows before scrolling.
VAR_HEIGHT = false

# This is the y placement offset of the monsters in battle.  This will allow
# you to shift all monster groups up or down without having to modify the
# groups themselves.
Y_OFFSET = 0

# This option corrects troop placement when the window is resized.  No matter
# the window size, the troop position will be centered in the window based on
# the placement in the editor.  Turn this off is using a script like Yanfly
# Core Engine that already does this.
RESIZE_CORRECTION = true

# This is the offset for animations that cover the screen and target the
# players party.  This will allow these animations to be shifted down and
# actually cover the actors.  This is disabled in sideview battles.
ANIM_OFFSET = 120

# This is the placement of actor battlers in mode 3 from the bottom of the
# screen.  Use this to shift them up or down.
Y_PLACEMENT = -12

# This is the zoom of actor battlers.  Use this to make them larger or smaller
# than normal battlers.  This only affects mode 3 and does not affect sideview
# battlers.
ZOOM = 100

# This is the cast animation for when an item is used.  Setting it to nil will
# prevent an animation from being displayed.
ITEM_ANIM = nil

# This hash contains the animations for when different skill types are used.
# Note that the skill note tag above takes priority.  To use, use the format
# "x => y," where "x" is the ID of the skill group and "y" is the animation to
# display.
CAST_ANIMS ={
  1 => 43,
  2 => 81,
}

##------
#    Party Config:

# These are the names for the new options that can be added to the party
# command window.
AUTO_NAME = "Auto"
RUSH_NAME = "All-out"
GUARD_NAME = "Defend"
PARTY_NAME = "Members"
SWITCH_NAME = "Switch"

# These are the commands to display in the party menu.
# :fight - Allows the player to select each action.
# :auto - Actors choose commands by auto.
# :rush - All actors attack the first enemy.
# :defend - All actors defend.
# :escape - Allows the player to flee from battle.
COMMANDS =[
  :fight,
  :auto,
  :rush,
  :guard,
  :party,
  :escape,
]

# These are the default abilities each actor in the party has.  If an actor has
# an empty list of commands they will get this list instead.  The notebox
# version of this takes priority.  See the instructions section titled
# "Setting up Actor Command Blocks" for a list of valid commands.  Additional
# commands from add-on scripts may be used here as well.
ABILITIES =[
  :attack,
  :skill,
  :defend,
  :item,
  :party,
]

# This option determines what a character's state must be in order to switch
# them in battle.
# 0 = Members always movable.
# 1 = Members must be alive.
# 2 = Members must be able to act.
# 3 = Members must be able to recieve input.
# 4 = Members may not be inflicted with status at all.
MOVE_MEMBERS = 1

# If this option is enabled, the player can only use the switch command from
# the party command window once per turn.
RESTRICT_USAGE = true

# This sets the change in speed of party members who are switched out on their
# turn.  Increasing this number makes the switch occur sooner.
SWITCH_SPEED = 0

# These are lines of text that can display when certain functions are performed
# in battle.  You can use the strings <target>, <user>, and <skill> in the line
# and they will be automatically replaced with the name of the user, target, or
# skill.
SWITCH_LOG = "<target> has switched out with <user>."

# This hash contains the help text to be displayed while the cursor is over a
# skill group during battle.  Note that each number is the same as the ID of
# the skill type in the data base, 0 is for while "items" is highlighted, and
# -1 is for while "party" is highlighted from the actor command window.  You
# can have a second line by adding "\n" to the string."
SKILL_HELP_TEXT ={
 -1 => "Switch places with a member on reserve.",
  0 => "Uses an item from the party's inventory.",
  1 => "Attack with a variety of offensive skills.",
  2 => "Cast a variety of offensive and supportive magics.",
}

##------
#    Sideview Battle System Config:
# This is the option to determine if sideview is turned on or off by default.
BATTLE_SIDE = false

# This is the switch that holds the sideview battle option.  You can turn this
# switch ON to enable sideview and OFF to disable it.
SBS_SWITCH = 52

# These values are the X and Y positions of the actors' feet when the sideview
# system is enabled.  Each number represents party position.
SBS_POS ={
  1  => [  462, 180  ],
  2  => [  480, 210  ],
  3  => [  492, 248  ],
  4  => [  500, 288  ],
}

# This option determines if animations are flipped when used by enemies.  This
# allows the animations to display properly no matter if the party or troop is
# using the skill.
FLIP_ANIM = true

##------
#    Add-on Config:
#  These are additional config options for scripts deemed compatible with
#  CPBE.  These include such things as allowing the said scripts to be enabled
#  or disabled by a switch, adding additional options, or extended cross
#  support.  Each add-on's options are listed below the name and supported
#  version of the script.

#    CP Battle Pop-ups v1.2+
# While the following switch is ON, battle pop-ups will NOT display.
POP_SWITCH = 51

##----------------------------------------------------------------------------##
                                                                              ##
                                                                              ##
##----------------------------------------------------------------------------##
## The following lines are the actual core code of the script.  While you are
## certainly invited to look, modifying it may result in undesirable results.
## Modify at your own risk!
###----------------------------------------------------------------------------


HIDE_V = /hide (hp|mp|tp)/i
NAME   = /battler\[(.+)\]/i
SIDE   = /side battler\[(.+)\]/i
ATTACK = /attack\[(\d+)\]/i
CAST   = /cast anim\[(\d+)\]/i
SCOMM  = /:(attack|skill|defend|item)/
NCOMM  = /(.*) => (\d+)/
COPEN  = /<commands>/i
CCLOSE = /<\/commands>/
ATK_ID = /attack skill\[(\d+)\]/i
DEF_ID = /defend skill\[(\d+)\]/i
TRANS  = /<transparent>/i
FLY    = /<flying>/i
MIRROR = /<mirror>/i

def self.styles; return [1, 2, 3, 4, 5]; end

def self.style  ## Gets the currently active style of the system.
  unless styles.include?($game_variables[VARIABLE])
    $game_variables[VARIABLE] = BATTLE_STYLE
  end
  return $game_variables[VARIABLE]
end

def self.sideview
  $game_switches[SBS_SWITCH] = BATTLE_SIDE unless @init_side; @init_side = true
  return $game_switches[SBS_SWITCH]
end

def self.style1; return style == 1; end
def self.style2; return style == 2; end
def self.style3; return style == 3; end
def self.style4; return style == 4; end
def self.style5; return style == 5; end

def self.classic; return [1, 2, 5].include?(style); end
def self.dated;   return [3, 4].include?(style);    end
def self.basic;   return [1, 5].include?(style);    end

def self.faceless; return [1, 3].include?(style); end
def self.face;     return [2, 4].include?(style); end

def self.clear_pop
  return $game_switches[POP_SWITCH]
end

end
end

module BattleManager
  def self.input_start
    if @phase != :input
      @phase = :input
      $game_troop.increase_turn  ## Turn increase moved up here to fix the
      $game_party.make_actions   ## turn counting on foes.
      $game_troop.make_actions
      clear_actor
    end
    return !@surprise && $game_party.inputable?
  end

  def self.turn_start
    @phase = :turn
    clear_actor  ## Removed turn count from here.
    make_action_orders
  end
end

class Game_Message
  alias cp_bv2_add add
  def add(text)
    cp_bv2_add(text)
    return unless CP::BATTLERS.style5 && $game_party.in_battle
    @background = 2
  end
end

class Game_Action
  def targets_for_friends
    if item.for_user?
      [subject]
    elsif item.for_dead_friend?
      if item.for_one?
        [friends_unit.smooth_dead_target(@target_index)]
      else
        friends_unit.dead_members
      end
    elsif item.for_friend?
      if item.for_one?  ## Added this line to add enemy healing AI.
        evaluate_item if @target_index < 0
        [friends_unit.smooth_target(@target_index)]
      else
        friends_unit.alive_members
      end
    end
  end
end

class Game_Battler < Game_BattlerBase
  attr_accessor :c_blinking  ## Used to add blinking in modes 3 and 4.

  alias cp_bv2_gb_init initialize
  def initialize
    cp_bv2_gb_init
    @c_blinking = false
  end
end

class Game_Enemy < Game_Battler
  def atk_animation_id
    if enemy.nattack_id == 0  ## Gets the animation of a foe's skill.
      rs = $data_skills[attack_skill_id].animation_id == -1 ? 1 :
           $data_skills[attack_skill_id].animation_id
    else
      rs = enemy.nattack_id
    end
    return rs
  end

  def attack_skill_id  ## Gets the basic attack and defend skills of a foe.
    enemy.sattack_id
  end

  def guard_skill_id
    enemy.sdefend_id
  end

  def flying?
    enemy.motion_flying
  end

  def transparent?
    enemy.motion_trans
  end

  def mirrored?
    enemy.motion_mirror
  end
end

class Game_Actor < Game_Battler
  attr_accessor :screen_x_pos_bv2
  attr_accessor :screen_y_pos_bv2
  attr_accessor :side_battler

  def animation_mirror  ## Mirrors animations displayed on actors.
    @animation_mirror = false unless @animation_mirror
    if CP::BATTLERS.sideview && CP::BATTLERS::FLIP_ANIM
      return !@animation_mirror
    else
      return @animation_mirror
    end
  end

  alias cp_bv2_setup setup
  def setup(actor_id)
    cp_bv2_setup(actor_id)  ## Creates an actor's battler.
    @battler_name = actor.battler_name
    @battler_name = self.class.battler_name if @battler_name == ""
    @side_battler = actor.side_battler
    @side_battler = self.class.side_battler if @side_battler == ""
  end

  def use_sprite?  ## Makes the actor use a sprite in certain modes.
    return true if CP::BATTLERS.sideview
    return false if CP::BATTLERS.basic
    return true if CP::BATTLERS.face
    return @battler_name == "" ? false : true
  end

  def all_commands  ## Gets all of an actor's commands with skills.
    res = commands.size
    return res unless commands.include?(:skill)
    res += added_skill_types.size - 1
    return res
  end

  def commands  ## Gets the actor's base commands.
    return actor.commands unless actor.commands.empty?
    return self.class.commands unless self.class.commands.empty?
    return CP::BATTLERS::ABILITIES
  end

  def attack_skill_id  ## Gets the actor's base attack skill.
    unless weapons.empty? || weapons[0].attack_skill == 0
      return weapons[0].attack_skill
    end
    return actor.sattack_id unless actor.sattack_id == 0
    return self.class.sattack_id unless self.class.sattack_id == 0
    return 1
  end

  def guard_skill_id  ## Gets the actor's base guard skill.
    return actor.sdefend_id unless actor.sdefend_id == 0
    return self.class.sdefend_id unless self.class.sdefend_id == 0
    return 2
  end

  def hide_mp?  ## Hide MP and TP under certain conditions.
    return true if actor.hide_mp?
    if CP::BATTLERS::HIDE_UNUSED_POOLS
      skills.each do |skill|
        if $imported["CP_SKILLCOSTS"]
          return false if skill_mp_cost(skill) > 0
          return false if skill.all_mp
        else
          return false if skill.mp_cost > 0
        end
      end
      return true
    end
    return false
  end

  def hide_tp?
    return true if actor.hide_tp?
    if CP::BATTLERS::HIDE_UNUSED_POOLS
      skills.each do |skill|
        if $imported["CP_SKILLCOSTS"]
          return false if skill_tp_cost(skill) > 0
          return false if skill.all_tp
        else
          return false if skill.tp_cost > 0
        end
      end
      return true
    end
    return false
  end

  def flying?
    actor.motion_flying
  end

  def transparent?
    actor.motion_trans
  end

  def mirrored?
    actor.motion_mirror
  end
end

class Game_Party < Game_Unit
  def max_battle_members  ## The max allowed battle characters.
    return CP::BATTLERS::BATTLERS_MAX
  end

  alias cp_bv2_setup_bt_addition setup_battle_test_members
  def setup_battle_test_members  ## Adds system members.
    cp_bv2_setup_bt_addition
    return unless CP::BATTLERS::ADD_SYSTEM_MEMBERS
    $data_system.party_members.each {|m| add_actor(m)}
  end
end

class Window_BattleLog < Window_Selectable
  def max_line_number  ## Changes the window for mode 5.
    return CP::BATTLERS.style5 ? 4 : 6
  end

  def back_opacity
    return CP::BATTLERS.style5 ? 0 : 64
  end
end

class Window_PartyCommand < Window_Command
  def visible_line_number  ## Mods the size of an party's battle window.
    return CP::BATTLERS.dated ? CP::BATTLERS::COMMANDS.size : 4
  end

  def make_command_list  ## Creates a list of the commands.
    CP::BATTLERS::COMMANDS.each do |com|
      case com
      when :fight
        add_command(Vocab::fight,  :fight)
      when :auto
        add_command(CP::BATTLERS::AUTO_NAME, :auto)
      when :rush
        add_command(CP::BATTLERS::RUSH_NAME, :rush)
      when :guard
        add_command(CP::BATTLERS::GUARD_NAME, :block)
      when :escape
        add_command(Vocab::escape, :escape, BattleManager.can_escape?)
      when :party
        add_command(CP::BATTLERS::PARTY_NAME, :party, SceneManager.scene.switch? &&
                $game_party.all_members.size > $game_party.max_battle_members)
      end
    end
  end
end

class Window_ActorCommand < Window_Command
  def visible_line_number  ## Gets the size of the actor's battle window.
    return 4 if @actor.nil? || CP::BATTLERS.classic
    i = @actor.all_commands
    h = @help_window ? @help_window.height : 0
    return [i, (Graphics.height - (120 + h)) / line_height].min
  end

  def make_command_list  ## Makes the list of commands.
    size1 = fitting_height(visible_line_number)
    size2 = Graphics.height - 120
    self.height = [size1, size2].min unless self.disposed?
    return unless @actor
    @actor.commands.each do |comm|
      if comm.is_a?(Symbol)  ## Gets each command by it's symbol.
        case comm
        when :attack
          add_command(Vocab::attack, :attack, @actor.attack_usable?,
                      @actor.attack_skill_id)
        when :skill
          @actor.added_skill_types.sort.each do |stype_id|
            name = $data_system.skill_types[stype_id]
            add_command(name, :skill, true, stype_id)
          end
        when :defend
          add_command(Vocab::guard, :guard, @actor.guard_usable?,
                      @actor.guard_skill_id)
        when :item
          add_command(Vocab::item, :item)
        when :party
          add_command(CP::BATTLERS::SWITCH_NAME, :party,
                  $game_party.all_members.size > $game_party.max_battle_members)
        else
          addon_command(comm)
        end
      elsif comm.is_a?(Array)
        can_use = @actor.usable?($data_skills[comm[1]])
        add_command(comm[0], :cp_command, can_use, comm[1])
      end
    end
  end

  unless method_defined?(:addon_command)
    def addon_command(comm)
    end
  end

  def update
    super  ## Makes the window stay open or closed during modes 3/4.
    return if CP::BATTLERS.classic
    self.hide if !active
    self.show if (active || ![0, 255].include?(openness))
  end

  def update_help  ## Updates the help window if it is turned on.
    case current_symbol  ## Get the command's help by symbol.
    when :attack, :guard, :cp_command
      @help_window.set_item($data_skills[current_ext])
    when :skill
      @help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(current_ext)
      @help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[current_ext])
    when :item
      @help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[0])
      @help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(0)
    when :party
      @help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[-1])
      @help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(-1)
    else
      addon_help_update(current_symbol)
    end
  end

  unless method_defined?(:addon_help_update)
    def addon_help_update(sym)
    end
  end
end

class Window_BattleStatus < Window_Selectable
  def window_width  ## Creates the party box width by mode.
    return CP::BATTLERS.classic ? Graphics.width - 128 : Graphics.width
  end

  def window_height  ## Gets the size of the party box by mode.
    return fitting_height(visible_line_number) if CP::BATTLERS.basic
    return 96 + standard_padding * 2  ## This is technically the same.
  end  ## The values that need this are more or less hard coded anyway....

  def col_max  ## Gets the max columns for other modes.
    return CP::BATTLERS.basic ? 1 : $game_party.max_battle_members
  end

  def spacing  ## Spacing.  Modded for certain types for a better feel.
    return 32 if CP::BATTLERS.basic
    return 0 if CP::BATTLERS.style2
    return standard_padding * 2
  end

  def item_height  ## Changes the height based on the current mode.
    return CP::BATTLERS.basic ? line_height : 96
  end

  def line_height  ## Changes the height of window items based on mode.
    return CP::BATTLERS.basic ? 24 : CP::BATTLERS::LINE_HEIGHT
  end

  alias cp_bv2_old_draw_item draw_item
  def draw_item(index)  ## Draws different contents based on the mode.
    return cp_bv2_old_draw_item(index) if CP::BATTLERS.basic
    contents.font.size = line_height
    actor = $game_party.battle_members[index]
    rect = rect_by_style(index)
    draw_bv2_face(actor, rect, index) if CP::BATTLERS.style2
    draw_basic_area_bv2(rect, actor)
    draw_gauge_area_bv2(rect, actor)
    contents.font.size = Font.default_size
  end

  def draw_bv2_face(actor, rect, nd)  ## Modded faces for modes 2/3.
    face_name = actor.face_name; face_index = actor.face_index
    bitmap = Cache.face(face_name)
    bt = Bitmap.new(96, 96)
    src = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
    bt.blt(0, 0, bitmap, src)
    size = Rect.new((96 - rect.width) / 2, 0, rect.width, rect.height)
    contents.blt(rect.x, rect.y, bt, size, trans?(nd) ? 255 : translucent_alpha)
  end

  def trans?(index)  ## Determines if the face is transparent or not.
    return true if @index == -1
    return (index == @index)
  end

  def rect_by_style(index)  ## Gets the item rectangle based on the style.
    rect = item_rect(index)
    return rect if CP::BATTLERS.faceless
    sides = rect.width - 96
    if sides > 0
      rect.width -= sides
      rect.x += sides / 2
    end
    cw = contents.width / CP::BATTLERS::BATTLERS_MAX
    rect.width = [rect.width, cw].min if CP::BATTLERS.style2
    return rect
  end

  def draw_basic_area_bv2(rect, actor)  ## Draws the basic HUD items.
    bottom = rect.y + rect.height
    i_w = contents.text_size(actor.name).width
    ncen = (rect.width - i_w) / 2
    total_icons = actor.state_icons.size + actor.buff_icons.size
    icen = [rect.width - total_icons * 24, rect.width % 24].max
    faces = CP::BATTLERS.face
    iy = faces ? bottom - line_height * 2 - 24 : rect.y
    ny = faces ? rect.y : bottom - line_height * 3
    draw_object_back(rect.x, ny, rect.width, ncen)
    draw_actor_name(actor, rect.x + ncen, ny, rect.width)
    draw_actor_icons(actor, rect.x + icen / 2, iy, rect.width - icen)
  end

  def draw_object_back(x, y, width, edge)
    l_h = line_height - 6  ## The fancy back used by the name on the HUD.
    c1 = gauge_back_color
    c1.alpha = 0
    c2 = gauge_back_color
    c2.alpha = 192
    temp = Bitmap.new(width, l_h)
    temp.gradient_fill_rect(0, 0, edge, l_h, c1, c2)
    temp.gradient_fill_rect(0 + width - edge, 0, edge, l_h, c2, c1)
    temp.fill_rect(0 + edge, 0, width - edge * 2, l_h, c2)
    contents.blt(x, y + 6, temp, temp.rect)
  end

  def draw_gauge_area_bv2(rect, actor)
    if $data_system.opt_display_tp  ## Draws either with or without TP.
      draw_gauge_area_with_tp_bv2(rect, actor)
    else
      draw_gauge_area_without_tp_bv2(rect, actor)
    end
  end

  def draw_gauge_area_with_tp_bv2(rect, actor)
    return draw_gauge_area_without_tp_bv2(rect, actor, :mp) if actor.hide_tp?
    return draw_gauge_area_without_tp_bv2(rect, actor, :tp) if actor.hide_mp?
    bottom = rect.y + rect.height  ## The with TP drawing.
    cen = rect.width / 2
    draw_actor_hp(actor, rect.x,       bottom - line_height * 2, rect.width)
    draw_actor_mp(actor, rect.x,       bottom - line_height,     cen)
    draw_actor_tp(actor, rect.x + cen, bottom - line_height,     cen)
  end

  def draw_gauge_area_without_tp_bv2(rect, actor, val = :mp)
    bottom = rect.y + rect.height  ## Without TP.
    i = CP::BATTLERS.style3 ? 2 : val == :mp && actor.hide_mp? ? 1 :
        val == :tp && actor.hide_tp? ? 1 : 2
    draw_actor_hp(actor, rect.x, bottom - line_height * i, rect.width)
    if val == :mp
      return if actor.hide_mp?
      draw_actor_mp(actor, rect.x, bottom - line_height,     rect.width)
    elsif val == :tp
      return if actor.hide_tp?
      draw_actor_tp(actor, rect.x, bottom - line_height,     rect.width)
    end
  end

  def draw_gauge_area_with_tp(rect, actor)  ## Modded old methods.
    return draw_gauge_area_without_tp(rect, actor, :mp) if actor.hide_tp?
    return draw_gauge_area_without_tp(rect, actor, :tp) if actor.hide_mp?
    draw_actor_hp(actor, rect.x + 0, rect.y, 72)
    draw_actor_mp(actor, rect.x + 82, rect.y, 64)
    draw_actor_tp(actor, rect.x + 156, rect.y, 64)
  end

  def draw_gauge_area_without_tp(rect, actor, val = :mp)
    if val == :mp
      if actor.hide_mp?
        draw_actor_hp(actor, rect.x + 0, rect.y, 220)
      else
        draw_actor_hp(actor, rect.x + 0, rect.y, 134)
        draw_actor_mp(actor, rect.x + 144,  rect.y, 76)
      end
    elsif val == :tp
      if actor.hide_tp?
        draw_actor_hp(actor, rect.x + 0, rect.y, 220)
      else
        draw_actor_hp(actor, rect.x + 0, rect.y, 134)
        draw_actor_tp(actor, rect.x + 144,  rect.y, 76)
      end
    else
      draw_actor_hp(actor, rect.x + 0, rect.y, 220)
    end
  end

  def update_cursor  ## Determines how to show the cursor by mode.
    refresh if CP::BATTLERS.style2
    return super if CP::BATTLERS.basic
    cursor_rect.empty
  end
end

class Window_BattleActor < Window_BattleStatus
  def col_max  ## Max columns used by the party target window.
    return CP::BATTLERS.dated ? item_max : 1
  end

  def item_max  ## Max items.  Always the same....
    return $game_party.battle_members.size
  end

  def window_height  ## The height based on mode.
    return fitting_height(visible_line_number)
  end

  def visible_line_number  ## Used for above method.
    return CP::BATTLERS.dated ? 1 : 4
  end

  def line_height
    return 24  ## Used to overwrite the super.
  end

  def item_width  ## Width.  Always the same....
    return width - (standard_padding * 2)
  end

  def item_height  ## Once again, overwrites super.
    return line_height
  end

  def contents_width  ## Same as above.
    return (item_width + spacing) * col_max - spacing
  end

  def draw_item(index)  ## Draws a horizontal view of battle status.
    actor = $game_party.battle_members[index]
    draw_basic_area(basic_area_rect(index), actor)
    draw_gauge_area(gauge_area_rect(index), actor)
  end

  def skill_viewport=(skill_viewport)
    @skill_viewport = skill_viewport
  end

  alias cp_bv2_show_old show
  def show  ## Shows the box and selects the first item.
    @skill_viewport.rect.width = Graphics.width - width if @skill_viewport
    return cp_bv2_show_old if CP::BATTLERS.classic
    select(0)
    super
  end

  alias cp_bv2_hide_old hide
  def hide  ## Hides the window and stops all blinking.
    cp_bv2_hide_old
    @skill_viewport.rect.width = Graphics.width if @skill_viewport
    $game_party.battle_members.each {|m| m.c_blinking = false}
  end

  def process_cursor_move  ## Prevents left/right wrapping.
    return unless cursor_movable?
    last_index = @index
    cursor_down (Input.trigger?(:DOWN))  if Input.repeat?(:DOWN)
    cursor_up   (Input.trigger?(:UP))    if Input.repeat?(:UP)
    cursor_right(false)                  if Input.repeat?(:RIGHT)
    cursor_left (false)                  if Input.repeat?(:LEFT)
    cursor_pagedown   if !handle?(:pagedown) && Input.trigger?(:R)
    cursor_pageup     if !handle?(:pageup)   && Input.trigger?(:L)
    Sound.play_cursor if @index != last_index
  end

  def current_item_enabled?  ## Gets which members are properly allowed.
    return true if @dead_members
    case CP::BATTLERS::MOVE_MEMBERS
    when 1
      return $game_party.battle_members[@index].alive?
    when 2
      return $game_party.battle_members[@index].movable?
    when 3
      return $game_party.battle_members[@index].inputable?
    when 4
      return $game_party.battle_members[@index].normal?
    else
      return true
    end
    return false
  end

  def ensure_cursor_visible  ## Ensures the proper actor is displayed.
    return super if CP::BATTLERS.classic
    self.ox = @index * (item_width + spacing)
  end

  def update_cursor  ## Modded to make actors blink.
    return super if CP::BATTLERS.basic
    $game_party.battle_members.each {|m| m.c_blinking = @cursor_all}
    if @cursor_all
      cursor_rect.set(0, 0, contents.width, row_max * item_height)
      self.top_row = 0
    elsif @index < 0
      cursor_rect.empty
    else
      ensure_cursor_visible
      cursor_rect.set(item_rect(@index))
      mem = $game_party.battle_members[@index]
      mem.c_blinking = true unless mem.nil?
    end
  end

  def activate(dead = true)  ## Determines if dead members may be selected.
    super()
    @dead_members = dead
  end
end

class Winodw_ExtraMembers < Window_BattleActor
  def item_max  ## Max items.  Always the same....
    return extra_members.size
  end

  def extra_members  ## Members not currently in the party.
    return $game_party.all_members - $game_party.battle_members
  end

  def draw_item(index)  ## Draws a horizontal view of battle status.
    actor = extra_members[index]
    draw_basic_area(basic_area_rect(index), actor)
    draw_gauge_area(gauge_area_rect(index), actor)
  end

  def actor_window=(actor_window)
    @actor_window = actor_window
  end

  def current_item_enabled?
    return true if @dead_members
    return false if last_for_dead
    return false if already_switch_in
    case CP::BATTLERS::MOVE_MEMBERS
    when 1
      return extra_members[@index].alive?
    when 2
      return extra_members[@index].movable?
    when 3
      return extra_members[@index].inputable?
    when 4
      return extra_members[@index].normal?
    else
      return true
    end
    return false
  end

  def last_for_dead  ## Prevents filling the party with dead members.
    return false unless @actor_window
    return false if $game_party.alive_members.size > 1
    return false unless $game_party.battle_members[@actor_window.index].alive?
    return false if extra_members[@index].alive?
    return true
  end

  def already_switch_in  ## Prevents a member from being switched in twice.
    $game_party.battle_members.each do |mem|
      mem.actions.each do |act|
        next if act.item.nil? || act.item.swap_party.nil?
        id = act.item.swap_party
        return true if id == $game_party.all_members.index(extra_members[@index])
      end
    end
    return false
  end

  def update_cursor
    if @cursor_all
      cursor_rect.set(0, 0, contents.width, row_max * item_height)
      self.top_row = 0
    elsif @index < 0
      cursor_rect.empty
    else
      ensure_cursor_visible
      cursor_rect.set(item_rect(@index))
    end
  end

  def activate(dead = true)
    super()
    @dead_members = dead
  end
end

class Window_BattleEnemy < Window_Selectable
  def col_max  ## Mods it's own size based on style.
    return 2 if CP::BATTLERS.classic
    return 3
  end

  alias cp_bv2_wind_width window_width
  def window_width  ## Mods it's width based on style.
    return cp_bv2_wind_width if CP::BATTLERS.classic
    return Graphics.width
  end

  def update_cursor  ## Causes enemies to blink.
    $game_troop.alive_members.each {|m| m.c_blinking = @cursor_all}
    if @cursor_all
      cursor_rect.set(0, 0, contents.width, row_max * item_height)
      self.top_row = 0
    elsif @index < 0
      $game_troop.alive_members.each {|m| m.c_blinking = false}
      cursor_rect.empty
    else
      mem = $game_troop.alive_members[@index]
      mem.c_blinking = true unless mem.nil?
      ensure_cursor_visible
      cursor_rect.set(item_rect(@index))
    end  ## Added method for old script.
    if !active
      $game_troop.alive_members.each {|m| m.c_blinking = false}
    end
  end

  def skill_viewport=(skill_viewport)
    @skill_viewport = skill_viewport
  end

  alias cp_bv2_show_old show
  def show  ## Changes the info viewport by style.  Ignored with CP Battleview.
    @skill_viewport.rect.width = Graphics.width - width if @skill_viewport
    return cp_bv2_show_old if CP::BATTLERS.classic
    if @info_viewport
      tot = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
      self.height = fitting_height(tot)
      create_contents
      refresh
      self.x = 0
      self.y = Graphics.height - height
      hr = @info_viewport.rect.height - height
      @info_viewport.rect.height = hr
      select(0)
    end
    super
  end

  alias cp_bv2_hide hide
  def hide  ## Reverts the info viewport to normal.
    cp_bv2_hide
    @skill_viewport.rect.width = Graphics.width if @skill_viewport
    if @info_viewport
      @info_viewport.rect.height = Graphics.height - @info_viewport.rect.y
    end
    $game_troop.alive_members.each {|m| m.c_blinking = false}
  end
end

class Window_BattleSkill < Window_SkillList
  def top_lines  ## Gets the max number of lines.
    return CP::BATTLERS.classic ? 99 : 4
  end

  def modded_height  ## Changes the window's height.
    if CP::BATTLERS::VAR_HEIGHT
      lines = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
    else
      lines = top_lines
    end  ## Will find the best fit based on the number of items.
    set = (line_height * [top_lines, lines].min) + (standard_padding * 2)
    return [set, @info_viewport.rect.y - y].min
  end

  def info_viewport=(window)
    @info_viewport = window
  end

  alias cp_bv2_show show
  def show  ## Update the height when the window is shown.
    self.height = modded_height unless CP::BATTLERS.style5
    self.height = fitting_height(4) if CP::BATTLERS.style5
    @info_viewport.visible = false if CP::BATTLERS.style5
    refresh
    cp_bv2_show
  end

  def hide  ## Modded to prevent the help window from vanishing.
    @help_window.hide unless CP::BATTLERS::SHOW_HELP_WINDOW
    @info_viewport.visible = true if CP::BATTLERS.style5
    super
  end
end

class Window_BattleItem < Window_ItemList
  def top_lines  ## Same as the class above.
    return CP::BATTLERS.classic ? 99 : 4
  end

  def modded_height
    if CP::BATTLERS::VAR_HEIGHT
      lines = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
    else
      lines = top_lines
    end
    set = (line_height * [top_lines, lines].min) + (standard_padding * 2)
    return [set, @info_viewport.rect.y - y].min
  end

  def info_viewport=(window)
    @info_viewport = window
  end

  alias cp_bv2_show show
  def show  ## Update the height when the window is shown.
    self.height = modded_height unless CP::BATTLERS.style5
    self.height = fitting_height(4) if CP::BATTLERS.style5
    @info_viewport.visible = false if CP::BATTLERS.style5
    refresh
    cp_bv2_show
  end

  def hide  ## Modded to prevent the help window from vanishing.
    @help_window.hide unless CP::BATTLERS::SHOW_HELP_WINDOW
    @info_viewport.visible = true if CP::BATTLERS.style5
    super
  end
end

class Scene_Battle < Scene_Base  ## The blood and guts of the script!!
  alias cp_bv2_create_info_viewport create_info_viewport
  def create_info_viewport  ## Lots of changes here.
    cp_bv2_create_info_viewport  ## Changes some aspects of certain windows.
    opac = CP::BATTLERS::WINDOW_OPACITY
    @status_window.back_opacity = opac if CP::BATTLERS.style2
    @status_window.opacity = 0 if CP::BATTLERS.dated
    @spriteset.info(@info_viewport, @status_window) if CP::BATTLERS.style4
    return unless CP::BATTLERS.style2
    $game_party.members.each_with_index do |mem, i|
      edge = 64 + @status_window.standard_padding
      rec = @status_window.width - (@status_window.standard_padding * 2)
      rec /= $game_party.max_battle_members
      l_offset = @status_window.height - @status_window.standard_padding
      mem.screen_x_pos_bv2 = edge + rec * i + rec / 2
      mem.screen_y_pos_bv2 = Graphics.height - l_offset
    end
  end

  alias cp_bv2_party_window create_party_command_window
  def create_party_command_window
    cp_bv2_party_window  ## Adds commands to the party window.
    @party_command_window.viewport = nil unless CP::BATTLERS.classic
    @party_command_window.set_handler(:auto,  method(:command_auto))
    @party_command_window.set_handler(:rush,  method(:command_rush))
    @party_command_window.set_handler(:block, method(:command_block))
    @party_command_window.set_handler(:party, method(:command_party))
  end

  alias cp_bv2_clog_window create_log_window
  def create_log_window
    cp_bv2_clog_window
    return unless CP::BATTLERS.style5
    @log_window.y = Graphics.height - @log_window.height
    @log_window2 = Window_Base.new(0, @log_window.y, @log_window.width,
                                   @log_window.height)
    @log_window2.openness = 255
  end

  alias cp_bv2_create_item_window create_item_window
  def create_item_window
    cp_bv2_create_item_window
    @skill_viewport = Viewport.new
    return unless CP::BATTLERS.style5
    @item_window.y = 0
    @skill_window.y = 0
    @item_window.info_viewport = @info_viewport
    @skill_window.info_viewport = @info_viewport
    @skill_viewport.rect.y = @info_viewport.rect.y
    @skill_viewport.rect.height = @item_window.height
    @skill_viewport.z = 100
    @item_window.viewport = @skill_viewport
    @skill_window.viewport = @skill_viewport
  end

  alias cp_bv2_actor_window create_actor_command_window
  def create_actor_command_window
    cp_bv2_actor_window  ## Adds a new command to the actor window.
    @actor_command_window.set_handler(:cp_command, method(:command_new_comms))
    @actor_command_window.set_handler(:party,      method(:command_switch))
    return if CP::BATTLERS.classic
    @actor_command_window.viewport = nil  ## May change window opacity.
    @actor_command_window.back_opacity = CP::BATTLERS::WINDOW_OPACITY
  end

  alias cp_bv2_help_window create_help_window
  def create_help_window
    cp_bv2_help_window
    return unless CP::BATTLERS::SHOW_HELP_WINDOW
    @help_window.visible = true  ## Prevents removal of the help window.
    @help_window.openness = 0
    @actor_command_window.help_window = @help_window
  end

  alias cp_bv2_create_enemy_window create_enemy_window
  def create_enemy_window
    cp_bv2_create_enemy_window
    @enemy_window.skill_viewport = @skill_viewport
    @actor_window.skill_viewport = @skill_viewport
  end

  alias cp_bv2_create_actor_window create_actor_window
  def create_actor_window
    cp_bv2_create_actor_window
    @extras_window = Winodw_ExtraMembers.new(@info_viewport)
    @extras_window.actor_window = @actor_window
    @extras_window.set_handler(:ok,     method(:on_extras_ok))
    @extras_window.set_handler(:cancel, method(:on_extras_cancel))
  end

  def command_attack  ## Makes the basic attack command like other commands.
    skill = $data_skills[BattleManager.actor.attack_skill_id]
    command_new_comms(skill)
  end

  def command_guard  ## Same as attack command but with defend.
    skill = $data_skills[BattleManager.actor.guard_skill_id]
    command_new_comms(skill)
  end

  def command_party
    @party_command_window.hide unless CP::BATTLERS.classic
    select_actor_selection
    @actor_window.activate(false)
  end

  def command_switch
    unless CP::BATTLERS.classic
      @actor_command_window.hide
      ypos = 0
      ypos = @help_window.y + @help_window.height if @help_window.visible &&
                                                     @help_window.open?
      @extras_window.y = ypos
    end
    BattleManager.actor.input.set_swap_party(0)
    @extras_window.refresh
    @actor_window.select($game_party.battle_members.index(BattleManager.actor))
    @extras_window.show.activate(false)
  end

  def command_new_comms(skl = nil)  ## Pushes the selected command.
    skill = skl ? skl : $data_skills[@actor_command_window.current_ext]
    BattleManager.actor.input.set_skill(skill.id)
    if !skill.need_selection?  ## Determines selection type.
      next_command
    elsif skill.for_opponent?
      select_enemy_selection
    else
      select_actor_selection
    end
  end

  alias cp_bv2_select_actor select_actor_selection
  def select_actor_selection
    cp_bv2_select_actor
    return if CP::BATTLERS.classic
    ypos = 0  ## Determines where to put the status window.
    ypos = @help_window.y + @help_window.height if @help_window.visible &&
                                                   @help_window.open?
    ypos = @skill_window.y + @skill_window.height if @skill_window.visible
    ypos = @item_window.y + @item_window.height if @item_window.visible
    @actor_window.y = ypos
  end

  alias cp_bv2_on_a_ok on_actor_ok
  def on_actor_ok
    if @party_command_window.current_symbol == :party
      if CP::BATTLERS.classic
        @actor_window.hide
      else
        ypos = 0
        ypos = @actor_window.y + @actor_window.height if @actor_window.visible
        @extras_window.y = ypos
      end
      @extras_window.refresh
      @extras_window.show.activate(false)
    else
      cp_bv2_on_a_ok
    end
  end

  alias cp_bv2_on_e_cancel on_enemy_cancel
  def on_enemy_cancel
    cp_bv2_on_e_cancel  ## Allows the cursor to return to it's index normally.
    case @actor_command_window.current_symbol
    when :cp_command, :attack, :guard
      @actor_command_window.activate
    end
  end

  alias cp_bv2_on_a_cancel on_actor_cancel
  def on_actor_cancel
    cp_bv2_on_a_cancel  ## Same as above.
    if @party_command_window.current_symbol == :party
      @party_command_window.show.activate
    else
      case @actor_command_window.current_symbol
      when :cp_command, :attack, :guard
        @actor_command_window.activate
      end
    end
  end

  def on_extras_ok
    if @party_command_window.current_symbol == :party
      i = @actor_window.index
      n = @actor_window.item_max + @extras_window.index
      $game_party.swap_order(i, n)
      $game_party.make_actions
      @status_window.refresh
      @extras_window.hide
      @actor_window.hide
      @spriteset.dispose_actors
      @spriteset.create_actors
      @party_command_window.show.activate
      @already_party = CP::BATTLERS::RESTRICT_USAGE
      @party_command_window.refresh
    else
      n = @actor_window.item_max + @extras_window.index
      BattleManager.actor.input.set_swap_party(n)
      @extras_window.hide
      next_command
    end
  end

  def on_extras_cancel
    @extras_window.hide
    if @party_command_window.current_symbol == :party
      i = @actor_window.index
      select_actor_selection
      @actor_window.select(i)
    else
      @actor_command_window.show.activate
    end
  end

  alias cp_bv2_status_create create_actor_window
  def create_actor_window
    cp_bv2_status_create  ## Mods the status window viewport OX by style.
    @info_viewport.ox = 128 unless CP::BATTLERS.classic
  end

  def show_attack_animation(targets, user = @subject)
    if user.actor?  ## Fixes how animations are shown by battler.
      show_normal_animation(targets, user.atk_animation_id1, false)
      show_normal_animation(targets, user.atk_animation_id2, true)
    else
      show_normal_animation(targets, user.atk_animation_id, false)
    end
  end

  def command_auto  ## Creates auto commands on actor selection.
    while BattleManager.next_command
      BattleManager.actor.make_auto_battle_actions
    end
    turn_start
  end

  def command_rush  ## Makes all party members auto attack.
    while BattleManager.next_command
      BattleManager.actor.input.set_attack
      BattleManager.actor.input.target_index = 0
      next if BattleManager.actor.input.item.for_opponent?
      BattleManager.actor.input.evaluate_item
    end
    turn_start
  end

  def command_block  ## Makes all party members block.
    while BattleManager.next_command
      BattleManager.actor.input.set_guard
    end
    turn_start
  end

  alias cp_bv2_turn_start turn_start
  def turn_start  ## Motion of several modified windows.
    @help_window.close if CP::BATTLERS::SHOW_HELP_WINDOW
    if CP::BATTLERS.style5
      @status_window.openness = 0
      @actor_command_window.openness = 0
      @party_command_window.openness = 0
      @log_window2.openness = 255
      $game_message.background = 2
    end
    return cp_bv2_turn_start if CP::BATTLERS.classic
    @actor_command_window.openness = 0 if !@actor_command_window.visible
    cp_bv2_turn_start
  end

  def start_actor_command_selection
    @status_window.select(BattleManager.actor.index)
    @party_command_window.close unless CP::BATTLERS.style5
    @actor_command_window.setup(BattleManager.actor)
    @help_window.open if CP::BATTLERS::SHOW_HELP_WINDOW
    return if CP::BATTLERS.classic
    th = @status_window.height + @actor_command_window.height
    @actor_command_window.y = Graphics.height - th
    slo = Graphics.width / $game_party.max_battle_members
    pos = (slo * BattleManager.actor.index) + slo / 2
    @actor_command_window.x = pos - @actor_command_window.width / 2
    @actor_command_window.x = 0 if @actor_command_window.x < 0
    grmw = Graphics.width - @actor_command_window.width
    @actor_command_window.x = grmw if @actor_command_window.x > grmw
  end

  def start_party_command_selection
    @help_window.close if CP::BATTLERS::SHOW_HELP_WINDOW
    unless scene_changing?
      if CP::BATTLERS.style5
        @info_viewport.ox = 0 if @info_viewport.ox == 64
        @actor_command_window.openness = 255
        @party_command_window.openness = 255
        @status_window.openness = 255
        @log_window2.openness = 0
      end
      refresh_status
      @status_window.unselect
      @status_window.open
      if BattleManager.input_start
        @actor_command_window.close unless CP::BATTLERS.style5
        @party_command_window.setup
      else
        @party_command_window.deactivate
        turn_start
      end
    end
  end

  alias cp_bv2_up_info_view update_info_viewport
  def update_info_viewport  ## Ignores viewport movement in some styles.
    return cp_bv2_up_info_view unless CP::BATTLERS.dated
  end

  def process_action
    return if scene_changing?
    if !@subject || !@subject.current_action
      @subject = BattleManager.next_subject
    end
    return turn_end unless @subject
    if @subject.current_action
      @subject.current_action.prepare
      if @subject.current_action.valid?
        @status_window.open unless CP::BATTLERS.style5  ## Only added this.
        execute_action
      end
      @subject.remove_current_action
    end
    process_action_end unless @subject.current_action
  end

  def execute_action  ## Creates the casting animations.
    if @subject.current_action.item.swap_party.nil?
      @log_window.display_use_item(@subject, @subject.current_action.item)
      item = @subject.current_action.item
      sid = nil
      sid = :item if item.is_a?(RPG::Item)
      sid = item.stype_id if item.is_a?(RPG::Skill)
      cst = item.is_a?(RPG::UsableItem) ? item.cast_anim : 0
      perform_casting_use(sid, cst)
    end
    @log_window.clear
    use_item
    @log_window.wait_and_clear
  end

  def perform_casting_use(type = nil, cast = 0)
    if type.nil?  ## Finds and performs the proper casting animations.
      @subject.sprite_effect_type = :whiten
      abs_wait_short
    elsif cast > 0
      @subject.animation_id = cast
      wait_for_animation
    elsif type == :item && !CP::BATTLERS::ITEM_ANIM.nil?
      @subject.animation_id = CP::BATTLERS::ITEM_ANIM
      wait_for_animation
    elsif type.is_a?(Integer) && CP::BATTLERS::CAST_ANIMS.include?(type)
      @subject.animation_id = CP::BATTLERS::CAST_ANIMS[type]
      wait_for_animation
    else
      @subject.sprite_effect_type = :whiten
      abs_wait_short
    end
  end

  def invoke_counter_attack(target, item)  ## Modified counter.
    @log_window.display_counter(target, item)
    attack_skill = $data_skills[target.attack_skill_id]
    if attack_skill.for_opponent?  ## Gets the attack's target.
      tgs = [@subject] * [attack_skill.number_of_targets, 1].max
    else
      tgs = [target] * [attack_skill.number_of_targets, 1].max
    end
    if attack_skill.animation_id < 0  ## Shows the attack anim.
      show_attack_animation(tgs, target)
    else
      show_normal_animation(tgs, attack_skill.animation_id)
    end  ## Performs the counter attack.
    tgs.each {|t| attack_skill.repeats.times {do_counter(target, attack_skill)}}
  end

  alias cp_basic_check_substitute check_substitute
  def check_substitute(target, item)  ## Prevents covering friendly attacks.
    return false if @subject.enemy? and target.enemy?
    return cp_basic_check_substitute(target, item)
  end

  def do_counter(user, item)  ## Modified counter to properly use party skills.
    target = item.for_opponent? ? @subject : user
    target.item_apply(user, item)
    refresh_status
    @log_window.display_action_results(target, item)
  end

  alias cp_bv2_turn_end turn_end
  def turn_end  ## Process party switch cooldown.
    @already_party = false
    temp = []
    $data_skills.each do |a|
      next if a.nil?
      next if a.swap_party.nil?
      temp.push(a)
    end
    $data_skills -= temp
    cp_bv2_turn_end
  end

  def switch?  ## Check if the party has already been switched.
    @already_party = false if @already_party.nil?
    return !@already_party
  end

  alias cp_bv2_use_item use_item
  def use_item  ## Process an actor set switch.
    item = @subject.current_action.item
    if !item.swap_party.nil? && item.swap_party > 0
      user_swap_party
    else
      cp_bv2_use_item
    end
  end

  unless method_defined?(:user_swap_party)
    def user_swap_party  ## Perform the basic switch.
      item = @subject.current_action.item
      text = CP::BATTLERS::SWITCH_LOG.gsub(/<user>/i, @subject.name)
      text.gsub!(/<target>/i, $game_party.all_members[item.swap_party].name)
      text.gsub!(/<skill>/i, CP::BATTLERS::SWITCH_NAME)
      @log_window.add_text(text)
      i = $game_party.all_members.index(@subject)
      n = item.swap_party
      $game_party.swap_order(i, n)
      @status_window.refresh
      @spriteset.dispose_actors
      @spriteset.create_actors
    end
  end
end

class Game_Action  ## Adds a switch skill and who to switch with.
  def set_swap_party(id = 0)
    if id > 0
      $data_skills.push(RPG::Skill.new)
      $data_skills[-1].swap_party = id
      $data_skills[-1].speed += CP::BATTLERS::SWITCH_SPEED
      $data_skills[-1].id = $data_skills.size - 1
      @item.object = $data_skills[-1]
    else
      @item.object = $data_skills[1]
    end
    self
  end
end

class Animation_Class
  attr_accessor :animation
  attr_accessor :ani_duration
  attr_accessor :ani_mirror
  attr_accessor :ani_rate
  attr_accessor :ani_bitmap1
  attr_accessor :ani_bitmap2
  attr_accessor :ani_sprites
  attr_accessor :ani_duplicated
  attr_accessor :ani_ox
  attr_accessor :ani_oy
end

class Sprite_Base < Sprite
  @@ani_checker_frame = 0

  alias cp_bv2_spb_init initialize
  def initialize(*args)
    @ani_array = []  ## Adds an animation array.
    cp_bv2_spb_init(*args)
  end

  def dispose
    super  ## Dispose each element of the array.
    @ani_array.each {|ani| dispose_animation(ani)}
  end

  def update
    super  ## FIX THE LEGACY BUG!
    update_animation
    @@ani_checker.clear unless @@ani_checker_frame == Graphics.frame_count
    @@ani_spr_checker.clear unless @@ani_checker_frame == Graphics.frame_count
    @@ani_checker_frame = Graphics.frame_count
  end

  def animation?  ## Checks if the animation array is empty.
    !@ani_array.empty?
  end

  def start_animation(animation, mirror = false)
    if animation  ## Adds a new animation to the array.
      @ani_array.push(Animation_Class.new)
      ani = @ani_array[-1]
      ani.animation = animation
      ani.ani_mirror = mirror
      set_animation_rate(-1)
      ani.ani_duration = ani.animation.frame_max * ani.ani_rate + 1
      load_animation_bitmap(ani)
      make_animation_sprites(ani)
      set_animation_origin(ani)
    end
  end

  def set_animation_rate(i = -1)  ## Sets the rate to make anims flow better.
    @ani_array[i].ani_rate = CP::BATTLERS::ANIM_RATE
  end

  def load_animation_bitmap(ani = nil)
    return unless ani  ## Loads an animation into the array.
    animation1_name = ani.animation.animation1_name
    animation1_hue = ani.animation.animation1_hue
    animation2_name = ani.animation.animation2_name
    animation2_hue = ani.animation.animation2_hue
    ani.ani_bitmap1 = Cache.animation(animation1_name, animation1_hue)
    ani.ani_bitmap2 = Cache.animation(animation2_name, animation2_hue)
    if @@_reference_count.include?(ani.ani_bitmap1)
      @@_reference_count[ani.ani_bitmap1] += 1
    else
      @@_reference_count[ani.ani_bitmap1] = 1
    end
    if @@_reference_count.include?(ani.ani_bitmap2)
      @@_reference_count[ani.ani_bitmap2] += 1
    else
      @@_reference_count[ani.ani_bitmap2] = 1
    end
    Graphics.frame_reset
  end

  def make_animation_sprites(ani = nil)
    return unless ani  ## Makes the sprites for the array.
    ani.ani_sprites = []
    if @use_sprite && !@@ani_spr_checker.include?(ani.animation)
      16.times do
        sprite = ::Sprite.new(viewport)
        sprite.visible = false
        ani.ani_sprites.push(sprite)
      end
      if ani.animation.position == 3
        @@ani_spr_checker.push(ani.animation)
      end
    end
    ani.ani_duplicated = @@ani_checker.include?(ani.animation)
    if !ani.ani_duplicated && ani.animation.position == 3
      @@ani_checker.push(ani.animation)
    end
  end

  def set_animation_origin(ani = nil)
    return unless ani  ## Sets the origin... for the array.
    if ani.animation.position == 3
      if viewport == nil
        ani.ani_ox = Graphics.width / 2
        ani.ani_oy = Graphics.height / 2
      else
        ani.ani_ox = viewport.rect.width / 2
        ani.ani_oy = viewport.rect.height / 2
      end
    else
      ani.ani_ox = x - ox + width / 2
      ani.ani_oy = y - oy + height / 2
      if ani.animation.position == 0
        ani.ani_oy -= height / 2
      elsif ani.animation.position == 2
        ani.ani_oy += height / 2
      end
    end
  end

  def dispose_animation(ani = nil)
    return unless ani  ## Need I say it?
    if ani.ani_bitmap1
      @@_reference_count[ani.ani_bitmap1] -= 1
      if @@_reference_count[ani.ani_bitmap1] == 0
        @@_reference_count.delete(ani.ani_bitmap1)
        ani.ani_bitmap1.dispose
      end
    end
    if ani.ani_bitmap2
      @@_reference_count[ani.ani_bitmap2] -= 1
      if @@_reference_count[ani.ani_bitmap2] == 0
        @@_reference_count.delete(ani.ani_bitmap2)
        ani.ani_bitmap2.dispose
      end
    end
    if ani.ani_sprites
      ani.ani_sprites.each {|sprite| sprite.dispose }
    end  ## Deletes the position in the array.
    @ani_array.delete_at(@ani_array.index(ani))
  end

  def update_animation  ## Updates each animation in the array.
    return unless animation?
    @ani_array.each do |ani|
      ani.ani_duration -= 1
      if ani.ani_duration % ani.ani_rate == 0
        if ani.ani_duration > 0
          frame_index = ani.animation.frame_max
          frame_index -= (ani.ani_duration + ani.ani_rate - 1) / ani.ani_rate
          animation_set_sprites(ani.animation.frames[frame_index], ani)
          ani.animation.timings.each do |timing|
            animation_process_timing(timing, ani) if timing.frame == frame_index
          end
        else
          end_animation(ani)
        end
      end
    end
  end

  def end_animation(ani = nil)
    dispose_animation(ani)  ## I think I took something out of this.
  end

  def animation_set_sprites(frame, ani = nil)
    return unless ani
    cell_data = frame.cell_data
    ani.ani_sprites.each_with_index do |sprite, i|
      next unless sprite
      pattern = cell_data[i, 0]
      if !pattern || pattern < 0
        sprite.visible = false
        next
      end
      sprite.bitmap = pattern < 100 ? ani.ani_bitmap1 : ani.ani_bitmap2
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if ani.ani_mirror
        sprite.x = ani.ani_ox - cell_data[i, 1]
        sprite.y = ani.ani_oy + cell_data[i, 2]
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = ani.ani_ox + cell_data[i, 1]
        sprite.y = ani.ani_oy + cell_data[i, 2]
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
      end  ## Adjust the animation position.
      ofs = CP::BATTLERS.sideview ? 0 : CP::BATTLERS::ANIM_OFFSET
      sprite.y += ofs if ani.animation.to_screen? && @battler && @battler.actor?
      sprite.z = self.z + 300 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / 100.0
      sprite.zoom_y = cell_data[i, 3] / 100.0
      sprite.opacity = cell_data[i, 6]  ## Ignore transparency.
      sprite.blend_type = cell_data[i, 7]
    end
  end

  def animation_process_timing(timing, ani = nil)
    return unless ani  ## Made once again for the array.
    timing.se.play unless ani.ani_duplicated
    case timing.flash_scope
    when 1
      self.flash(timing.flash_color, timing.flash_duration * ani.ani_rate)
    when 2
      if viewport && !ani.ani_duplicated
        viewport.flash(timing.flash_color, timing.flash_duration * ani.ani_rate)
      end
    when 3
      self.flash(nil, timing.flash_duration * ani.ani_rate)
    end
  end
end

class Sprite_Character < Sprite_Base
  def end_animation(*args)
    super(*args)  ## Ensures sprites work.
    @character.animation_id = 0
  end

  def move_animation(dx, dy)
    @ani_array.each do |ani|
      if ani.animation && ani.animation.position != 3
        ani.ani_ox += dx
        ani.ani_oy += dy
        ani.ani_sprites.each do |sprite|
          sprite.x += dx
          sprite.y += dy
        end
      end
    end
  end
end

class Sprite_Battler < Sprite_Base
  attr_accessor :viewport4

  def opacity=(i)
    n = @battler.transparent? ? i * 0.62 : i
    super(n)
  end

  alias cp_bv2_init_vis init_visibility
  def init_visibility
    self.opacity = 255
    cp_bv2_init_vis
  end

  def flying_offset
    return self.oy unless @battler.flying?
    frames = 480
    @flying_add = 2.0 + rand if @flying_add.nil?
    @flying_frame = rand(frames).to_f if @flying_frame.nil?
    @flying_frame += @flying_add
    ra = ((@flying_frame % frames).to_f / frames) * 360
    offset = 6 * Math.sin(ra * Math::PI / 180)
    return (self.height - 3) + offset
  end

  alias cp_bv2_sb_init initialize
  def initialize(viewport, battler = nil, use = true)
    @used_sprite = use
    if !use
      return super() if CP::BATTLERS.basic
      return super() if battler.battler_name == "" && !CP::BATTLERS.face
    end
    cp_bv2_sb_init(viewport, battler)
    update
  end

  alias cp_bv2_sb_update update
  def update  ## Updates the blinking effect in modes 3/4.
    if $imported["CP_BATTLEVIEW"] && $imported["CP_BATTLEVIEW"] >= 1.2
      @battler.popup.clear if CP::BATTLERS.clear_pop
    end
    #return cp_bv2_sb_update if CP::BATTLERS.sideview
    @c_blinking = 0  if @c_blinking.nil?
    @c_blinking += 1; @c_blinking %= 80
    cp_bv2_sb_update
  end

  alias cp_bv2_update_bitmap update_bitmap
  def update_bitmap  ## Modified update to get faces and battlers.
    if @used_sprite && CP::BATTLERS.sideview && @battler.actor?
      update_sideview_bitmap
    elsif @battler.enemy? || CP::BATTLERS.faceless
      self.mirror = @battler.mirrored?
      cp_bv2_update_bitmap
    elsif CP::BATTLERS.style4
      if @battler.face_name != @old_face_name ||
         @battler.face_index != @old_face_index
        temp = Cache.face(@battler.face_name)
        face_index = @battler.face_index
        rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
        new_bitmap = Bitmap.new(96, 96)
        new_bitmap.blt(0, 0, temp, rect)
        self.bitmap = new_bitmap
        @old_face_name = @battler.face_name
        @old_face_index = @battler.face_index
        init_visibility
        self.opacity = 1000
      end
    end
  end

  unless method_defined?(:update_sideview_bitmap)
    def update_sideview_bitmap  ## Creates a sideview battler.
      unless @battler.side_battler.empty?
        new_bitmap = Cache.battler(@battler.side_battler, @battler.battler_hue)
        self.mirror = @battler.mirrored?
        if bitmap != new_bitmap
          self.bitmap = new_bitmap
          init_visibility
        end
      else
        if @battler.character_name != @old_char_name ||
           @battler.character_index != @old_char_index
          temp = Cache.character(@battler.character_name)
          sign = @battler.character_name[/^[\!\$]./]
          if sign && sign.include?('$')
            cw = temp.width / 3
            ch = temp.height / 4
          else
            cw = temp.width / 12
            ch = temp.height / 8
          end
          n = @battler.character_index
          src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch + ch, cw, ch)
          new_bitmap = Bitmap.new(cw, ch)
          new_bitmap.blt(0, 0, temp, src_rect)
          self.bitmap = new_bitmap
          @old_char_name = @battler.character_name
          @old_char_index = @battler.character_index
          init_visibility
        end
      end
    end
  end

  alias cp_bv2_update_position update_position
  def update_position  ## Updates position on modes 2-4.
    self.oy = flying_offset
    if @battler.enemy?
      cp_bv2_update_position
      self.y += CP::BATTLERS::Y_OFFSET unless CP::BATTLERS.sideview
      return unless CP::BATTLERS::RESIZE_CORRECTION
      self.y += Graphics.height - 416
      self.x += (Graphics.width - 544) / 2
    else
      return sideview_pos if CP::BATTLERS.sideview && @used_sprite
      return move_style_2 if CP::BATTLERS.style2
      i = $game_party.battle_members.index(@battler)
      l = Graphics.width / $game_party.max_battle_members
      self.x = l * i + l / 2
      self.y = Graphics.height - 12
      self.z = 100
      return if CP::BATTLERS.face
      zoom = CP::BATTLERS::ZOOM.to_f / 100
      self.y = Graphics.height + CP::BATTLERS::Y_PLACEMENT
      self.zoom_x = zoom
      self.zoom_y = zoom
    end
  end

  unless method_defined?(:sideview_pos)
    def sideview_pos
      i = $game_party.battle_members.index(@battler)
      return unless i
      i += 1
      if CP::BATTLERS::SBS_POS.include?(i)
        self.x = CP::BATTLERS::SBS_POS[i][0]
        self.y = CP::BATTLERS::SBS_POS[i][1]
        self.z = 100
      end
    end
  end

  def move_style_2  ## Places blank battlers during mode 2.
    return if @battler.screen_x_pos_bv2.nil?
    return if @battler.screen_y_pos_bv2.nil?
    self.x = @battler.screen_x_pos_bv2
    self.y = @battler.screen_y_pos_bv2
    self.z = 100
  end

  unless $imported["CP_VIEWED"]
    alias cp_bv2_update_effect update_effect
    def update_effect  ## Updates the blinking effect.
      cp_bv2_update_effect
      return if CP::BATTLERS.sideview
      return unless @effect_type.nil?
      if @battler.c_blinking
        update_blinking_effect
      else
        remove_blinking_effect
      end
    end
  end

  def update_blinking_effect  ## Actually does what I said above.
    return if CP::BATTLERS.sideview && @used_sprite
    i = @c_blinking > 40 ? 80 - @c_blinking : @c_blinking
    create_backlit if @backlit_s.nil?
    @backlit_s.opacity = i * 2 + 155
    if @battler_visible
      self.color.set(160, 200, 255, 0)
      self.color.set(255, 120, 120, 0) if @battler.enemy?
      self.color.alpha = i * 2
    end
  end

  def remove_blinking_effect  ## Stops the blinking effect.
    remove_backlit if @backlit_s
    self.color.set(255, 255, 255, 0)
  end

  def create_backlit  ## Creates the backlit sprite.
    @backlit_s = ::Sprite.new(viewport)
    return unless CP::BATTLERS.dated
    return unless width > 0 && height > 0
    @backlit_s.x = x
    @backlit_s.y = y - 10
    @backlit_s.z = z
    @backlit_s.ox = ox
    @backlit_s.oy = oy
    @backlit_s.zoom_x = zoom_x
    @backlit_s.zoom_y = zoom_y
    @backlit_s.opacity = opacity
    @backlit_s.bitmap = Bitmap.new(width, height)
    @backlit_s.bitmap.blt(0, 0, bitmap, src_rect)
    @backlit_s.color.set(255, 255, 200, 255)
    @backlit_s.color.set(255, 160, 160, 255) if @battler.enemy?
  end

  def remove_backlit  ## Removes above sprite.
    @backlit_s.dispose
    @backlit_s = nil
  end
end

class Spriteset_Battle
  alias cp_new_viewports create_viewports
  def create_viewports
    cp_new_viewports  ## Adds a new actor viewport.
    @viewport4 = Viewport.new
    @viewport4.z = 25
    @viewport4.visible = false if CP::BATTLERS.style4
  end

  alias cp_update_viewports_bv2 update_viewports
  def update_viewports  ## Updates the new viewport.
    cp_update_viewports_bv2
    @viewport4.tone.set($game_troop.screen.tone)
    @viewport4.ox = $game_troop.screen.shake if CP::BATTLERS.style3
    @viewport4.update
    update_info_viewport if @info_viewport
  end

  def update_info_viewport  ## Changes the actor viewport during mode 3.
    @viewport4.rect.width = @info_viewport.rect.width
    @viewport4.rect.height = @info_viewport.rect.y + @info_viewport.rect.height
    @viewport4.visible = @window_status.open?
  end

  alias cp_dispose_viewports_bv2 dispose_viewports
  def dispose_viewports  ## Disposes the viewport.
    cp_dispose_viewports_bv2
    @viewport4.dispose
  end

  def create_enemies  ## Tells enemy sprites where viewport 4 is.
    @enemy_sprites = $game_troop.members.reverse.collect do |enemy|
      Sprite_Battler.new(@viewport1, enemy)
    end
    @enemy_sprites.each {|sprite| sprite.viewport4 = @viewport4}
  end

  def create_actors  ## Creates the actor sprites.
    @extra_sprites = []
    @actor_sprites = $game_party.battle_members.collect do |actor|
      create_viewed_battler(actor)
    end
    @actor_sprites.each {|sprite| sprite.viewport4 = @viewport4}
  end

  def create_viewed_battler(actor)
    basic_sprite = Sprite_Battler.new(@viewport4, actor, !CP::BATTLERS.sideview)
    return basic_sprite unless CP::BATTLERS.sideview
    if $imported["CP_VIEWED"]  ## Bookmarked.
      side_sprite = cp_viewed_battler_create ## Used for the later sideview mod.
    else
      side_sprite = Sprite_Battler.new(@viewport1, actor)
    end
    @extra_sprites.push(basic_sprite) if @extra_sprites
    return side_sprite
  end

  alias cp_bv2_dispose_act dispose_actors
  def dispose_actors
    cp_bv2_dispose_act
    @extra_sprites.each {|sprite| sprite.dispose }
  end

  def info(viewport, status)  ## Gets the battle viewports.
    @info_viewport = viewport
    @window_status = status
  end
end

class RPG::BaseItem
  def battler_name
    set_b_name if @battler_name.nil?
    return @battler_name
  end

  def side_battler
    set_b_name if @side_battler.nil?
    return @side_battler
  end

  def hide_hp?
    set_b_name if @hide_hp.nil?
    return @hide_hp
  end

  def hide_mp?
    set_b_name if @hide_mp.nil?
    return @hide_mp
  end

  def hide_tp?
    set_b_name if @hide_tp.nil?
    return @hide_tp
  end

  def sattack_id
    set_b_name if @sattack_id.nil?
    return @sattack_id
  end

  def sdefend_id
    set_b_name if @sdefend_id.nil?
    return @sdefend_id
  end

  def commands
    create_comms if @commands.nil?
    return @commands
  end

  def motion_flying
    set_b_name if @motion_flying.nil?
    return @motion_flying
  end

  def motion_trans
    set_b_name if @motion_trans.nil?
    return @motion_trans
  end

  def motion_mirror
    set_b_name if @motion_mirror.nil?
    return @motion_mirror
  end

  def set_b_name
    @battler_name = "" unless @battler_name
    @side_battler = ""
    @hide_hp = false; @hide_mp = false; @hide_tp = false
    @sattack_id = 0
    @sdefend_id = 0
    @motion_flying = false; @motion_trans = false; @motion_mirror = false
    note.split(/[\r\n]+/).each do |line|
      case line
      when CP::BATTLERS::SIDE
        @side_battler = $1.to_s
      when CP::BATTLERS::NAME
        @battler_name = $1.to_s
      when CP::BATTLERS::HIDE_V
        case $1.to_sym.downcase
        when :hp
          @hide_hp = true
        when :mp
          @hide_mp = true
        when :tp
          @hide_tp = true
        end
      when CP::BATTLERS::ATK_ID
        @sattack_id = $1.to_i
      when CP::BATTLERS::DEF_ID
        @sdefend_id = $1.to_i
      when CP::BATTLERS::TRANS
        @motion_trans = true
      when CP::BATTLERS::FLY
        @motion_flying = true
      when CP::BATTLERS::MIRROR
        @motion_mirror = true
      end
    end
  end

  def create_comms
    @commands = []
    in_comm = false
    note.split(/[\r\n]+/).each do |line|
      case line
      when CP::BATTLERS::COPEN
        in_comm = true
      when CP::BATTLERS::CCLOSE
        in_comm = false
        break
      when CP::BATTLERS::SCOMM
        next unless in_comm
        @commands.push($1.to_sym)
      when CP::BATTLERS::NCOMM
        next unless in_comm
        @commands.push([$1.to_s, $2.to_i])
      end
    end
  end
end

class RPG::Enemy < RPG::BaseItem
  def nattack_id
    set_a_id if @nattack_id.nil?
    return @nattack_id
  end

  def sattack_id
    set_a_id if @sattack_id.nil?
    return @sattack_id
  end

  def sdefend_id
    set_a_id if @sdefend_id.nil?
    return @sdefend_id
  end

  def set_a_id
    @nattack_id = 0
    @sattack_id = 1
    @sdefend_id = 2
    note.split(/[\r\n]+/).each do |line|
      case line
      when CP::BATTLERS::ATTACK
        @nattack_id = $1.to_i
      when CP::BATTLERS::ATK_ID
        @sattack_id = $1.to_i
      when CP::BATTLERS::DEF_ID
        @sdefend_id = $1.to_i
      end
    end
  end
end

class RPG::UsableItem < RPG::BaseItem
  attr_accessor :swap_party

  def cast_anim
    set_cast_anim if @cast_anim.nil?
    return @cast_anim
  end

  def set_cast_anim
    @cast_anim = 0
    note.split(/[\r\n]+/).each do |line|
      case line
      when CP::BATTLERS::CAST
        @cast_anim = $1.to_i
      end
    end
  end
end

class RPG::Weapon < RPG::EquipItem
  def attack_skill
    set_weapon_attack_skill if @attack_skill.nil?
    return @attack_skill
  end

  def set_weapon_attack_skill
    @attack_skill = 0
    note.split(/[\r\n]+/).each do |line|
      case line
      when CP::BATTLERS::ATK_ID
        @attack_skill = $1.to_i
      end
    end
  end
end


###--------------------------------------------------------------------------###
#  End of script.                                                              #
###--------------------------------------------------------------------------###