Side View Battle:Request

Outcast · Mar 23, 2010

Anything Simpler?

Out of 3-4 of the script I found. All had demos, I rifled through said demo's and ALL OF THEM either needed more of another script or some extra sprites with more than what I just basically want. XD

What I wold like is a simple Side view system. Using XP sprites as my battlers, and either the full artwork put into XP already or sprite versions of the enemies.

If noone has or either seen said simplistic battle system, I'm going to have to make my own with events. -_-
(Which I'm really good at.)

action · Mar 23, 2010

Check this one out:
[ Atoa's Custom Battle System ]
Probably the most customizable, and simplest one out there. It doesn't need extra scripts to run, and you can use whatever kind of battle sprites you want, with the right settings.

Hope this helps

-abreaction

Outcast · Mar 24, 2010

It doesn't help me a whole lot.... thanks though.

It just seems to pop up more errors

action · Mar 24, 2010

can I see an example of the battler you are using?

Brewmeister · Mar 25, 2010

Did you try the Super Simple Sideview System?

The only thing you need to do is put the battler images in the battler folder.
If you're using the RTP, simply grab a copy from the RTP (C:\Program Files\Common Files\Enterbrain\RGSS\Standard\Graphics\Characters)
Paste in your projects "Battlers" folder. Then edit the file & crop the image to the first cell in the second row (for Actors), first cell in 3rd row for enemies. i.e.

-------->

Then just assign the battlers in the database (Actors & Enemies tabs), and adjust the enemy positions in the Troops tab

Outcast · Mar 26, 2010

@abreaction

Its not the battler, I added that. Its just something that collides with another script I had put in.

@Brewmeister

Never tried, trying now.

Outcast · Apr 24, 2010

Reply to both

@ first, tried the first, Didn't like, required minkoffish like battlers, I don't have the time to make'em, second, my project is a simple one.

@ Second, re-trying

Atoa · Apr 27, 2010

@Outcast
I think you didn't read the instructions or tested deeply the demo.
The ACBS allows varios types of battler sprites: minkoff, ccoa and even totally custom sprites. Also it allows non animated battlers. just add an "$" on the begin of the filename. Also there's an setting to make enemies and actors don't move.

So, unless you're using another script that is incompatible, i don't see a reason to not use the ACBS.

9robin3 · Apr 27, 2010

Here you go! Cant be simpler: Post this above main in different sections:

Part I:

Code:

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

# ** Animated Battlers - Enhanced   ver. 10.7                      (06-17-2008)

#

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

#  * (1) Configuration:  The Sprite Battler Class (initialize system)

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

 

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

  #   ****                     ARROW CONTROLS                        ****   #

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

  # * Just moves the targetting arrow around

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

  MNK_ARROW_X             = 14      # The x position for your target cursor

  MNK_ARROW_Y             = 10      # The y position for your target cursor

  

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

  #   ****                    GENERAL CONTROLS                       ****   #

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

 

  # * Default Battler Style Switches

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

  DEFAULT_ENEMY           = true   # If true, these switches allows the use

  DEFAULT_ACTOR           = false   # of default battlers for actors/enemies

  DEFAULT_ENEMY_ID        = [1,2,3,4,5,6,7,8,9]     # Ids of enemies using default battlers

  DEFAULT_ACTOR_ID        = [1,2,3,4,5,6,7,8,9]     # Ids of actors using default battlers

  DEFAULT_COLLAPSE_ACTOR  = false   # If true, restores the old 'red fade'

  DEFAULT_COLLAPSE_ENEMY  = false   #   collapse effect (using spritesheets)

 

  

  # * Animation Frames and Animation Speed

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

  MNK_SPEED               = 5       # Framerate speed of the battlers

  MNK_RUSH_SPEED          = 1.5     # Melee/Skill/Item motion speed of the battlers

  MNK_POSES               = 11      # Maximum # of poses (stances) in the template

  MNK_FRAMES              = 4       # Maximum # of frames in each pose

  MNK_FRAMES_STANDARD     = 4       # Standard # of frames played in each pose.

  

  # Individual Spritesheet Control Center

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

  MNK_POSES_ENEMY         = {1 => 4}  # ID and # of poses for each enemy

  MNK_FRAMES_ENEMY        = nil       # ID and # of frames for each enemy

  MNK_POSES_ACTOR         = {2 => 4}  # ID and # of poses for each actor

  MNK_FRAMES_ACTOR        = nil       # ID and # of frames for each actor.

      

  # * Wooziness Rates

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

  MNK_LOW_HP_PERCENTAGE   = 0.25                    # Health% for WOOZY pose.

  MNK_LOW_HP_ACTOR        = {7 => 0.50, 8 => 0.75}  # Ind. health% for actors.

  MNK_LOW_HP_ENEMY        = {1 => 0.50}             # Ind. health% for enemies.

  MNK_LOW_HP_FLAT         = true                    # If true, flat rate hp

  

    

    

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

  #   ****                   POSE CONTROL CENTER                     ****   #

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

    

  # Editable Template (Some people wanted to change their template design)

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

  MNK_POSE1   =   1   # Sets the 'Ready Pose'  (MNK_POSE1)   #1 in your template

  MNK_POSE2   =   2   # Sets the 'Struck Pose' (MNK_POSE2)   #2 in your template

  MNK_POSE3   =   3   # Sets the 'Woozy Pose'  (MNK_POSE3)   #3 in your template

  MNK_POSE4   =   4   # Sets the 'Block Pose'  (MNK_POSE4)   #4 in your template

  MNK_POSE5   =   5   # Sets the 'Charge Pose' (MNK_POSE5)   #5 in your template

  MNK_POSE6   =   6   # Sets the 'Retreat Pose'(MNK_POSE6)   #6 in your template

  MNK_POSE7   =   7   # Sets the 'Attack Pose' (MNK_POSE7)   #7 in your template

  MNK_POSE8   =   8   # Sets the 'Item Pose'   (MNK_POSE8)   #8 in your template

  MNK_POSE9   =   9   # Sets the 'Skill Pose'  (MNK_POSE9)   #9 in your template

  MNK_POSE10  =  10   # Sets the 'Victory Pose'(MNK_POSE10) #10 in your template

  MNK_POSE11  =  11   # Sets the 'Defeat Pose' (MNK_POSE11) #11 in your template

    

  # Editable Template (for Custom Actor Spritesheets)

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

  MNK_APOSE1   =   {2 => 2} 

  MNK_APOSE2   =   {2 => 2}   # Hilda is using a Charset graphic as a battler.

  MNK_APOSE3   =   {2 => 2}   # The battler was copied into the Battler folder.

  MNK_APOSE4   =   {2 => 2}   # This setup allows you to use Charactersets for 

  MNK_APOSE5   =   {2 => 2}   # battlers battlers.

  MNK_APOSE6   =   {2 => 3} 

  MNK_APOSE7   =   {2 => 2} 

  MNK_APOSE8   =   {2 => 2} 

  MNK_APOSE9   =   {2 => 2} 

  MNK_APOSE10  =   {2 => 1} 

  MNK_APOSE11  =   {2 => 4} 

    

  # Editable Template (for Custom Enemy Spritesheets)

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

  MNK_EPOSE1   =   {1 => 2} 

  MNK_EPOSE2   =   {1 => 2}   # Did the same to the ghosts.  Note that enemies have

  MNK_EPOSE3   =   {1 => 2}   # no victory pose.

  MNK_EPOSE4   =   {1 => 2}   

  MNK_EPOSE5   =   {1 => 2}   

  MNK_EPOSE6   =   {1 => 3} 

  MNK_EPOSE7   =   {1 => 2} 

  MNK_EPOSE8   =   {1 => 2} 

  MNK_EPOSE9   =   {1 => 2} 

  MNK_EPOSE11  =   {1 => 11}  # Setting the ghost to an invalid pose erases it.

                        

                        

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

  #   ****               EXPANDED POSE CONTROL CENTER                ****   #

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

  

  # Non-Default Poses (can expand beyond the default 11 poses here)

  # (New system mimics the revised Template system.  Can use 'custom' sheets)

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

  # The first value in each set indicates the index number  in a spritesheet.

  # This value is  overrided by a value  in one of the other two accompanying

  # arrays... one for actor battlerss, the other for enemy battlers.

  #

  # To define a pose linked to a specific battler, the syntax is...

  # '' hash array '' = { battler.id => pose# }

  # Where Aluxes and the Ghost (RTP)  would be  the 1st battlers (per array),

  # and the pose# would be the pose in your spritesheet.

  #

  # Combinations in the  hash arrays  are possible,  so if the MNK_POSES_DYING_E

  # array has {1 => 5, 9 => 2},  then the GHOST (enemy #1) would be using the

  # 6th pose (index 5) and the 9th enemy battler would be using the 3rd pose.

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

  MNK_POSES_SETUP       = 7          # Choose animation pose for 'preparation'

  MNK_POSES_SETUP_A     = {2 => 4}

  MNK_POSES_SETUP_E     = {1 => 4}    

  MNK_POSES_CASTPREP    = 4          # Set 'casting' pose for skill preparation

  MNK_POSES_CASTPREP_A  = {}          

  MNK_POSES_CASTPREP_E  = {9 => 3}    

  MNK_POSES_DYING       = 6          # Choose animation pose for dying throws.

  MNK_POSES_DYING_a     = {}          

  MNK_POSES_DYING_E     = {9 => 5}    

  MNK_POSES_ESCAPE      = 2          # Set 'coward' pose for fleeing monsters)    

  MNK_POSES_ESCAPE_A    = {}         

  MNK_POSES_ESCAPE_E    = {9 => 5}   

  MNK_POSES_CRITICAL    = nil        # Set pose for BIG hits 

  MNK_POSES_CRIT_A      = {}

  MNK_POSES_CRIT_E      = {9 =>5}

  MNK_POSES_WINNING     = 4          # Set winning (Victory Dance before pose)

  MNK_POSES_WINNING_A   = {}

  MNK_POSES_WINNING_E   = {}         

  

  # Looping Poses

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

  # These arrays merely hold the ID  of actors or enemies whose poses loop at

  # the end of combat.  Enemies have no 'winning' animation pose.

  MNK_LOOPS_WINNING         = [7]     # Actor IDs if their victory pose loops

  MNK_LOOPS_DEFEATED_ACTOR  = []      # Actor IDs if their defeat pose loops

  MNK_LOOPS_DEFEATED_ENEMY  = []      # Enemy IDs if their defeat pose loops

    

  # Non-Default Pose Hashes (poses dependant on .id values)

  # (New system mimics the revised Template system.)

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

  # The first hash in each set  indicates the id number (be it skill, item or

  # otherwise, and the pose it brings up.   These mimic the 2nd array type in

  # the above Non-Default poses.   As such, a hash value of {1 => 10) for the

  # MNK_POSES_WEAPONS hash would make  the 'Bronze Sword' use the 10th index (or

  # 11th spritesheet) pose... aka the 'Defeat' pose.

  #

  # To define an advanced pose linked to a specific battler, the syntax is...

  #  = { battler.id => { item/skill.id => pose#  } }

  # ...so this gets  more complicated.   But this does allow  each battler to

  # have his or her own unique pose, regardless of spritesheet type.

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

  MNK_POSES_CASTED     = {61 => 6}  # Set a specific skill to use a pose

  MNK_POSES_CASTED_A   = {}         

  MNK_POSES_CASTED_E   = {}

  MNK_POSES_STATUS     = {3 => 3}   # Set status values to poses here

  MNK_POSES_STAT_A     = {}  

  MNK_POSES_STAT_E     = {}

  MNK_POSES_SKILLS     = {57 => 7}  # Default: #57(Cross Cut) does 'Attack'

  MNK_POSES_SKILLS_A   = {}  

  MNK_POSES_SKILLS_E   = {}

  MNK_POSES_ITEMS      = {13 => 4}  # Default: #13(Sharp Stone) does 'Block'

  MNK_POSES_ITEMS_A    = {}         

  MNK_POSES_ITEMS_E    = {}         

  MNK_POSES_WEAPONS    = {}         # Didn't set any weapons to any poses

  MNK_POSES_WEAPS_A    = {}

  MNK_POSES_WEAPS_E    = {}         # Non-functional (Enemies don't use 'em.)

  

  # Non-Default Pose Hashes (Hits & Critical Hits)

  # (Just like above, but pertains to specific hits and critical hits)

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

  MNK_STRUCK_WEAPS     = {}         # Set a specific 'Struck' to a weapon attack

  MNK_STRUCK_WEAPS_A   = {}         

  MNK_STRUCK_WEAPS_E   = {}         

  MNK_STRUCK_SKILLS    = {}         # Set a specific 'Struck' to a skill

  MNK_STRUCK_SKILLS_A  = { 7 => { 7 => 4 }}

  MNK_STRUCK_SKILLS_E  = {}

  MNK_STRUCK_ITEMS     = {}         # Set a specific 'Struck' to an item attack

  MNK_STRUCK_ITEMS_A   = {}

  MNK_STRUCK_ITEMS_E   = {}

  MNK_CRIT_WEAPS       = {}         # Set a specific 'Critical Hit' to a weapon

  MNK_CRIT_WEAPS_A     = {}

  MNK_CRIT_WEAPS_E     = {}       

  MNK_CRIT_SKILLS      = {}         # Set a specific 'Critical Hit' to a skill

  MNK_CRIT_SKILLS_A    = {7 => {7 => 10 }, 5 => {7 => 7}}

  MNK_CRIT_SKILLS_E    = {}

  MNK_CRIT_ITEMS       = {}         # Set a specific 'Critical Hit' to an item

  MNK_CRIT_ITEMS_A     = {}

  MNK_CRIT_ITEMS_E     = {}

 

    

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

  #   ****                   FRAME CONTROL CENTER                    ****   #

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

 

  # * Frames Control 

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

  MNK_FRAMES_PER_POSE    = {}               # Set #of frames to pose(by index)

 

  # Advanced Individual Pose/Frame Hashes   # Advanced Individual Poses  uses

                                            # hashes within hashes. As a demo 

  MNK_POSES_FR_ACTOR = {}                   # you can see that enemy #1 has 2

  MNK_POSES_FR_ENEMY = {}                   # sets of controls:  index 0 (for

                                            # a ready pose is set to 1 frame,

  # while index 3 (block) is set to 'two' frames.   Likewise, for the actor's

  # hash, Actor #7 (Gloria) has only 1 control hash.   It sets index pose '0' 

  # (the ready pose again) to use four frames of animation (even though I had

  # set the ready pose to just use '2' with the MNK_FRAMES_PER_POSE hash earlier.

 

  

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

  #   ****                   MOVEMENT CONTROL CENTER                 ****   #

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

      

  # * Offset / Battler Overlap System

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

  MNK_OFFSET            = 0       # How much additional space between battlers

  MNK_OFFSET_ACTOR      = {1 => -50}

  MNK_OFFSET_ENEMY      = nil

  

  # * Forward Step System (Final Fantasy-Style)

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

  MNK_STEP_ATTACK       = false   # If true, battler steps forward to attack

  MNK_STEP_SKILL        = true    # If true, battler steps forward to use skill

  MNK_STEP_ITEM         = true    # If true, battler steps forward to use item

    

  # * Movement Arrays (Arrays for skill/weapon/item IDs that affect movement)

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

  MNK_MOVING_ITEM       = [1]     # Examples are items that need to be applied.

  MNK_MOVING_SKILL      = [61]    # Examples are martial-arts and sneak attacks

  MNK_MOVE2CENTER_ATK   = []      # Moves battler to center based on weapon id!

  MNK_MOVE2CENTER_ITEM  = [5]     # Moves battler to center for a big item atk!

  MNK_MOVE2CENTER_SKILL = [7]     # Moves battler to center for a big skill atk!

  #

  # * Remember, do not supply Skill or Item ID#'s that have 'None' scopes into

  #   either the MNK_MOVING_ITEM or MNK_MOVING_SKILL hashes.  These skills &

  #   item attacks have no target and would cause an error when trying to find

  #   an enemy to move towards.

 

 

    

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

  #   ****                STATIONARY CONTROL CENTER                  ****   #

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

  

  # * Stationary Battlers (simple True/False settings)

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

  MNK_STATIONARY_ENEMIES = false    # If the enemies don't move while attacking

  MNK_STATIONARY_ACTORS  = false    # If the actors don't move while attacking

  

  # * Arrays filled with skill/weapon/item IDs that halt movement 

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

  MNK_STATIONARY_ENEMY_IDS = []       # Enemies that don't RUN during melee attacks

  MNK_STATIONARY_WEAPONS = [17,18,19,20,21,22,23,24] # (examples are bows & guns)

  MNK_STATIONARY_SKILLS  = []       # (examples are bows & guns)

  MNK_STATIONARY_ITEMS   = []       # (examples are bows & guns)

 

 

    

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

  #   ****               TRANSPARENCY CONTROL CENTER                 ****   #

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

  MNK_TRANSLUCENCY      = 300      # Degree of transparency

  MNK_TRANSLUCENT_ACTOR = []       # ID of actor at translucency settings

  MNK_TRANSLUCENT_ENEMY = [1, 9]   # ID of enemy at translucency settings

  MNK_PHASING           = true     # If battlers fade in/out while charging

  MNK_PHASING_ACTOR     = [1, 2]   # IDs of actors that fade in/out if charging

  MNK_PHASING_ENEMY     = [9]      # IDs of enemies that fade in/out if charging

 

  MNK_FADE_IN           = true     # Battler fades in if replaced or transparent

 

    

    

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

  #   ****                CUSTOM FEATURE CENTER                      ****   #

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

        

  MNK_MIRROR_ENEMIES    = false    # Enemy battlers use reversed image

  MNK_CALC_SPEED        = false    # System calculates a mean/average speed

  MNK_AT_DELAY          = true     # Pauses battlesystem until animation done.

  MNK_ADV_OFF_TURN      = 1        # Number of turns before enemies turn

Part II:

Code:

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

# ** Animated Battlers - Enhanced   ver. 10.7                      (06-17-2008)

#

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

#  * (2) Sprite System:  The Sprite Battler Class

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

 

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

# ** Sprite_Battler

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

#  This sprite is used to display the battler.It observes the Game_Character

#  class and automatically changes sprite conditions.

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

 

class Sprite_Battler < RPG::Sprite  

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

  # * Public Instance Variables

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

  attr_accessor :battler_offset         # Degree of action forcing  

  attr_accessor :skill_used             # Degree of action forcing  

  attr_accessor :item_used              # Degree of action forcing  

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

  # * Object Initialization

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

  alias mnk_init initialize 

  def initialize(viewport, battler = nil)

    # --Initialize poses

    @frame, @pose, @last_time, @last_move_time  = 0, 0, 0, 0

    # --Initialize Battler placement and pose types

    @battler_offset, @skill_used, @item_used    = 0, 0, 0

    # --Initialize Boolean values

    @statusd              = false

    @dying                = true

    @s_pose               = false

    $game_system.victory  = false

    $game_system.defeat   = false

    @winning              = true

    # ORIGINAL Initialize call

    mnk_init(viewport, battler)

    # EVENT VALUE CALLS

    # --Obtain the Sideview switch

    $game_system.sv_angle = $sideview_mirror

    $game_system.sv_angle = 0 if $sideview_mirror == nil

    # -- Obtain the max party size

    $game_system.max_member = $formation_max_member

    $game_system.max_member = 4 if $formation_max_member == nil

    # --Obtain the highest position for the formation

    $game_system.form_top = $formation_max_height

    $game_system.form_top = 220 if $formation_max_height == nil

    # --Obtain the formation's width

    $game_system.form_wd = $formation_max_width

    $game_system.form_wd = 128 if $formation_max_width == nil

    # --Obtain the height of the Battlestatus Window

    $game_system.bstat_ht = $battlestatus_height

    $game_system.bstat_ht = 160 if $battlestatus_height == nil

  end

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

  # * Update

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

  alias mnk_update update

  def update

 

    # Only perform sprite edit for valid battlers

    return unless @battler

    if @battler.battler_name != @battler_name

      @started = false

    end    

 

    # Regular Update

    mnk_update

 

    # Set Translucency  

    if @battler.is_a?(Game_Enemy)

      battler_translucency(@battler, MNK_TRANSLUCENT_ENEMY)

    else

      battler_translucency(@battler, MNK_TRANSLUCENT_ACTOR)

    end

    # Reset hash for Advanced Pose/Frames

    pose_temp = {}

    

    # Start Routine (Performed at startup for each battler)

    unless @started

      # Set the pose based on battler's state

      @pose = state

      # Turn off Casting pose

      @battler.casted  = false

      @battler.casting = false

      # Configure Enemy Spritesheet

      if @battler.is_a?(Game_Enemy) 

        # Use spritesheet unless specified

        unless DEFAULT_ENEMY or DEFAULT_ENEMY_ID.include?(@battler.id)

          @width  = @width  / cell_divider(MNK_FRAMES_ENEMY,  MNK_FRAMES) 

          @height = @height / cell_divider(MNK_POSES_ENEMY,   MNK_POSES)

        end

      # Or Configure Actor Spritesheet

      else  

        # Use spritesheet unless specified

        unless DEFAULT_ACTOR or DEFAULT_ACTOR_ID.include?(@battler.id)

          @width  = @width  / cell_divider(MNK_FRAMES_ACTOR,  MNK_FRAMES)

          @height = @height / cell_divider(MNK_POSES_ACTOR,   MNK_POSES)

        end

      end

      # Distance the battlers

      @battler_offset = @width * 0.75

      # Obtain battler position (simulating 3-Dness)

      @display_x = @battler.screen_x

      @display_y = @battler.screen_y

      @display_z = @battler.screen_z

      @destination_x = @display_x

      @destination_y = @display_y

      @destination_z = @display_z

      # Opacity fadein feature

      self.opacity = 0 if MNK_FADE_IN

      # Make invisible if dead at battle start

      self.visible = false if @battler.dead?

      # Set the started flag

      @started = true

    # End of Start Routine (for each battler)  

    end

    

    # Again, ensure a pose is set

    @pose = state if @pose == nil

 

    # Obtain animation cell/frame from Enemy

    if @battler.is_a?(Game_Enemy)

      # Use spritesheet cell unless specified

      unless DEFAULT_ENEMY or DEFAULT_ENEMY_ID.include?(@battler.id)

        cell_obtain

      else

        self.src_rect.set(0, 0, @width, @height)

      end

    # Or get it from an actor  

    else

      # Use spritesheet cell unless specified

      unless DEFAULT_ACTOR or DEFAULT_ACTOR_ID.include?(@battler.id)

        cell_obtain

      else

        self.src_rect.set(0, 0, @width, @height)

      end

    end

    

    # Position Sprite 

    self.x = @display_x

    self.y = @display_y

    self.z = @display_z

    self.ox = @width / 2

    self.oy = @height

    

    #  Party Turned Around

    #  $game_temp.advantage_set == 6

    

    # Adjust sprite direction if facing the other way...

    if $game_system.sv_angle == 1

      if @battler.is_a?(Game_Actor)

        mirror_pose_unless(6)

      else

        if MNK_MIRROR_ENEMIES

          mirror_pose_if(5)

        else

          mirror_pose_unless(5)

        end

      end

    else

      if @battler.is_a?(Game_Actor)

        mirror_pose_if(6)

      else

        if MNK_MIRROR_ENEMIES

          mirror_pose_unless(5)

        else

          mirror_pose_if(5)

        end

      end

    end

    

    # Setup Frames per Pose

    poseframe = MNK_FRAMES_STANDARD

    if @battler.is_a?(Game_Actor)

      poseframe = cell_divider(MNK_FRAMES_ACTOR,  MNK_FRAMES_STANDARD) if cell_divider(MNK_FRAMES_ACTOR,  MNK_FRAMES_STANDARD) != nil

    else

      poseframe = cell_divider(MNK_FRAMES_ENEMY,  MNK_FRAMES_STANDARD) if cell_divider(MNK_FRAMES_ENEMY,  MNK_FRAMES_STANDARD) != nil

    end 

    pose_chk = 0

    pose_chk = @pose+1 if @pose != nil

    poseframe = MNK_FRAMES_PER_POSE[pose_chk] if MNK_FRAMES_PER_POSE.include?(pose_chk)

    # Set Advanced Poses for Actors

    if @battler.is_a?(Game_Actor)

      pose_temp = MNK_POSES_FR_ACTOR[@battler.id] if MNK_POSES_FR_ACTOR.include?(@battler.id)

      poseframe = pose_temp[pose_chk] if pose_temp.include?(pose_chk)

    end    

    # Set Advanced Poses for Enemies

    if @battler.is_a?(Game_Enemy)

      pose_temp = MNK_POSES_FR_ENEMY[@battler.id] if MNK_POSES_FR_ENEMY.include?(@battler.id)

      poseframe = pose_temp[pose_chk] if pose_temp.include?(pose_chk)

    end

    

    # Make visible if returned to life

    unless @battler.dead?

      self.visible = true if @pose == pose_obtain(MNK_POSE1, MNK_APOSE1, MNK_EPOSE1)

      @freeze = false unless $game_system.victory

    end

 

    # Setup Animation 

    time = Graphics.frame_count / (Graphics.frame_rate / MNK_SPEED)

    if @last_time < time

      @frame = (@frame + 1) % poseframe

      if @frame == 0

        if @freeze

          @frame = poseframe - 1

          return

        end

        @pose = state

      end

    end

    @last_time = time

    

    # Setup Dying Animation

    if @battler.dead?

      if @dying == true

        @pose = state

        @dying = false

      end

    # Otherwise, all non-dead actions...  

    else

      # Setup/Ready for Battle (Let's get ready to RUMBLE!)

      if @s_pose == false

        tmp_pose = pose_obtain(MNK_POSES_SETUP, MNK_POSES_SETUP_A, MNK_POSES_SETUP_E)

        if tmp_pose != nil

          @pose = tmp_pose

          @s_pose = true            

        end

      end

      # If Victory pose (Who's your daddy?) 

      if @battler.is_a?(Game_Actor)

        if $game_system.victory == true

          if @winning == true

            @pose = state

            @winning = false

          end

        end

      end

    end

    

    # Move It

    move if moving

  end

  

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

  # * Current State

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

  def state

    # Reset Statusd Flag    

    @statusd = false

    

    # Set Translucency if not dead

    unless @battler.dead?

      if @battler.is_a?(Game_Actor)

        battler_translucency(@battler, MNK_TRANSLUCENT_ACTOR)

      else

        battler_translucency(@battler, MNK_TRANSLUCENT_ENEMY)

      end

    end

    

    # Damage State

    if [nil,{}].include?(@battler.damage)

      # Battler Fine

      state = pose_obtain(MNK_POSE1, MNK_APOSE1, MNK_EPOSE1)

      # Battler Wounded

      temp_woozy = MNK_LOW_HP_PERCENTAGE

      if @battler.is_a?(Game_Actor)

        temp_woozy = MNK_LOW_HP_ACTOR[@battler.id] if MNK_LOW_HP_ACTOR[@battler.id] != nil

      end

      if @battler.is_a?(Game_Enemy)

        temp_woozy = MNK_LOW_HP_ENEMY[@battler.id] if MNK_LOW_HP_ENEMY[@battler.id] != nil

      end

      # If Set to Flat Rate

      if MNK_LOW_HP_FLAT

        if @battler.hp < temp_woozy

          state = pose_obtain(MNK_POSE3, MNK_APOSE3, MNK_EPOSE3)

          @statusd = true

        end

      # Otherwise, use percentage of battler's health

      else

        if @battler.hp < @battler.maxhp * temp_woozy

          state = pose_obtain(MNK_POSE3, MNK_APOSE3, MNK_EPOSE3)

          @statusd = true

        end

      end

      # Battler Status-Effect

      for i in @battler.states

        tmp_pose2 = pose_array_obtain(MNK_POSES_STATUS, MNK_POSES_STAT_A, MNK_POSES_STAT_E, i)

        state = tmp_pose2 if tmp_pose2 != nil

        @statusd = true if tmp_pose2 != nil

      end

      # If Battler Dead

      if @battler.dead? 

        # If using default battlers or default collapse

        if (DEFAULT_COLLAPSE_ACTOR and @battler.is_a?(Game_Actor)) or

          (DEFAULT_COLLAPSE_ENEMY and @battler.is_a?(Game_Enemy)) or

          (DEFAULT_ACTOR and @battler.is_a?(Game_Actor)) or

          (DEFAULT_ENEMY and @battler.is_a?(Game_Enemy)) or

          (DEFAULT_ENEMY_ID.include?(@battler.id) and @battler.is_a?(Game_Enemy)) or

          (DEFAULT_ACTOR_ID.include?(@battler.id) and @battler.is_a?(Game_Actor))

          # Do absolutely nothing :)

        else

          # Dying Animation pose

          if @dying == true

            tmp_pose = pose_obtain(MNK_POSES_DYING, MNK_POSES_DYING_a, MNK_POSES_DYING_E)

            if tmp_pose != nil

              state = tmp_pose

            else

              state = dying_pose

            end  

          else

            state = dying_pose

          end

          

          # Fix Opacity

          if @battler.is_a?(Game_Enemy) 

            if MNK_TRANSLUCENT_ENEMY.include?(@battler.id)

              set_translucency(@battler, MNK_TRANSLUCENCY)

            else

              set_translucency(@battler, 255)

            end

          else

            if MNK_TRANSLUCENT_ACTOR.include?(@battler.id)

              set_translucency(@battler, MNK_TRANSLUCENCY)

            else

              set_translucency(@battler, 255)

            end

          end

        end

      end

    end

   

    # Casting State 

    if @battler.casted

      state = casting_pose if $game_system.mnk_det_para_spell and @battler.spelling?

      state = casting_pose if $game_system.mnk_det_sd_casting and @battler.sd_casting

      state = casting_pose if $game_system.mnk_det_rtab_systm and @battler.rtp != 0

    end

    

    # Victory State

    if @battler.is_a?(Game_Actor)

      if $game_system.victory

        if not @battler.dead?

          if @winning == true

            # A Pre-Winning Pose display

            if MNK_POSES_WINNING != nil

              tmp_pose = pose_obtain(MNK_POSES_WINNING, MNK_POSES_WINNING_A, MNK_POSES_WINNING_E)

              state = tmp_pose if tmp_pose != nil

            end

          else

            # Final Pose

            state = victory_pose

          end

        else

          # Final Pose

          state = victory_pose

        end        

      end

    # Perform check for Enemies  

    else

      if $game_system.defeat

        if not @battler.dead?

          if @winning == true

            if MNK_POSES_WINNING != nil

              tmp_pose = pose_obtain(MNK_POSES_WINNING, MNK_POSES_WINNING_A, MNK_POSES_WINNING_E)

              state = tmp_pose if tmp_pose != nil

            end

          else

            # Final Pose

            state = victory_pose

          end

        else

          # Final Pose

          state = victory_pose

        end        

      end

    end

    

    # Guarding State (not if dead OR in victory)

    if not @battler.dead?

      if not $game_system.victory

        if @statusd == false 

          state = pose_obtain(MNK_POSE4, MNK_APOSE4, MNK_EPOSE4) if @battler.guarding?

        end

      end

    end

    # Moving State 

    if moving

    # Adjust sprite direction if facing the other way...

      if $game_system.sv_angle == 1

        # If enemy battler moving

        if @battler.is_a?(Game_Enemy) 

          # Battler Moving Left

          state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(0)

          # Battler Moving Right

          state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(1)

        # Else actor battler moving

        else

          # Battler Moving Left

          state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(0)

          # Battler Moving Right

          state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(1)

        end

      else      

        # If enemy battler moving

        if @battler.is_a?(Game_Enemy) 

          # Battler Moving Left

          state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(0)

          # Battler Moving Right

          state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(1)

        # Else actor battler moving

        else

          # Battler Moving Left

          state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(0)

          # Battler Moving Right

          state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(1)

        end

      end

    end

    # Return State

    return state

  end

  

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

  # * Move

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

  def move

    time = Graphics.frame_count / (Graphics.frame_rate.to_f / (MNK_SPEED * 5))

    

    if @last_move_time < time

      # Pause for Animation

      return if @pose != state

        # The standard 'full' opacity

        opa = 255

        if @battler.is_a?(Game_Enemy) and MNK_TRANSLUCENT_ENEMY.include?(@battler.id)

          opa = MNK_TRANSLUCENCY

        end

        if @battler.is_a?(Game_Actor) and MNK_TRANSLUCENT_ACTOR.include?(@battler.id)

          opa = MNK_TRANSLUCENCY

        end

  

      # Phasing

      self.opacity = phasing(opa)   if MNK_PHASING

      if @battler.is_a?(Game_Actor)

        self.opacity = phasing(opa) if MNK_PHASING_ACTOR.include?(@battler.id)

      else      

        self.opacity = phasing(opa) if MNK_PHASING_ENEMY.include?(@battler.id)

      end

      

      # Calculate Difference

      difference_x = (@display_x - @destination_x).abs

      difference_y = (@display_y - @destination_y).abs

      difference_z = (@display_z - @destination_z).abs  

      # Done? Reset, Stop

      if [difference_x, difference_y].max.between?(0, 8)

        @display_x = @destination_x

        @display_y = @destination_y

        @display_z = @destination_z

        @pose = state

        return

      end

      

      # Calculate Movement Increments

      increment_x = increment_y = 1

      if difference_x < difference_y

        increment_x = 1.0 / (difference_y.to_f / difference_x)

      elsif difference_y < difference_x

        increment_y = 1.0 / (difference_x.to_f / difference_y)

      end

      increment_z = increment_y

  

      # Calculate Movement Speed 

      if MNK_CALC_SPEED

        total = 0; $game_party.actors.each{ |actor| total += actor.agi }

        speed = @battler.agi.to_f / (total / $game_party.actors.size)

        increment_x *= speed

        increment_y *= speed

        increment_z *= speed

      end

      

      # Multiply and Move

      multiplier_x = MNK_RUSH_SPEED * (@destination_x - @display_x > 0 ? 8 : -8)

      multiplier_y = MNK_RUSH_SPEED * (@destination_y - @display_y > 0 ? 8 : -8)

      multiplier_z = MNK_RUSH_SPEED * (@destination_z - @display_z > 0 ? 8 : -8)      

      @display_x += (increment_x * multiplier_x).to_i

      @display_y += (increment_y * multiplier_y).to_i

      @display_z += (increment_z * multiplier_z).to_i

      

    end

    @last_move_time = time

  end

  

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

  # * Set Movement

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

  def setmove(destination_x, destination_y, destination_z)

    unless (@battler.is_a?(Game_Enemy) and MNK_STATIONARY_ENEMIES) or

           (@battler.is_a?(Game_Actor) and MNK_STATIONARY_ACTORS)

      unless MNK_STATIONARY_WEAPONS.include?(@battler.weapon_id) or

             MNK_STATIONARY_SKILLS.include?(@skill_used) or

             MNK_STATIONARY_ITEMS.include?(@item_used)

        @original_x = @display_x

        @original_y = @display_y

        @original_z = @display_z          

        @destination_x = destination_x

        @destination_y = destination_y

        @destination_z = destination_z

      end

    end

  end

  

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

  # * Movement Check

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

  def moving

    if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)

      return (@display_x > @destination_x ? 0 : 1)

    end

  end

  

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

  # * Set Pose

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

  def pose=(pose)

    @pose = pose

    @frame = 0

  end

  

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

  # * Freeze

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

  def freeze

    @freeze = true

  end

  

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

  # * Fallen Pose

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

  if @derv_anim_bat_stack.nil?

    @derv_anim_bat_stack = true

    alias mnk_collapse collapse

    def collapse

      if @battler.is_a?(Game_Actor)

        mnk_collapse if DEFAULT_ACTOR

        mnk_collapse if DEFAULT_COLLAPSE_ACTOR

        if DEFAULT_ACTOR_ID != nil

          mnk_collapse if DEFAULT_ACTOR_ID.include?(@battler.id)

        end

      else

        mnk_collapse if DEFAULT_ENEMY

        mnk_collapse if DEFAULT_COLLAPSE_ENEMY

        if DEFAULT_ENEMY_ID != nil

          mnk_collapse if DEFAULT_ENEMY_ID.include?(@battler.id)

        end

      end

    end

  end

 

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

  # * Phasing / Vanishing

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

  def phasing(opa)

    d1 = (@display_x - @original_x).abs

    d2 = (@display_y - @original_y).abs

    d3 = (@display_x - @destination_x).abs

    d4 = (@display_y - @destination_y).abs

    return [opa - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max

  end

  

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

  # * Mirror Pose If...

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

  def mirror_pose_if(adv_value)

    if $game_temp.advantage_set == adv_value

      self.mirror = true

    else

      self.mirror = false

    end

  end

 

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

  # * Mirror Pose Unless...

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

  def mirror_pose_unless(adv_value)

    unless $game_temp.advantage_set == adv_value

      self.mirror = true

    else

      self.mirror = false

    end

  end

  

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

  # * Casting Pose

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

  def casting_pose

    tmp_pose = pose_obtain(MNK_POSES_CASTPREP, MNK_POSES_CASTPREP_A, MNK_POSES_CASTPREP_E)

    tmp_pose2 = pose_array_obtain(MNK_POSES_CASTED, MNK_POSES_CASTED_A, MNK_POSES_CASTED_E, @battler.skill_casted)

    tmp_pose = tmp_pose2 if tmp_pose2 != nil

    state = tmp_pose if tmp_pose != nil

    return state

  end

 

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

  # * Final Victory Pose

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

  def victory_pose

    tmp_pose = MNK_POSE10-1

    tmp_pose = MNK_APOSE10[@battler.id]-1 if MNK_APOSE10[@battler.id] != nil

    if not MNK_LOOPS_WINNING.include?(@battler.id)

      @freeze = true

    end

    return tmp_pose

  end

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

  # * Final Victory Pose

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

  def dying_pose

    state = pose_obtain(MNK_POSE11, MNK_APOSE11, MNK_EPOSE11)

    if @battler.is_a?(Game_Actor)

      @freeze = true if not MNK_LOOPS_DEFEATED_ACTOR.include?(@battler.id)

    else

      @freeze = true if not MNK_LOOPS_DEFEATED_ENEMY.include?(@battler.id)

    end

    return state

  end  

  

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

  # * Battler Translucency

  #     battler            : actor or enemy battler

  #     battler_trans      : translucency array for battler

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

  def battler_translucency(battler, battler_trans)

    tcheck = {}

    tcheck = battler_trans

    set_translucency(battler, MNK_TRANSLUCENCY) if tcheck.include?(battler.id)

  end

  

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

  # * Set Translucency

  #     battler            : actor or enemy battler

  #     trans_level        : translucency level

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

  def set_translucency(battler, trans_level)

    if battler.hidden

      self.opacity  = 0

    else

      self.opacity  = MNK_TRANSLUCENCY

    end

  end

    

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

  # * Cell Divider

  #     divider_check      : array to divide cells by custom actor or enemy

  #     divider_standard   : standard number to divide by

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

  def cell_divider(divider_check, divider_standard)

    dcheck = {}

    divided_cell = divider_standard

    dcheck = divider_check

    if dcheck != nil

      if dcheck.include?(@battler.id)

        divided_cell = dcheck[@battler.id] if dcheck[@battler.id] != nil

      end

    end

    return divided_cell        

  end

  

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

  # * Obtain Individual Cell

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

  def cell_obtain

    # Only permit for valid poses & frames

    if @pose != nil

      if @frame != nil

        self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

      end

    end

  end

  

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

  # * Obtain Pose

  #     pose_base   : default pose to return

  #     pose_actor  : list of poses for actors

  #     pose_enemy  : list of poses for enemies

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

  def pose_obtain(pose_base, pose_actor, pose_enemy)

    # create Arrays

    pos_a = {}

    pos_e = {}

    # fill created Arrays & Set pose

    pos_a = pose_actor

    pos_e = pose_enemy

    pose_now = pose_base

    # Obtain pose if not a standard pose

    if @battler.is_a?(Game_Actor)

      pose_now = pos_a[@battler.id] if pos_a[@battler.id] != nil

    else

      pose_now = pos_e[@battler.id] if pos_e[@battler.id] != nil

    end

    # Return the final pose (minus 1 for neceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

  

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

  # * Obtain Pose from hashes

  #     hash_base   : hash with default poses

  #     hash_actor  : advanced list of poses for actors

  #     hash_enemy  : advanced list of poses for enemies

  #     condition   : value determining where to get the final pose

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

  def pose_array_obtain(hash_base, hash_actor, hash_enemy, condition)

    # create Arrays

    hash_b    = {}

    hash_a    = {}

    hash_e    = {}

    pose_temp = {}

    # fill created Arrays & Set pose

    hash_b = hash_base

    hash_a = hash_actor

    hash_e = hash_enemy

    # Setup the temp Array

    if @battler.is_a?(Game_Actor)

      pose_temp = hash_a[@battler.id] if hash_a.include?(@battler.id)

    else

      pose_temp = hash_e[@battler.id] if hash_e.include?(@battler.id)

    end

    # Obtain the base pose based on condition (or nil)

    pose_now = hash_b[condition] if hash_b.include?(condition)

    # Obtain the optional actor/enemy pose based on condition (unless nil)

    pose_now = pose_temp[condition] if pose_temp.include?(condition)

    # Return the final pose (minus 1 for neceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

 end

Part III:

Code:

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

# ** Animated Battlers - Enhanced   ver. 10.7                      (06-17-2008)

#

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

#  * (3) Battle System:  The Scene Battle class

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

 

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

# ** Scene_Battle 

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

#  This class performs battle screen processing.

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

 

class Scene_Battle

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

  # * Main Processing

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

  alias mnkmain main

  def main

    # Initialize wait count

    @delay_count = 0

    # Obtain the formation style

    # Only once per battle start

    $game_system.formation = $formation_style

    $game_system.formation = 0 if $formation_style == nil

    # if Formation is random 

    if $game_system.formation == 8 then

      $game_system.formation = rand(8).to_i

    end

    # Perform the original call

    mnkmain

  end

 

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

  # * Frame Update (main phase)

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

  alias mnk_anim_sp3 start_phase3

  def start_phase3

    # Remove flag after set number of turns

    if $game_temp.battle_turn >= MNK_ADV_OFF_TURN

      # Turn sideview advantage mirror flag off

      $game_temp.advantage_set = 0

    end

    # Perform the original call

    mnk_anim_sp3

  end

  

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

  # * Frame Update (main phase step 1 : action preparation)

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

  alias mkf_up4s1 update_phase4_step1

  def update_phase4_step1(battler = @active_battler)

    if $game_system.mnk_det_rtab_systm == true

      mkf_up4s1(battler)

    else

      mkf_up4s1

    end

    if battler != nil

      if $game_system.mnk_det_sd_casting == true

        if battler.sd_casting

          battler.casted = true

        end

      end

    end

  end

  

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

  # *  End Skill Selection

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

  alias mkf_endss end_skill_select

  def end_skill_select

    mkf_endss

    if $game_system.mnk_det_rtab_systm

      @active_actor.skill_casted = @skill.id

    else

      @active_battler.skill_casted = @skill.id

    end

  end

  

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

  # * Make Skill Action Results (alias used to determine skill used)

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

  alias make_skill_action_result_anim make_skill_action_result

  def make_skill_action_result(battler = @active_battler, plus_id = 0)

    @rtab = !@target_battlers

    if $game_system.mnk_det_rtab_attck

      make_skill_action_result_anim(battler, plus_id)

    else

      @rtab ? make_skill_action_result_anim(battler) : make_skill_action_result_anim

    end

    @skill_used = @skill.id

    battler.strike_skill   = @skill.id

    if $game_system.mnk_det_para_spell == true

      #if battler.spelling?

        battler.casted = true

      #end

    end       

    for target in (@rtab ? battler.target : @target_battlers)

      target.struck_skill = @skill.id

    end

  end

  

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

  # * Make Item Action Results (alias used to determine item used)

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

  alias make_item_action_result_anim make_item_action_result

  def make_item_action_result(battler = @active_battler)

    @rtab = !@target_battlers

    @rtab ? make_item_action_result_anim(battler) : make_item_action_result_anim

    @item_used = @item.id

    @item_usage = @item.scope

    battler.strike_item = @item.id

    for target in (@rtab ? battler.target : @target_battlers)

      target.struck_item = @item.id

    end

  end

  

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

  # * Frame Update (main phase step 1 : action preparation) (Casting Routine)

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

  alias update_phase4_step1_anim update_phase4_step1

  def update_phase4_step1(battler = @active_battler) 

    @rtab = !@target_battlers

    if $game_system.mnk_det_rtab_systm == true

      update_phase4_step1_anim(battler)

      if battler.current_action.kind == 1 and

        (not battler.current_action.forcing or @force != 2)

        if battler.rtp != 0    

          battler.casted = true

        end

      end

    else

      update_phase4_step1_anim

    end

  end

  

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

  # * Action Animation, Movement

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

  alias mnk_update_phase4_step3 update_phase4_step3

  def update_phase4_step3(battler = @active_battler)

    @rtab = !@target_battlers

    target = (@rtab ? battler.target : @target_battlers)[0]

    # Battle Delay System

    if MNK_AT_DELAY    

      # Fomar's Action Cost Detection

      if $game_system.mnk_det_acb_detect

        for actor in $game_party.actors

          actor.vitality= 0

        end

        for enemy in $game_troop.enemies

          enemy.vitality= 0

        end

      end

      # Trickster's AT Detection

      if $game_system.mnk_det_abs_detect

        for actor in $game_party.actors

          actor.at_bonus= [0,0]

        end

        for enemy in $game_troop.enemies

          enemy.at_bonus= [0,0]

        end

      end

      # Cogwheel RTAB Detection

      if $game_system.mnk_det_rtab_systm

        @rtab_wait_flag = true

      end

    end

 

    # If enemy is a default battler

    if battler.is_a?(Game_Enemy)

      if DEFAULT_ENEMY

        if @rtab then battler.white_flash = true end

        if @rtab then battler.wait = 10 end

      end

      if DEFAULT_ENEMY_ID != nil

        if DEFAULT_ENEMY_ID.include?(battler.id)

          if @rtab then battler.white_flash = true end

          if @rtab then battler.wait = 10 end

        end 

      end        

    end

    # If actor is a default battler

    if battler.is_a?(Game_Actor)

      if DEFAULT_ACTOR

        if @rtab then battler.white_flash = true end

        if @rtab then battler.wait = 10 end

      end

      if DEFAULT_ACTOR_ID != nil

        if DEFAULT_ACTOR_ID.include?(battler.id)

          if @rtab then battler.white_flash = true end

          if @rtab then battler.wait = 10 end

        end 

      end                

    end

    # Reset the 'Do Nothing' flag

    dn_flag = false

    # Set values and poses based on Action 

    case battler.current_action.kind

    when 0  # Attack

      # if Do Nothing, just return

      if battler.current_action.basic == 3

        dn_flag = true

      end

      if dn_flag != true

        rush_type = MNK_STEP_ATTACK

        full_moving = true ; if rush_type; full_moving = false; end

        if MNK_MOVE2CENTER_ATK.include?(battler.weapon_id); center_move=true ; end

        if MNK_STATIONARY_ENEMY_IDS.include?(battler.id) and battler.is_a?(Game_Enemy)

          full_moving = false

          center_move = false

          rush_type = false

        end

        base_pose = pose_obtain(battler, MNK_POSE7, MNK_APOSE7, MNK_EPOSE7)

        base_pose2 = pose_array_obtain(battler, MNK_POSES_WEAPONS, MNK_POSES_WEAPS_A, MNK_POSES_WEAPS_E, battler.weapon_id)

        base_pose = base_pose2 if base_pose2 != nil        

        if battler.current_action.basic == 2

          # If escaping, disable all movement

          full_moving = false

          center_move = false

          rush_type = false    

          # Set the graphics

          temp_pose = pose_obtain(battler, MNK_POSES_ESCAPE, MNK_POSES_ESCAPE_A, MNK_POSES_ESCAPE_E)

          base_pose = temp_pose if temp_pose != nil

        end

      end

    when 1  # Skill

      @spriteset.battler(battler).skill_used = @skill_used

      rush_type = MNK_STEP_SKILL

      if MNK_MOVING_SKILL.include?(@skill_used) ; full_moving = true ; end

      if MNK_MOVE2CENTER_SKILL.include?(@skill_used) ; center_move = true ; end        

      base_pose = pose_obtain(battler, MNK_POSE9, MNK_APOSE9, MNK_EPOSE9)

      base_pose2 = pose_array_obtain(battler, MNK_POSES_SKILLS, MNK_POSES_SKILLS_A, MNK_POSES_SKILLS_E, @skill_used)

      base_pose = base_pose2 if base_pose2 != nil

    when 2  # Item

      @spriteset.battler(battler).item_used = @item_used

      rush_type = MNK_STEP_ITEM

      if MNK_MOVING_ITEM.include?(@item_used) or @item_scope == 1..2 ; full_moving = true ; end

      if MNK_MOVE2CENTER_ITEM.include?(@item_used); center_move = true; end

      base_pose = pose_obtain(battler, MNK_POSE8, MNK_APOSE8, MNK_EPOSE8)

      base_pose2 = pose_array_obtain(battler, MNK_POSES_ITEMS, MNK_POSES_ITEMS_A, MNK_POSES_ITEMS_E, @item_used)

      base_pose = base_pose2 if base_pose2 != nil

    end

 

    # Only perform action if 'Do Nothing' flag is off, ie... doing something...

    if dn_flag != true

      # Control Movement and use current pose 

      @moved = {} unless @moved

      return if @spriteset.battler(battler).moving

      if not (@moved[battler] or battler.guarding?)

        offset = offset_value(target, battler)

        if rush_type        # Steps forward

          @spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1, battler.screen_z)

        end

        if full_moving      # Runs to target

          @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y - 1, target.screen_z + 10)

        end

        if center_move      # Runs to center

          @spriteset.battler(battler).setmove(320+(offset/4), battler.screen_y-1, battler.screen_z)

        end

        @moved[battler] = true

        return

        @spriteset.battler(battler).pose = base_pose

      elsif not battler.guarding?

        @spriteset.battler(battler).pose = base_pose

        @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y, battler.screen_z)

      end

     

      # Finish Up Skill and Item Use

      case battler.current_action.kind

      when 1

        # Flag system that skill was used

        battler.casted = false

        battler.casting = false

        @spriteset.battler(battler).skill_used = 0

      when 2

        # Flag system that item was used

        @spriteset.battler(battler).item_used = 0

      end

      

      # Battle_Charge value for BattleCry script

      $battle_charge = true

    end

  

    # Battle Delay System

    if MNK_AT_DELAY    

      # Fomar's Action Cost Detection

      if $game_system.mnk_det_acb_detect

        for actor in $game_party.actors

          actor.vitality = 1

        end

        for enemy in $game_troop.enemies

          enemy.vitality = 1

        end

      end

      # Trickster's AT Detection

      if $game_system.mnk_det_abs_detect

        for actor in $game_party.actors

          actor.at_bonus = [1,0]

        end

        for enemy in $game_troop.enemies

          enemy.at_bonus = [1,0]

        end

      end

      # Cogwheel RTAB Detection

      if $game_system.mnk_det_rtab_systm

        @rtab_wait_flag = false

      end

    end

    # Prevent 'removed battler' moved state

    unless @moved == nil

      @moved[battler] = false

    end

    # Start attack, do not move from spot

    battler.attacking = true

    # Perform the original call

    @rtab ? mnk_update_phase4_step3(battler) : mnk_update_phase4_step3

  end

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

  # * Offset Calculation

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

  def offset_value(target, battler = @active_battler)

    offst = @spriteset.battler(battler).battler_offset

    offst += MNK_OFFSET

    # Oversized or special Battler offsets

    if target.is_a?(Game_Enemy) && battler.is_a?(Game_Actor)

      unless MNK_OFFSET_ACTOR == nil

        offst += MNK_OFFSET_ACTOR[battler.id] if MNK_OFFSET_ACTOR.include?(battler.id)

      end

      unless MNK_OFFSET_ENEMY == nil

        offst += MNK_OFFSET_ENEMY[target.id] if MNK_OFFSET_ENEMY.include?(target.id)

      end

    end

    if target.is_a?(Game_Actor) && battler.is_a?(Game_Enemy)

      unless MNK_OFFSET_ENEMY == nil

        offst += MNK_OFFSET_ENEMY[battler.id] if MNK_OFFSET_ENEMY.include?(battler.id)

      end

      unless MNK_OFFSET_ACTOR == nil

        offst += MNK_OFFSET_ACTOR[target.id] if MNK_OFFSET_ACTOR.include?(target.id)

      end

    end

    # Offset calc dependant on sideview

    if $game_system.sv_angle == 1

      offset = (battler.is_a?(Game_Actor) ? -(offst) : offst)

    else

      offset = (battler.is_a?(Game_Actor) ? offst : -(offst))

    end

    return offset

  end

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

  # * Hit Animation

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

  alias mnk_update_phase4_step4 update_phase4_step4

  def update_phase4_step4(battler = @active_battler)

    # Cycle through the targets

    for target in (@rtab ? battler.target : @target_battlers)

      damage = (@rtab ? target.damage[battler] : target.damage)

      critical = (@rtab ? target.critical[battler] : target.critical)

      if damage.is_a?(Numeric) and damage > 0

        base_pose = pose_obtain(target, MNK_POSE2, MNK_APOSE2, MNK_EPOSE2)

        weapon_used = battler.weapon_id

        weapon_used = 0 if weapon_used == nil

        base_pose2 = pose_array_obtain(target, MNK_STRUCK_WEAPS, MNK_STRUCK_WEAPS_A, MNK_STRUCK_WEAPS_E, weapon_used)

        base_pose = base_pose2 if base_pose2 != nil

        if battler.strike_skill != 0

          if battler.strike_skill == target.struck_skill

            base_pose2 = pose_array_obtain(target, MNK_STRUCK_SKILLS, MNK_STRUCK_SKILLS_A, MNK_STRUCK_SKILLS_E, target.struck_skill)

            base_pose = base_pose2 if base_pose2 != nil

          end

        end

        if battler.strike_item != 0

          if battler.strike_item == target.struck_item

            base_pose2 = pose_array_obtain(target, MNK_STRUCK_ITEMS, MNK_STRUCK_ITEMS_A, MNK_STRUCK_ITEMS_E, target.struck_item)

            base_pose = base_pose2 if base_pose2 != nil

          end

        end

        @spriteset.battler(target).pose = base_pose

        if critical == true

          temp_pose = pose_obtain(target, MNK_POSES_CRITICAL, MNK_POSES_CRIT_A, MNK_POSES_CRIT_E)

          weapon_used = battler.weapon_id

          weapon_used = 0 if weapon_used == nil

          base_pose2 = pose_array_obtain(target, MNK_CRIT_WEAPS, MNK_CRIT_WEAPS_A, MNK_CRIT_WEAPS_E, weapon_used)

          base_pose = base_pose2 if base_pose2 != nil

          if @skill_used != 0

            if @skill_used == target.struck_skill

              base_pose2 = pose_array_obtain(target, MNK_CRIT_SKILLS, MNK_CRIT_SKILLS_A, MNK_CRIT_SKILLS_E, target.struck_skill)

              base_pose = base_pose2 if base_pose2 != nil

            end

          end

          if @item_used != 0

            if @item_used == target.struck_item

              base_pose2 = pose_array_obtain(target, MNK_CRIT_ITEMS, MNK_CRIT_ITEMS_A, MNK_CRIT_ITEMS_E, target.struck_item)

              base_pose = base_pose2 if base_pose2 != nil

            end

          end

          @spriteset.battler(target).pose = temp_pose if temp_pose != nil

        end

      end

    end

    # Reset/zero out the battler's skill & item

    battler.strike_skill  = 0

    battler.strike_item   = 0

    # Perform the original call

    @rtab ? mnk_update_phase4_step4(battler) : mnk_update_phase4_step4

    # Finish attack n battle animation, free to move

    battler.attacking = false

  end

  

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

  # * Victory Animation

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

  alias mnk_start_phase5 start_phase5

  def start_phase5

    for actor in $game_party.actors

      return if @spriteset.battler(actor).moving

    end

    # See if an actor remains alive

    for actor in $game_party.actors

      unless actor.dead?

        $game_system.victory = true

      end

    end

    # See if an enemy remains alive

    for enemy in $game_troop.enemies.reverse

      unless enemy.dead?

        $game_system.defeat = true

      end

    end    

    # Perform the original call    

    mnk_start_phase5

  end

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

  # * Change Arrow Viewport

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

  alias mnk_start_enemy_select start_enemy_select

  def start_enemy_select

    # Perform the original call

    mnk_start_enemy_select

    # Arrow manipulation

    @enemy_arrow.dispose

    @enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)

    @enemy_arrow.help_window = @help_window

  end

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

  # * Obtain Pose (Scene Battle version)

  #     battler     : battler performing attack

  #     pose_base   : default pose to return

  #     pose_actor  : list of poses for actors

  #     pose_enemy  : list of poses for enemies

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

  def pose_obtain(battler, pose_base, pose_actor, pose_enemy)

    # create Arrays

    pos_a = {}

    pos_e = {}

    # fill created Arrays & Set pose

    pos_a = pose_actor

    pos_e = pose_enemy

    pose_now = pose_base

    # Obtain pose if not a standard pose

    if battler.is_a?(Game_Actor)

      pose_now = pos_a[battler.id] if pos_a[battler.id] != nil

    else

      pose_now = pos_e[battler.id] if pos_e[battler.id] != nil

    end

    # Return the final pose (minus 1 for niceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

 

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

  # * Obtain Pose from hashes (Scene Battle version)

  #     battler     : battler performing attack

  #     hash_base   : hash with default poses

  #     hash_actor  : advanced list of poses for actors

  #     hash_enemy  : advanced list of poses for enemies

  #     condition   : value determining where to get the final pose

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

  def pose_array_obtain(battler, hash_base, hash_actor, hash_enemy, condition)

    # create Arrays

    # create Arrays

    hash_b    = {}

    hash_a    = {}

    hash_e    = {}

    pose_temp = {}

    # fill created Arrays & Set pose

    hash_b = hash_base

    hash_a = hash_actor

    hash_e = hash_enemy

    # Setup the temp Array

    if battler.is_a?(Game_Actor)

      pose_temp = hash_a[battler.id] if hash_a.include?(battler.id)

    else

      pose_temp = hash_e[battler.id] if hash_e.include?(battler.id)

    end

    # Obtain the base pose based on condition (or nil)

    pose_now = hash_b[condition] if hash_b.include?(condition)

    # Obtain the optional actor/enemy pose based on condition (unless nil)

    pose_now = pose_temp[condition] if pose_temp.include?(condition)

    # Return the final pose (minus 1 for niceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

end

Part 4: Post all the parts of this script NEAR each other in different sections.

Code:

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

# ** Animated Battlers - Enhanced   ver. 10.7                      (06-17-2008)

#

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

#  * (3) Battle System:  The Scene Battle class

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

 

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

# ** Scene_Battle 

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

#  This class performs battle screen processing.

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

 

class Scene_Battle

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

  # * Main Processing

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

  alias mnkmain main

  def main

    # Initialize wait count

    @delay_count = 0

    # Obtain the formation style

    # Only once per battle start

    $game_system.formation = $formation_style

    $game_system.formation = 0 if $formation_style == nil

    # if Formation is random 

    if $game_system.formation == 8 then

      $game_system.formation = rand(8).to_i

    end

    # Perform the original call

    mnkmain

  end

 

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

  # * Frame Update (main phase)

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

  alias mnk_anim_sp3 start_phase3

  def start_phase3

    # Remove flag after set number of turns

    if $game_temp.battle_turn >= MNK_ADV_OFF_TURN

      # Turn sideview advantage mirror flag off

      $game_temp.advantage_set = 0

    end

    # Perform the original call

    mnk_anim_sp3

  end

  

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

  # * Frame Update (main phase step 1 : action preparation)

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

  alias mkf_up4s1 update_phase4_step1

  def update_phase4_step1(battler = @active_battler)

    if $game_system.mnk_det_rtab_systm == true

      mkf_up4s1(battler)

    else

      mkf_up4s1

    end

    if battler != nil

      if $game_system.mnk_det_sd_casting == true

        if battler.sd_casting

          battler.casted = true

        end

      end

    end

  end

  

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

  # *  End Skill Selection

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

  alias mkf_endss end_skill_select

  def end_skill_select

    mkf_endss

    if $game_system.mnk_det_rtab_systm

      @active_actor.skill_casted = @skill.id

    else

      @active_battler.skill_casted = @skill.id

    end

  end

  

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

  # * Make Skill Action Results (alias used to determine skill used)

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

  alias make_skill_action_result_anim make_skill_action_result

  def make_skill_action_result(battler = @active_battler, plus_id = 0)

    @rtab = !@target_battlers

    if $game_system.mnk_det_rtab_attck

      make_skill_action_result_anim(battler, plus_id)

    else

      @rtab ? make_skill_action_result_anim(battler) : make_skill_action_result_anim

    end

    @skill_used = @skill.id

    battler.strike_skill   = @skill.id

    if $game_system.mnk_det_para_spell == true

      #if battler.spelling?

        battler.casted = true

      #end

    end       

    for target in (@rtab ? battler.target : @target_battlers)

      target.struck_skill = @skill.id

    end

  end

  

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

  # * Make Item Action Results (alias used to determine item used)

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

  alias make_item_action_result_anim make_item_action_result

  def make_item_action_result(battler = @active_battler)

    @rtab = !@target_battlers

    @rtab ? make_item_action_result_anim(battler) : make_item_action_result_anim

    @item_used = @item.id

    @item_usage = @item.scope

    battler.strike_item = @item.id

    for target in (@rtab ? battler.target : @target_battlers)

      target.struck_item = @item.id

    end

  end

  

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

  # * Frame Update (main phase step 1 : action preparation) (Casting Routine)

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

  alias update_phase4_step1_anim update_phase4_step1

  def update_phase4_step1(battler = @active_battler) 

    @rtab = !@target_battlers

    if $game_system.mnk_det_rtab_systm == true

      update_phase4_step1_anim(battler)

      if battler.current_action.kind == 1 and

        (not battler.current_action.forcing or @force != 2)

        if battler.rtp != 0    

          battler.casted = true

        end

      end

    else

      update_phase4_step1_anim

    end

  end

  

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

  # * Action Animation, Movement

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

  alias mnk_update_phase4_step3 update_phase4_step3

  def update_phase4_step3(battler = @active_battler)

    @rtab = !@target_battlers

    target = (@rtab ? battler.target : @target_battlers)[0]

    # Battle Delay System

    if MNK_AT_DELAY    

      # Fomar's Action Cost Detection

      if $game_system.mnk_det_acb_detect

        for actor in $game_party.actors

          actor.vitality= 0

        end

        for enemy in $game_troop.enemies

          enemy.vitality= 0

        end

      end

      # Trickster's AT Detection

      if $game_system.mnk_det_abs_detect

        for actor in $game_party.actors

          actor.at_bonus= [0,0]

        end

        for enemy in $game_troop.enemies

          enemy.at_bonus= [0,0]

        end

      end

      # Cogwheel RTAB Detection

      if $game_system.mnk_det_rtab_systm

        @rtab_wait_flag = true

      end

    end

 

    # If enemy is a default battler

    if battler.is_a?(Game_Enemy)

      if DEFAULT_ENEMY

        if @rtab then battler.white_flash = true end

        if @rtab then battler.wait = 10 end

      end

      if DEFAULT_ENEMY_ID != nil

        if DEFAULT_ENEMY_ID.include?(battler.id)

          if @rtab then battler.white_flash = true end

          if @rtab then battler.wait = 10 end

        end 

      end        

    end

    # If actor is a default battler

    if battler.is_a?(Game_Actor)

      if DEFAULT_ACTOR

        if @rtab then battler.white_flash = true end

        if @rtab then battler.wait = 10 end

      end

      if DEFAULT_ACTOR_ID != nil

        if DEFAULT_ACTOR_ID.include?(battler.id)

          if @rtab then battler.white_flash = true end

          if @rtab then battler.wait = 10 end

        end 

      end                

    end

    # Reset the 'Do Nothing' flag

    dn_flag = false

    # Set values and poses based on Action 

    case battler.current_action.kind

    when 0  # Attack

      # if Do Nothing, just return

      if battler.current_action.basic == 3

        dn_flag = true

      end

      if dn_flag != true

        rush_type = MNK_STEP_ATTACK

        full_moving = true ; if rush_type; full_moving = false; end

        if MNK_MOVE2CENTER_ATK.include?(battler.weapon_id); center_move=true ; end

        if MNK_STATIONARY_ENEMY_IDS.include?(battler.id) and battler.is_a?(Game_Enemy)

          full_moving = false

          center_move = false

          rush_type = false

        end

        base_pose = pose_obtain(battler, MNK_POSE7, MNK_APOSE7, MNK_EPOSE7)

        base_pose2 = pose_array_obtain(battler, MNK_POSES_WEAPONS, MNK_POSES_WEAPS_A, MNK_POSES_WEAPS_E, battler.weapon_id)

        base_pose = base_pose2 if base_pose2 != nil        

        if battler.current_action.basic == 2

          # If escaping, disable all movement

          full_moving = false

          center_move = false

          rush_type = false    

          # Set the graphics

          temp_pose = pose_obtain(battler, MNK_POSES_ESCAPE, MNK_POSES_ESCAPE_A, MNK_POSES_ESCAPE_E)

          base_pose = temp_pose if temp_pose != nil

        end

      end

    when 1  # Skill

      @spriteset.battler(battler).skill_used = @skill_used

      rush_type = MNK_STEP_SKILL

      if MNK_MOVING_SKILL.include?(@skill_used) ; full_moving = true ; end

      if MNK_MOVE2CENTER_SKILL.include?(@skill_used) ; center_move = true ; end        

      base_pose = pose_obtain(battler, MNK_POSE9, MNK_APOSE9, MNK_EPOSE9)

      base_pose2 = pose_array_obtain(battler, MNK_POSES_SKILLS, MNK_POSES_SKILLS_A, MNK_POSES_SKILLS_E, @skill_used)

      base_pose = base_pose2 if base_pose2 != nil

    when 2  # Item

      @spriteset.battler(battler).item_used = @item_used

      rush_type = MNK_STEP_ITEM

      if MNK_MOVING_ITEM.include?(@item_used) or @item_scope == 1..2 ; full_moving = true ; end

      if MNK_MOVE2CENTER_ITEM.include?(@item_used); center_move = true; end

      base_pose = pose_obtain(battler, MNK_POSE8, MNK_APOSE8, MNK_EPOSE8)

      base_pose2 = pose_array_obtain(battler, MNK_POSES_ITEMS, MNK_POSES_ITEMS_A, MNK_POSES_ITEMS_E, @item_used)

      base_pose = base_pose2 if base_pose2 != nil

    end

 

    # Only perform action if 'Do Nothing' flag is off, ie... doing something...

    if dn_flag != true

      # Control Movement and use current pose 

      @moved = {} unless @moved

      return if @spriteset.battler(battler).moving

      if not (@moved[battler] or battler.guarding?)

        offset = offset_value(target, battler)

        if rush_type        # Steps forward

          @spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1, battler.screen_z)

        end

        if full_moving      # Runs to target

          @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y - 1, target.screen_z + 10)

        end

        if center_move      # Runs to center

          @spriteset.battler(battler).setmove(320+(offset/4), battler.screen_y-1, battler.screen_z)

        end

        @moved[battler] = true

        return

        @spriteset.battler(battler).pose = base_pose

      elsif not battler.guarding?

        @spriteset.battler(battler).pose = base_pose

        @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y, battler.screen_z)

      end

     

      # Finish Up Skill and Item Use

      case battler.current_action.kind

      when 1

        # Flag system that skill was used

        battler.casted = false

        battler.casting = false

        @spriteset.battler(battler).skill_used = 0

      when 2

        # Flag system that item was used

        @spriteset.battler(battler).item_used = 0

      end

      

      # Battle_Charge value for BattleCry script

      $battle_charge = true

    end

  

    # Battle Delay System

    if MNK_AT_DELAY    

      # Fomar's Action Cost Detection

      if $game_system.mnk_det_acb_detect

        for actor in $game_party.actors

          actor.vitality = 1

        end

        for enemy in $game_troop.enemies

          enemy.vitality = 1

        end

      end

      # Trickster's AT Detection

      if $game_system.mnk_det_abs_detect

        for actor in $game_party.actors

          actor.at_bonus = [1,0]

        end

        for enemy in $game_troop.enemies

          enemy.at_bonus = [1,0]

        end

      end

      # Cogwheel RTAB Detection

      if $game_system.mnk_det_rtab_systm

        @rtab_wait_flag = false

      end

    end

    # Prevent 'removed battler' moved state

    unless @moved == nil

      @moved[battler] = false

    end

    # Start attack, do not move from spot

    battler.attacking = true

    # Perform the original call

    @rtab ? mnk_update_phase4_step3(battler) : mnk_update_phase4_step3

  end

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

  # * Offset Calculation

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

  def offset_value(target, battler = @active_battler)

    offst = @spriteset.battler(battler).battler_offset

    offst += MNK_OFFSET

    # Oversized or special Battler offsets

    if target.is_a?(Game_Enemy) && battler.is_a?(Game_Actor)

      unless MNK_OFFSET_ACTOR == nil

        offst += MNK_OFFSET_ACTOR[battler.id] if MNK_OFFSET_ACTOR.include?(battler.id)

      end

      unless MNK_OFFSET_ENEMY == nil

        offst += MNK_OFFSET_ENEMY[target.id] if MNK_OFFSET_ENEMY.include?(target.id)

      end

    end

    if target.is_a?(Game_Actor) && battler.is_a?(Game_Enemy)

      unless MNK_OFFSET_ENEMY == nil

        offst += MNK_OFFSET_ENEMY[battler.id] if MNK_OFFSET_ENEMY.include?(battler.id)

      end

      unless MNK_OFFSET_ACTOR == nil

        offst += MNK_OFFSET_ACTOR[target.id] if MNK_OFFSET_ACTOR.include?(target.id)

      end

    end

    # Offset calc dependant on sideview

    if $game_system.sv_angle == 1

      offset = (battler.is_a?(Game_Actor) ? -(offst) : offst)

    else

      offset = (battler.is_a?(Game_Actor) ? offst : -(offst))

    end

    return offset

  end

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

  # * Hit Animation

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

  alias mnk_update_phase4_step4 update_phase4_step4

  def update_phase4_step4(battler = @active_battler)

    # Cycle through the targets

    for target in (@rtab ? battler.target : @target_battlers)

      damage = (@rtab ? target.damage[battler] : target.damage)

      critical = (@rtab ? target.critical[battler] : target.critical)

      if damage.is_a?(Numeric) and damage > 0

        base_pose = pose_obtain(target, MNK_POSE2, MNK_APOSE2, MNK_EPOSE2)

        weapon_used = battler.weapon_id

        weapon_used = 0 if weapon_used == nil

        base_pose2 = pose_array_obtain(target, MNK_STRUCK_WEAPS, MNK_STRUCK_WEAPS_A, MNK_STRUCK_WEAPS_E, weapon_used)

        base_pose = base_pose2 if base_pose2 != nil

        if battler.strike_skill != 0

          if battler.strike_skill == target.struck_skill

            base_pose2 = pose_array_obtain(target, MNK_STRUCK_SKILLS, MNK_STRUCK_SKILLS_A, MNK_STRUCK_SKILLS_E, target.struck_skill)

            base_pose = base_pose2 if base_pose2 != nil

          end

        end

        if battler.strike_item != 0

          if battler.strike_item == target.struck_item

            base_pose2 = pose_array_obtain(target, MNK_STRUCK_ITEMS, MNK_STRUCK_ITEMS_A, MNK_STRUCK_ITEMS_E, target.struck_item)

            base_pose = base_pose2 if base_pose2 != nil

          end

        end

        @spriteset.battler(target).pose = base_pose

        if critical == true

          temp_pose = pose_obtain(target, MNK_POSES_CRITICAL, MNK_POSES_CRIT_A, MNK_POSES_CRIT_E)

          weapon_used = battler.weapon_id

          weapon_used = 0 if weapon_used == nil

          base_pose2 = pose_array_obtain(target, MNK_CRIT_WEAPS, MNK_CRIT_WEAPS_A, MNK_CRIT_WEAPS_E, weapon_used)

          base_pose = base_pose2 if base_pose2 != nil

          if @skill_used != 0

            if @skill_used == target.struck_skill

              base_pose2 = pose_array_obtain(target, MNK_CRIT_SKILLS, MNK_CRIT_SKILLS_A, MNK_CRIT_SKILLS_E, target.struck_skill)

              base_pose = base_pose2 if base_pose2 != nil

            end

          end

          if @item_used != 0

            if @item_used == target.struck_item

              base_pose2 = pose_array_obtain(target, MNK_CRIT_ITEMS, MNK_CRIT_ITEMS_A, MNK_CRIT_ITEMS_E, target.struck_item)

              base_pose = base_pose2 if base_pose2 != nil

            end

          end

          @spriteset.battler(target).pose = temp_pose if temp_pose != nil

        end

      end

    end

    # Reset/zero out the battler's skill & item

    battler.strike_skill  = 0

    battler.strike_item   = 0

    # Perform the original call

    @rtab ? mnk_update_phase4_step4(battler) : mnk_update_phase4_step4

    # Finish attack n battle animation, free to move

    battler.attacking = false

  end

  

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

  # * Victory Animation

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

  alias mnk_start_phase5 start_phase5

  def start_phase5

    for actor in $game_party.actors

      return if @spriteset.battler(actor).moving

    end

    # See if an actor remains alive

    for actor in $game_party.actors

      unless actor.dead?

        $game_system.victory = true

      end

    end

    # See if an enemy remains alive

    for enemy in $game_troop.enemies.reverse

      unless enemy.dead?

        $game_system.defeat = true

      end

    end    

    # Perform the original call    

    mnk_start_phase5

  end

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

  # * Change Arrow Viewport

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

  alias mnk_start_enemy_select start_enemy_select

  def start_enemy_select

    # Perform the original call

    mnk_start_enemy_select

    # Arrow manipulation

    @enemy_arrow.dispose

    @enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)

    @enemy_arrow.help_window = @help_window

  end

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

  # * Obtain Pose (Scene Battle version)

  #     battler     : battler performing attack

  #     pose_base   : default pose to return

  #     pose_actor  : list of poses for actors

  #     pose_enemy  : list of poses for enemies

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

  def pose_obtain(battler, pose_base, pose_actor, pose_enemy)

    # create Arrays

    pos_a = {}

    pos_e = {}

    # fill created Arrays & Set pose

    pos_a = pose_actor

    pos_e = pose_enemy

    pose_now = pose_base

    # Obtain pose if not a standard pose

    if battler.is_a?(Game_Actor)

      pose_now = pos_a[battler.id] if pos_a[battler.id] != nil

    else

      pose_now = pos_e[battler.id] if pos_e[battler.id] != nil

    end

    # Return the final pose (minus 1 for niceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

 

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

  # * Obtain Pose from hashes (Scene Battle version)

  #     battler     : battler performing attack

  #     hash_base   : hash with default poses

  #     hash_actor  : advanced list of poses for actors

  #     hash_enemy  : advanced list of poses for enemies

  #     condition   : value determining where to get the final pose

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

  def pose_array_obtain(battler, hash_base, hash_actor, hash_enemy, condition)

    # create Arrays

    # create Arrays

    hash_b    = {}

    hash_a    = {}

    hash_e    = {}

    pose_temp = {}

    # fill created Arrays & Set pose

    hash_b = hash_base

    hash_a = hash_actor

    hash_e = hash_enemy

    # Setup the temp Array

    if battler.is_a?(Game_Actor)

      pose_temp = hash_a[battler.id] if hash_a.include?(battler.id)

    else

      pose_temp = hash_e[battler.id] if hash_e.include?(battler.id)

    end

    # Obtain the base pose based on condition (or nil)

    pose_now = hash_b[condition] if hash_b.include?(condition)

    # Obtain the optional actor/enemy pose based on condition (unless nil)

    pose_now = pose_temp[condition] if pose_temp.include?(condition)

    # Return the final pose (minus 1 for niceties)

    pose_now -= 1 if pose_now != nil

    return pose_now

  end

end

In line 21-23 in SCRIPT PART I write "True" so that you can use a character sprite ass battler (only 1 frame of teh character ofc)

//Hope I helped!

BlueScope · Apr 28, 2010

"Can't be simpler" is a funny line for a ~2200 line script that only does sideview battles...

@OT: As far as I can tell, you're just looking for a script that draws the character on the screen, right? Because in that case, ~100 lines should be perfectly sufficient to achieve that (and I recall one of the script collection threats having such a simple "plugin" listed).

BlueScope · May 2, 2010

Because someone just necroposted in another thread, I found this: viewtopic.php?f=11&t=66224&start=0

Should be exactly what you're looking for!

EDIT: NAh, I'm stupid... it's a VX script. However, as stated in the description, lambchop made a version for XP, so I figure look for that ^^"

Envision, Create, Share

Side View Battle:Request

Outcast

action

Outcast

action

Brewmeister

Outcast

Outcast

Atoa

9robin3

BlueScope

BlueScope

Share this page

Thank you for viewing

Discord

RPG Maker

Content