#===============================================================================
# Animated Battlers
# By Jet10985 (Jet)
#===============================================================================
# This script will allow the use of spritesheets to represent enemies and actors
# inside the battle scene.
# This script has: 14 customization options.
#===============================================================================
# Overwritten Methods:
# None
#-------------------------------------------------------------------------------
# Aliased methods:
# Cache: load_bitmap
# Game_Battler: initialize, on_damage
# BattleManager: process_victory, process_defeat, battle_start
# Sprite_Battler: initialize, update, update_origin, start_effect,
#   revert_to_normal
# Sprite: update
#===============================================================================
=begin
If you need to set up a custom animated sprite for a specific actor or enemy,
you need to use these inside the character's notebox:

<anim battler: name> (This sets the name of the animated spritesheet to use)

The above is the only needed notetag to use a custom spritesheet, but if you
need to go against default configuration below as well, you may use these:

<anim speed: speed> (This sets the speed at which the animation changes frames)
<anim frames: frames> (This sets how many frames there are in a single row)
<anim rows: rows> (This sets how many rows there are in the spritesheet)
--------------------------------------------------------------------------------
Byd efault, all states except being dead will set the row to be the one
set for :state, but if you need a state which does not change the current row,
use this in the state's notebox:

<anim no pose>
--------------------------------------------------------------------------------
To have an enemy follow the opposite of the below FLIP_ENEMIES config, use this
notetag:

<anim flip>

Putting this in an actor's notebox will always cause the actor's sprite to be
flipped.
--------------------------------------------------------------------------------
You can change an enemy's attack animation by using this notetag:

<atk anim: id>
--------------------------------------------------------------------------------
If you need to have a special sheet for when the character is a specific class,
use this tag in the class notebox:

<anim suffix: suffix>

This will make the script look for whatever their default sheet would be,
but with suffix at the end. So if the tag was <anim suffix: _paladin> and the
base sheet was "Jimmy", the script would look for "Jimmy_paladin"
--------------------------------------------------------------------------------
If you need to have a specific row for when the character has a specific state,
use this tag in the state notebox:

<anim row: row>

This will make it so if this state is inflicted, the character's row will be
that of whatever the row is in the notetag.
If multiple states have a notetag, and are inflicted, the state with the highest
"Display Priority" will be used.
--------------------------------------------------------------------------------
By default, this is what the POSE_ROWS configuration correlates to in choosing
which row of the spritesheet to show. This uses a format which Holder uses in
their animated battlers by default, and this is taken directly from them:

1. Idle - Waiting.
2. Defend - Guarding.
3. Woozy - Under status effect. (Also low hp value)
4. Struck - Being hit. (Taking damage)
5. Attack - Striking the target.
6. Item - Using an item.
7. Skill - Using a technique.
8. Magic - Casting a spell.
9. Advance - Moving forward.
10. Retreat - Moving away. (From target or fleeing from battle)
11. Victory - Battle end.
12. Enter - Battle start.
13. Dead - Corpse. (Dead-dood-ded)
14. Credits - Information about the graphic. (Not shown in game)
=end

module Jet
  module AnimatedBattlers
    
    # This is how many rows on poses there are in a default spritesheet.
    # The height of each row is determined by dividing the animation
    # bitmap height by this.
    ANIMATION_ROWS = 14
    
    # This is how many frames are in a row/pose.
    # This width of each frame is determined by dividing the animation
    # bitmap width by this.
    ANIMATION_FRAMES = 4
    
    # This is how long it takes in frames to change which frame is displayed
    # on the current pose.
    ANIMATION_SPEED = 10
    
    # This is the suffix added to the character's name to try to find a default
    # animated spritesheet. If an enemy's name was "Slime", this script will
    # first scan the note for a specific spritesheet, and if it does not find
    # it, this script will then search for a file by the enemy's name combined
    # with this suffix. If the suffix was "_animated", it'd look for 
    # "Sline_animated"
    ANIM_SUFFIX = "_animated"
    
    # Do you want to flip enemy's spritesheets by default?
    FLIP_ENEMIES = true
    
    # Don't touch.
    PLAYER_SPOTS = []
    
    # This is where an actor's battler is displayed on the screen.
    # You can add one for each actor by following this format:
    # PLAYER_SPOTS[party_index] = [x, y]
    PLAYER_SPOTS[0] = [315, 50]
    PLAYER_SPOTS[1] = [335, 80]
    PLAYER_SPOTS[2] = [355, 110]
    PLAYER_SPOTS[3] = [375, 140]
    
    # Do you want the battlers to move to the target when attacking?
    MOVE_TO_TARGET = true
    
    # This is the amount of time it takes to move an animated battler to their
    # target during a physical attack. This is in seconds.
    TIME_TO_MOVE = 0.5
    
    # This is a switch to turn animated battlers off and to revert to normal.
    TURN_OFF = 0
    
    # This is the percent of hp a battler's current hp has to be below to be
    # considered "critical condition"
    CRIT_PERC = 25
    
    # What is an enemy's default attack animation id?
    ENEMY_DEF_ANIM = 1
    
    # This is the harder config, fair warning.
    # By default, these options work with Holder's animated battlers.
    # These are used to determine which condition goes to which row on
    # the sheet.
    # :symbol => row_id
    POSE_ROWS = {
    
      :idle => 0,
      :guard => 1,
      :state => 2,
      :damage => 3,
      :attack => 4,
      :item => 5,
      :skill => 6,
      :magic => 7,
      :advance => 8,
      :retreat => 9,
      :victory => 10,
      :begin => 11,
      :dead => 12,
      :credits => 13
    
    }
    
    #---------------------------------------------------------------------------
    # This is the most difficult and optional config.
    # You may set specific amounts of frames, and speed for each row of
    # specific spritesheets.
    # "SheetName" => {row_index => [frames, speed], next_row => [frames, speed]}
    # row_index is which row you're configuring
    # frames is how many frames there are on this row
    # speed if how long it takes to make from one frame to the other.
    #---------------------------------------------------------------------------
    ROW_CONFIG = {
    
      "ExampleSheet" => {
        0 => [14, 10],
        1 => [7, 10]
      },
      "ExampleSheet_paladin" => {
        8 => [27, 20],
        9 => [3, 5]
      }
    }
    
    # This is the default for rows for every sheet if you need to change them.
    # It follows the format of the second hash in the above config.
    # row_index => [frames, speed]
    ROW_HASHES = {}
    
    # Don't touch these.
    ROW_HASHES.default = [ANIMATION_FRAMES, ANIMATION_SPEED]
    ROW_CONFIG.default = ROW_HASHES
    
  end
end

#===============================================================================
# DON'T EDIT FURTHER UNLESS YOU KNOW WHAT TO DO.
#===============================================================================

($imported ||= {})[:jet] ||= {}
$imported[:jet][:AnimatedBattlers] = true

class Game_Actor
  
  def screen_x
    Jet::AnimatedBattlers::PLAYER_SPOTS[self.index][0] rescue 0
  end
  
  def screen_y
    Jet::AnimatedBattlers::PLAYER_SPOTS[self.index][1] rescue 0
  end
  
  def screen_z
    100
  end
  
  def battler_name
    self.actor.name
  end
end

class Game_Enemy
  
  def atk_animation_id1
    begin
      self.enemy.note.match(/<atk[ ]*anim[ ]*(\:|=)[ ]*(\d+)/i)[2]
    rescue
      Jet::AnimatedBattlers::ENEMY_DEF_ANIM
    end
  end
  
  def atk_animation_id2
    0
  end
end

class << Cache
  
  alias jet3746_load_bitmap load_bitmap
  def load_bitmap(*args, &block)
    (jet3746_load_bitmap(*args, &block)).dup
  end
end

class Game_Battler
  
  attr_accessor :animation_row
  attr_accessor :animation_delay
  
  alias jet1824_initialize initialize
  def initialize(*args, &block)
    @animation_row = Jet::AnimatedBattlers::POSE_ROWS[:idle]
    @animation_delay = 0
    jet1824_initialize(*args, &block)
  end
  
  def animated?
    false
  end
  
  def full_frame_time
    self.animation_frames * self.animation_speed
  end
  
  alias jet3745_on_damage on_damage
  def on_damage(*args, &block)
    jet3745_on_damage(*args, &block)
    if !dead?
      @animation_row = guard? ? @animation_row : Jet::AnimatedBattlers::POSE_ROWS[:damage]
      @animation_delay = self.full_frame_time
    end
  end
  
  def pose_state?
    states.each {|a|
      return true unless a.id == 1 || !(a.note =~ /<anim[ ]*no[ ]*pose>/i).nil?
    }
    return true if self.mhp / self.hp.to_f >= Jet::AnimatedBattlers::CRIT_PERC
    return false
  end
  
  def state_row
    sort_states
    states.each {|a|
      if !(a.note =~ /<anim[ ]*row[ ]*(\:|=)[ ]*(\d+)>/i).nil?
        return $2.to_i
      end
    }
    return Jet::AnimatedBattlers::POSE_ROWS[:state]
  end
  
  def battle_sprite
    return nil unless SceneManager.scene_is?(Scene_Battle)
    SceneManager.scene.spriteset.battler_sprites.each {|a|
      return a if a.battler == self
    }
    return nil
  end
  
  def anim_reset
    @animation_row = Jet::AnimatedBattlers::POSE_ROWS[:idle]
    @animation_delay = 0
    @animated = nil
    @anim_rows = nil
    @anim_speed = nil
    @anim_frames = nil
    @anim_bitmap = nil
  end
end

class << BattleManager
  
  alias jet8335_battle_start battle_start
  def battle_start(*args, &block)
    ($game_party.alive_members + $game_troop.alive_members).each {|a|
      a.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:begin]
      a.animation_delay = a.full_frame_time
    }
    jet8335_battle_start(*args, &block)
  end
  
  alias jet2834_process_victory process_victory
  def process_victory(*args, &block)
    $game_party.alive_members.each {|a|
      a.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:victory]
      a.animation_delay = -1
    }
    jet2834_process_victory(*args, &block)
  end
  
  alias jet3745_process_defeat process_defeat
  def process_defeat(*args, &block)
    $game_troop.alive_members.each {|a|
      a.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:victory]
      a.animation_delay = -1
    }
    jet3745_process_defeat(*args, &block)
  end
end

%w[enemy actor].each {|a|
  aStr = %Q{

    class Game_#{a.capitalize}
      
      def animated?
        @animated ||= (
        note = !(/<anim[ ]*battler[ ]*(\\:|=)[ ]*(.+)>/i =~ #{a}.note).nil?
        name = self.battler_name + Jet::AnimatedBattlers::ANIM_SUFFIX
        graph = (!Cache.battler(name, self.battler_hue).nil? rescue false)
        note || graph)
      end
      
      def animation_rows
        @anim_rows ||= (
        if /<anim[ ]*rows[ ]*(\\:|=)[ ]*(\\d+)/i =~ #{a}.note
          $2.to_i
        else
          Jet::AnimatedBattlers::ANIMATION_ROWS
        end)
      end
      
      def animation_speed
        @anim_speed ||= (
        if /<anim[ ]*speed[ ]*(\\:|=)[ ]*(\\d+)/i =~ #{a}.note
          $2.to_i
        else
          Jet::AnimatedBattlers::ROW_CONFIG[self.animation_bitmap][@animation_row][1]
        end)
      end
      
      def animation_frames
        @anim_frames ||= (
        if /<anim[ ]*frames[ ]*(\\:|=)[ ]*(\\d+)/i =~ #{a}.note
          $2.to_i
        else
          Jet::AnimatedBattlers::ROW_CONFIG[self.animation_bitmap][@animation_row][0]
        end)
      end
      
      def animation_bitmap_name
        @anim_bitmap ||= (
        begin
          self.#{a}.note.match(/<anim[ ]*battler[ ]*(\\:|=)[ ]*(.+)>/i)[2]
        rescue
          self.battler_name + Jet::AnimatedBattlers::ANIM_SUFFIX
        end)
      end
      
      def animation_bitmap
        actor_bitmap = self.animation_bitmap_name
        #{ 
          if a == "actor"
            "class_suffix = (self.class.note.match(
              /<anim[ ]*suffix[ ]*(\:|=)[ ]*(.+)>/i)[2] rescue '')"
          else
            "class_suffix = ''"
          end
        }
        actor_bitmap + (class_suffix || "")
      end
    end
  }
  eval(aStr)
}

class Sprite_Battler
  
  attr_reader :animated
  attr_accessor :anim_pause
  
  alias jet2734_initialize initialize
  def initialize(viewport, battler = nil)
    @animated = (!battler.nil? && battler.animated?) ? true : false
    jet2734_initialize(viewport, battler)
  end
  
  def battler=(new_battler)
    @animated = (!new_battler.nil? && new_battler.animated?) ? true : false
    @battler = new_battler
  end
  
  alias jet8234_update update
  def update(*args, &block)
    @animated = (!@battler.nil? && @battler.animated?) ? true : false
    @animated = false if $game_switches[Jet::AnimatedBattlers::TURN_OFF]
    @animated ? (super; animated_update) : jet8234_update(*args, &block)
  end
  
  def animated_update
    if @old_battler != @battler
      self.bitmap = Cache.battler(@battler.animation_bitmap, @battler.battler_hue)
      @old_battler = @battler
      @use_sprite = true
      init_visibility
      if @battler.enemy?
        self.mirror = Jet::AnimatedBattlers::FLIP_ENEMIES
        if /<anim[ ]*flip>/i =~ @battler.enemy.note
          self.mirror = !self.mirror
        end
      elsif @battler.actor?
        self.mirror = !(/<anim[ ]*flip>/i =~ @battler.actor.note).nil?
      end
    end
    #------------------------
    update_origin
    update_position unless @in_anim_move
    setup_new_effect
    setup_new_animation
    update_effect
    update_battler_pose
    #------------------------
    width = self.bitmap.width
    height = self.bitmap.height
    if @anim_row != @battler.animation_row
      @anim_frame = 0
      @frame_count = 0
    end
    @anim_row = @battler.animation_row
    width = self.bitmap.width / @battler.animation_frames
    height = self.bitmap.height / @battler.animation_rows
    x = @anim_frame * width
    y = @battler.animation_row * height
    self.src_rect.set(x, y, width, height)
    @frame_count += 1
    @anim_pause ||= false
    if @frame_count >= @battler.animation_speed
      @anim_frame += 1
      @frame_count = 0
      if @anim_frame >= @battler.animation_frames
        @anim_frame = @anim_pause ? (@battler.animation_frames - 1) : 0
      end
    end
  end
  
  def update_battler_pose
    if @battler.animation_delay == -1
      return
    end
    if @battler.animation_delay > 0
      @battler.animation_delay -= 1
      return
    end
    if @battler.dead?
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:dead]
    elsif @battler.guard?
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:guard]
    elsif @battler.pose_state?
      @battler.animation_row = @battler.state_row
    else
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:idle]
    end
  end
  
  alias jet7345_update_origin update_origin
  def update_origin(*args, &block)
    if @animated
      self.ox = @battler.enemy? ? self.src_rect.width / 2 : 0
      self.oy = @battler.enemy? ? self.src_rect.height / 2 : 0
    else
      jet7345_update_origin(*args, &block)
    end
  end
  
  alias jet2734_revert_to_normal revert_to_normal
  def revert_to_normal(*args, &block)
    jet2734_revert_to_normal(*args, &block)
    if @animated
      self.ox = @battler.enemy? ? self.src_rect.width / 2 : 0
      self.oy = @battler.enemy? ? self.src_rect.height / 2 : 0
    end
  end
  
  alias jet8344_start_effect start_effect
  def start_effect(effect)
    return if effect == :collapse && @animated
    jet8344_start_effect(effect)
  end
  
  def anim_move_to(target)
    self.z = 101
    return unless Jet::AnimatedBattlers::MOVE_TO_TARGET
    min_x = target.x - target.src_rect.width / 2 + self.src_rect.width / 2
    min_x -= self.src_rect.width / 3
    max_x = target.x + target.src_rect.width / 2 - self.src_rect.width / 2
    max_x += self.src_rect.width / 3
    @orig_x ||= self.x
    @orig_y ||= self.y
    if self.x > min_x && @orig_x > min_x
      x = min_x
    elsif self.x < max_x && @orig_x < min_x
      x = max_x
    else
      x = self.x
    end
    if self.y > target.y + target.src_rect.height / 2
      y = target.y + target.src_rect.height / 2
    elsif self.y < target.y - target.src_rect.height / 2
      y = target.y - target.src_rect.height / 2
    else
      y = self.y
    end
    if x > self.x
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:retreat]
    else
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:advance]
    end
    @battler.animation_delay = -1
    @in_anim_move = true
    do_tween(x, y, Tween::Linear, Jet::AnimatedBattlers::TIME_TO_MOVE)
    until @tween.nil?
      [SceneManager.scene.spriteset, Graphics].each {|a| a.update }
    end
  end
  
  def anim_return
    self.z = 100
    return unless Jet::AnimatedBattlers::MOVE_TO_TARGET
    @orig_x = nil
    @orig_y = nil
    x = @battler.screen_x
    y = @battler.screen_y
    if x >= self.x
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:retreat]
    else
      @battler.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:advance]
    end
    @battler.animation_delay = -1
    do_tween(x, y, Tween::Linear, Jet::AnimatedBattlers::TIME_TO_MOVE)
    until @tween.nil?
      [SceneManager.scene.spriteset, Graphics].each {|a| a.update }
    end
    @in_anim_move = false
    @battler.animation_delay = 0
  end
end

class Scene_Battle
  
  attr_reader :spriteset
  
  alias jet3845_show_normal_animation show_normal_animation
  def show_normal_animation(targets, animation_id, mirror = false)
    if !$game_switches[Jet::AnimatedBattlers::TURN_OFF]
      animation = $data_animations[animation_id]
      if animation
        did_to_screen = false
        targets.each do |target|
          next if did_to_screen
          @subject.animation_delay = 0
          @subject.battle_sprite.anim_pause = false
          obj = @subject.current_action.item
          if @subject.battle_sprite.animated
            if obj.physical?
              @subject.battle_sprite.anim_move_to(target.battle_sprite)
            end
          end
          target.animation_id = animation_id
          target.animation_mirror = mirror
          did_to_screen = animation.to_screen?
          case obj
          when RPG::Item
            @subject.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:item]
          when RPG::Skill
            if obj.id == @subject.attack_skill_id
              @subject.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:attack]
            elsif obj.magical?
              @subject.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:magic]
            elsif obj.id != @subject.guard_skill_id
              @subject.animation_row = Jet::AnimatedBattlers::POSE_ROWS[:skill]
            end
          end
          @subject.animation_delay = -1
          @subject.battle_sprite.anim_pause = true
          abs_wait_short unless animation.to_screen?
        end
        abs_wait_short if animation.to_screen?
      end
    else
      jet3845_show_normal_animation(*args, &block)
    end
  end
  
  alias jet3745_terminate terminate
  def terminate(*args, &block)
    jet3745_terminate(*args, &block)
    $game_party.members.each {|a| a.anim_reset }
  end
  
  alias jet3434_use_item use_item
  def use_item(*args, &block)
    jet3434_use_item(*args, &block)
    @subject.animation_delay = 0
    @subject.battle_sprite.anim_pause = false
    if @subject.battle_sprite.animated
      if @subject.current_action.item.physical?
        @subject.battle_sprite.anim_return
      end
    end
  end
  
  alias jet3345_show_attack_animation show_attack_animation
  def show_attack_animation(targets)
    if !$game_switches[Jet::AnimatedBattlers::TURN_OFF]
      show_normal_animation(targets, @subject.atk_animation_id1, false)
      show_normal_animation(targets, @subject.atk_animation_id2, true)
    else
      jet3345_show_attack_animation(*args, &block)
    end
  end
end

class Sprite
  
  attr_reader :tween
  
  def calculate_delta
    @this_frame = Time.now
    @delta = ((@this_frame - @last_frame) * 1000.0).to_i / 1000.0
    @last_frame = @this_frame
  end
  
  def do_tween(new_x, new_y, style = Tween::Linear, time = 1)
    @last_frame = Time.now
    @tween = Tween.new([self.x.to_f, self.y.to_f], [new_x.to_f, new_y.to_f],
      style, time)
  end
  
  alias jet2724_update update unless $@
  def update(*args, &block)
    jet2724_update(*args, &block)
    if !@tween.nil?
      calculate_delta
      @tween.update(@delta)
      self.x, self.y = @tween.x, @tween.y
      @tween = nil if @tween.done
    end
  end
end
    
class Tween
  attr_reader :done
  attr_reader :easer
  
  def initialize(start, finish, easer, duration)
    @start, @finish = start, finish
    @easer, @duration = easer, duration
    unless @start.is_a? Enumerable
      @start = [@start]
    end
    unless @finish.is_a? Enumerable
      @finish = [@finish]
    end
    @time = 0
    @done = false
  end
  
  def update(delta)
    @time += delta
    if @time > @duration
      @time = @duration
      @done = true
    end
  end
  
  def [](idx)
    @easer.ease(
      @time,
      @start[idx],
      (@finish[idx] - @start[idx]),
      @duration
    )
  end
  
  def value; self[0]; end
  def x; self[0]; end
  def y; self[1]; end
  def z; self[2]; end
  
  module Linear
    def self.ease(t, st, ch, d)
      ch * t / d + st
    end
  end
end