Envision, Create, Share

Welcome to HBGames, a leading amateur game development forum and Discord server. All are welcome, and amongst our ranks you will find experts in their field from all aspects of video game design and development.
Register

Problem With Minkoffs Animated Battlers

Latest Post

Nolund

Sponsor

468
Alright, I was hoping to use Minkoff's Animated Battlers for my game, but I've been having some problems with it. I've managed to figure out how to make my enemies use animated battlers, and that aspect works fine, but for some reason I get this:

minkofferrorqk9.png

Now, those aren't my actual battlers when things will be said and done, I just wanted to test the system out. Is it a problem with the battlers? Or am I doing something wrong?
 
Sort by date Sort by votes

Fusty

Sponsor

97
I'm not great at scripting but I think you have to change a few things in the Side View CONFIG script:

On line 34 change MNK_POSES = 5 to MNK_POSES = 11
On line 42 change MNK_POSES_ACTOR = {1 => 5} to MNK_POSES_ACTOR = {1 => 11}
Then make sure line 73 to 83 look like this:

MNK_EPOSE1 = {1 => 1}
MNK_EPOSE2 = {1 => 2}
MNK_EPOSE3 = {1 => 3}
MNK_EPOSE4 = {1 => 4}
MNK_EPOSE5 = {1 => 5}
MNK_EPOSE6 = {1 => 6}
MNK_EPOSE7 = {1 => 7}
MNK_EPOSE8 = {1 => 8}
MNK_EPOSE9 = {1 => 9}
MNK_APOSE10 = {1 => 10}
MNK_EPOSE11 = {1 => 11}

(This only works if your actor battlers have 11 poses, if they have less you have to change the numbers.)
I've tested it and it works for me.
If it doesn't work for you post the script so I can see what's wrong.

Hope it helps.
 
Upvote 0 Downvote

Nolund

Sponsor

468
I tried fixing the problem that way, by there is no difference. I made sure my battlers all had 11 poses, which they do, and I changed the other data as well, but my problem is still the same.

Code: 
#==============================================================================

# ** Animated Battlers - Enhanced   ver. 11.2                      (11-24-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           = false   # If true, these switches allows the use

  DEFAULT_ACTOR           = false   # of default battlers for actors/enemies

  DEFAULT_ENEMY_ID        = [3]     # Ids of enemies using default battlers

  DEFAULT_ACTOR_ID        = [1]     # 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)

  

  # * Background Battler Screentone Switches

  #   Note:  Battle animations and damage pops reside in the same viewport as

  #          the battlers.  If a battler's tone is altered by the screentone,

  #          so shall the battle animation and damage pops for that battler.

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

  SCREENTONE_ENEMY_MATCH  = true    # If true, the actors/enemies tones match

  SCREENTONE_ACTOR_MATCH  = false   # with the background.  If false, no fix.

  

  # * Animation Frames and Animation Speed

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

  MNK_SPEED               = 4       # 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         = {1 => 11}  # 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_EPOSE1 = {1 => 1}

MNK_EPOSE2 = {1 => 2}

MNK_EPOSE3 = {1 => 3}

MNK_EPOSE4 = {1 => 4}

MNK_EPOSE5 = {1 => 5}

MNK_EPOSE6 = {1 => 6}

MNK_EPOSE7 = {1 => 7}

MNK_EPOSE8 = {1 => 8}

MNK_EPOSE9 = {1 => 9}

MNK_APOSE10 = {1 => 10}

MNK_EPOSE11 = {1 => 11} 

    

  # 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.

     

  

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

  #   ****                 RANDOM ATTACK POSE CENTER                 ****   #

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

  

  # Each value can be set to nil so no optional melee attack poses are avail-

  # able, or you can enter an array [ ] of poses that can be chosen randomly

  # along with your battler's pre-set attack pose.

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

  

  MNK_RANDOM_ATTACKS    = nil           # -- no random attacks here --

  MNK_RANDOM_ATTACKS_A  = {7 => [8,9]}  # Sets the 7th battler to use 8&9 too.

  MNK_RANDOM_ATTACKS_E  = nil           # -- no random attacks here --

  

  

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

  #   ****               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     = {7 => 6}          

  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  = [73]       # (examples are bows & guns)

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

 

 

    

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

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

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

  MNK_TRANSLUCENCY      = 127      # 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    = true     # 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 around.

 
 
Upvote 0 Downvote

Fusty

Sponsor

97
The lines 81 to 91 should be like 67 to 77.

And line 25: DEFAULT_ACTOR_ID = [1] # Ids of actors using default battlers
Should be like this: DEFAULT_ACTOR_ID = [] # Ids of actors using default battlers
 
Upvote 0 Downvote

Nolund

Sponsor

468
OK, I've changed those variables, but now I get this error:

2a5c9c9.png


And here's the script it comes from:

Code: 
#==============================================================================

# ** Animated Battlers - Enhanced   ver. 11.2                      (11-24-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)

    movekind = @battler.current_action.kind

    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) && movekind == 0) or

             (MNK_STATIONARY_SKILLS.include?(@battler.skill_used) && movekind == 1) or

             (MNK_STATIONARY_ITEMS.include?(@battler.item_used) && movekind == 2)

        @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)

    # Check for default RTP battler type

    default_flag = false

    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))

      default_flag = true

    end    

=begin    

    if battler.hidden

      self.opacity  = 0

    else

      self.opacity  = MNK_TRANSLUCENCY

    end

=end

    # Perform translucency check

    if battler.hidden 

      self.opacity = 0

    elsif battler.dead? && default_flag == true

      self.opacity = 0# if @collapsing = false

    else

      self.opacity  = trans_level

    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

 

I assume I have to change the variables of MNK_POSE and such, I just dont know what I am supposed to change it to.

I apologize for all this, I'm just clueless when it comes to coding yet.
 
Upvote 0 Downvote

Fusty

Sponsor

97
Oh crap I've just noticed that you're using a newer version, so the lines are different from the ones in the script I'm using.
I don't know if much has changed but since I suck at scripting as well I think it's better if someone else helped you.
 
Upvote 0 Downvote
You must log in or register to reply here.

Share this page

Thank you for viewing

HBGames is a leading amateur video game development forum and Discord server open to all ability levels. Feel free to have a nosey around!

Discord

Join our growing and active Discord server to discuss all aspects of game making in a relaxed environment. Join Us

RPG Maker

  • Support & Help
    •
  • Tutorials
    •
  • Plugins - MZ, MV
    •
  • Scripts - Ace, VX, XP
    •
  • Resources
    •

    Content

  • Our Games
    •
  • Games in Development
    •  Emoji by Twemoji.
    Top