#==============================================================================
# ** Multiple Damages
#------------------------------------------------------------------------------
# SephirothSpawn
# Version 1
# 2007-02-12
# SDK : Version 2.0, Part 1
#------------------------------------------------------------------------------
# * Version History :
#
#  Version 1 ---------------------------------------------------- (2007-02-12)
#------------------------------------------------------------------------------
# * Description :
#
#  This script was designed to show multiple damage sprites at the same time.
#  When a damage sprite is created, it is immediately added to an array of
#  damage sprites. From there, each damage sprite is handeled the same way
#  the default damage sprite is handeled. This also delays damages to prevent
#  multiple damages being displayed at once.
#------------------------------------------------------------------------------
# * Instructions :
#
#  Place The Script Below the SDK and Above Main.
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
SDK.log('Multiple Damages', 'SephirothSpawn', 1, '2007-02-12')
SDK.check_requirements(2, [1])

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
if SDK.enabled?('Multiple Damages')

#==============================================================================
# ** RPG::Sprite
#==============================================================================

class RPG::Sprite < ::Sprite
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  if @seph_multidamage_stack.nil?
    alias_method :seph_multidamage_rpgs_init, :initialize
    alias_method :seph_multidamage_rpgs_disp, :dispose
    alias_method :seph_multidamage_rpgs_dmge, :damage
    alias_method :seph_multidamage_rpgs_updt, :update
    @seph_multidamage_stack = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
    # Original Initialization
    seph_multidamage_rpgs_init(viewport)
    # Create Damage Sprite Array
    @_multi_damage_sprites  = []
    @_multi_damage_duration = []
    # Damage Delay Count
    @_damages_delay_count = 0
    @_damages_pops_coming = []
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    # Original Dispose
    seph_multidamage_rpgs_disp
    # Pass Through Multi-Damage Sprites
    for sprite in @_multi_damage_sprites
      sprite.dispose unless sprite.nil?
    end
  end
  #--------------------------------------------------------------------------
  # * Damage
  #--------------------------------------------------------------------------
  def damage(value, critical)
    # Adds Damage to Pop List
    unless value.nil? && critical.nil?
      @_damages_pops_coming << [value, critical]
    end
    # Return If Damage Delay
    return if @_damages_delay_count > 0
    # Start Damage Count
    @_damages_delay_count = 8
    # Gets Pops Coming
    value, critical = *@_damages_pops_coming.shift
    # Original Damage Method
    seph_multidamage_rpgs_dmge(value, critical)
    # Creates Sprite
    sprite = ::Sprite.new(self.viewport)
    sprite.bitmap = @_damage_sprite.bitmap
    range = (-16..16).to_a
    sprite.ox = @_damage_sprite.ox + range[rand(range.size)]
    sprite.oy = @_damage_sprite.oy + range[rand(range.size)]
    sprite.x  = @_damage_sprite.x
    sprite.y  = @_damage_sprite.y
    sprite.z = 3000
    # Adds Duplicated Sprite to Damage Sprites Array
    @_multi_damage_sprites  << sprite
    @_multi_damage_duration << 40
    # Deletes Damage Sprite
    @_damage_sprite.dispose
    @_damage_sprite = nil
    @_damage_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If Damage Delaying
    if @_damages_delay_count > 0
      @_damages_delay_count -= 1
    # If Damage Not Delaying
    else
      # If Damages Waiting to Be Popped
      if @_damages_pops_coming.size > 0
        # Create Damage Sprite
        damage(nil, nil)
      end
    end
    # Original Update
    seph_multidamage_rpgs_updt
    # Pass through Every Damage Sprite
    for i in 0...@_multi_damage_duration.size
      # Decrease Duration
      @_multi_damage_duration[i] -= 1
      # Move Damage Sprite
      case @_multi_damage_duration[i]
      when 38..39
        @_multi_damage_sprites[i].y -= 4
      when 36..37
        @_multi_damage_sprites[i].y -= 2
      when 34..35
        @_multi_damage_sprites[i].y += 2
      when 28..33
        @_multi_damage_sprites[i].y += 4
      end
      # Adjust Opacity
      @_multi_damage_sprites[i].opacity = 256 - (12 -
                                          @_multi_damage_duration[i]) * 32
      # If Damage Duration Complete
      if @_multi_damage_duration[i] == 0
        # Delete All Remaining Damage Sprites
        for n in i...@_multi_damage_duration.size
          @_multi_damage_duration.delete_at(n)
          unless @_multi_damage_sprites[n].nil?
            @_multi_damage_sprites[n].dispose
            @_multi_damage_sprites[n] = nil
            @_multi_damage_sprites.delete_at(n)
          end
        end
        break
      end
    end
  end
end

#------------------------------------------------------------------------------
# * End SDK Enable Test
#------------------------------------------------------------------------------
end

=begin
==============================================================================
 ●● Multi-Attack
------------------------------------------------------------------------------
 Trickster (tricksterguy@hotmail.com)
 Version 4.0
 Date 4/13/07

 Instructions:
  1) Create your animation like usual
  2) Determine how many hits you want the animation to do
  3) What you will be doing now is adding blank SE/Timing Events
      That means a Timing that only has a frame nummber, no SE no Flash
      If you don't get what I mean there are examples
      1) The Cross Cut Animation is one with a example of 2 attacks
      2) The Octo Slash Animation is an example of one with 8 attacks
  4) If only one hit determine where you want the damage to show
      note: if its at the last frame of the animation the script will
            automatically do this for you
  5) If more than one hit determine where you want the damage to show
      note: if its at the last frame then you must put a blank at the end
      note: give a few frames (3-5) between damage
  6) Give the skill/weapon/item/enemy the animation and you are done the
      script takes care of the rest
==============================================================================
=end
#--------------------------------------------------------------------------
# ● Begin SDK Log
#--------------------------------------------------------------------------
SDK.log('Multi-Attack', 'Trickster', 4.0, '4/13/07')
#--------------------------------------------------------------------------
# Begin SDK Requirement Check
#--------------------------------------------------------------------------
SDK.check_requirements(2.0, [1, 2], ['Multiple Damages'])
#--------------------------------------------------------------------------
# ● Begin SDK Enabled Check
#--------------------------------------------------------------------------
if SDK.enabled?('Multi-Attack')
 
class Sprite_Battler
  #---------------------------------------------------------------------------
  # ● Sprite Animation
  #---------------------------------------------------------------------------
  SDK.log_overwrite(:Sprite_Battler, :sprite_animation)
  def sprite_animation
    # If Animation Is Defined
    if $data_animations[@battler.animation_id.to_i] != nil
      # Set Animaton
      @animation = $data_animations[@battler.animation_id]
      # Show Animation
      animation(@animation, @battler)
      # Set Animation id to 0
      @battler.animation_id = 0
      # Reset Damage Pop Flag
      @battler.damage_pop = false
    else
      # Reset Animation
      @animation = nil
    end
  end
  #---------------------------------------------------------------------------
  # ● Sprite Damage
  #---------------------------------------------------------------------------
  alias_method :trick_multiattack_battler_sprite_damage, :sprite_damage
  def sprite_damage
    # Return if Animation or animation is not nil
    return if @battler.animation_id != 0 or not @animation.nil?
    # The Usual
    trick_multiattack_battler_sprite_damage
  end
  #---------------------------------------------------------------------------
  # ● Sprite Collaspe
  #---------------------------------------------------------------------------
  alias_method :trick_multiattack_battler_sprite_collapse, :sprite_collapse
  def sprite_collapse
    # Return unless animation is nil
    return unless @animation.nil?
    # Run Collapse Effect
    trick_multiattack_battler_sprite_collapse
  end
end

class Scene_Battle
  #---------------------------------------------------------------------------
  # ● Public Instance Variables
  #---------------------------------------------------------------------------
  attr_reader :phase4_step
end

class RPG::Sprite
  #---------------------------------------------------------------------------
  # ● Animation
  #---------------------------------------------------------------------------
  def animation(animation, hit)
    # Dispose Old Animation
    dispose_animation
    # Set Animation
    @_animation = animation
    # Return if animation is nil
    return if @_animation == nil
    # Flag for Damage Popping
    @damage_pop = false
    # If battler is defined
    if @battler.is_a?(Game_Battler)
      # Save Battler
      @_animation_battler = @battler
      # Get Animation Hit
      @_animation_hit = @_animation_battler.animation_hit
      # Get all of the Damage and Critical Hits
      @_animation_damage = @_animation_battler.damage_hits.to_a
      @_animation_critical = @_animation_battler.critical_hits.to_a
      # Recreate Animation Hit
      @_animation_hit = []
      # Run Through Each Damage
      @_animation_damage.each {|damage| @_animation_hit << (damage != "Miss")}
    else
      # Set Hit
      @_animation_hit = hit
    end
    # No Damage Pop if After Second Animation Id Phase
    @damage_pop = true if ($game_temp.in_battle and
                          [5,9].include?($scene.phase4_step))
    # Setup Animation Like usual
    @_animation_duration = @_animation.frame_max
    # Get Animation name and hue
    animation_name = @_animation.animation_name
    animation_hue = @_animation.animation_hue
    # Get Animation Bitmap
    bitmap = RPG::Cache.animation(animation_name, animation_hue)
    # If Number of References include bitmap
    if @@_reference_count.include?(bitmap)
      # Increase refenece count
      @@_reference_count[bitmap] += 1
    else
      # Set Reference count to 1
      @@_reference_count[bitmap] = 1
    end
    # Setup Animation Sprite Array
    @_animation_sprites = []
    # If Position is not full screen and animations doesn't include animation
    if @_animation.position != 3 or not @@_animations.include?(@_animation)
      # Do 16 times
      16.times do
        # Create Sprite
        sprite = ::Sprite.new(viewport)
        # Set Bitmap
        sprite.bitmap = bitmap
        # Set to invisible
        sprite.visible = false
        # Add to Sprites
        @_animation_sprites << sprite
      end
      # Push Animation unless already there
      @@_animations << @_animation unless @@_animations.include?(@_animation)
    end
    # Update Animation
    update_animation
  end
  #---------------------------------------------------------------------------
  # ● Update Animation
  #---------------------------------------------------------------------------
  def update_animation
    # If Duration is greater than 0
    if @_animation_duration > 0
      # Get Frame index
      frame_index = @_animation.frame_max - @_animation_duration
      # Get Cell Data
      cell_data = @_animation.frames[frame_index].cell_data
      # Get Position
      position = @_animation.position
      # Set Sprites
      animation_set_sprites(@_animation_sprites, cell_data, position)
      # If in battle
      if $game_temp.in_battle
        # Copy Damage Frames
        damage_frames = @_animation.damage_frames.dup
        # Set Union Add 0 and Max
        damage_frames = damage_frames | [0, @_animation.frame_max]
        # Sort Frames (Restore order)
        damage_frames.sort!
        # Declare Local Variable index
        index = nil
        # Run Through with next element
        damage_frames.each_with_next_and_index do |start, finish, i|
          # Set Index if no frames
          index = i if (start..finish) === frame_index
        end
      end
      # Run Through all Timings
      @_animation.timings.each do |timing|
        # Skip if not at a timing effect
        next if timing.frame != frame_index or timing.damage?
        # If In Battle
        if $game_temp.in_battle
          # Send Animation Hit at Index
          animation_process_timing(timing, @_animation_hit[index])
        else
          # Do Things Like normal
          animation_process_timing(timing, @_animation_hit)
        end
      end
      # If in Battle
      if $game_temp.in_battle and @damage_pop
        # Run Through All Damage Frames
        if @_animation.damage_frames.include?(frame_index)
          # Display Damage
          damage(@_animation_damage.shift, @_animation_critical.shift)
        end
      end
    else
      # If Damage Pop and In Battle
      if @damage_pop and $game_temp.in_battle
        # Reset Damage and Critical Flag
        @_animation_battler.damage = nil
        @_animation_battler.critical = false
        # Collapse Effects?
        trick_multiattack_battler_sprite_collapse
      end
      # Dispose Animation
      dispose_animation
    end
  end
end
#--------------------------------------------------------------------------
#  End SDK Enabled Check
#--------------------------------------------------------------------------
end

#--------------------------------------------------------------------------
# ● Begin SDK Enabled Check
#--------------------------------------------------------------------------
if SDK.enabled?('Multi-Attack')
 
class RPG::Animation
  #-------------------------------------------------------------------------
  # ● Damage Popping Frames
  #-------------------------------------------------------------------------
  def damage_frames
    # Set Damage Frames if not set
    set_damage_frames if @damage_frames.nil?
    # Return Damage Frames
    return @damage_frames
  end
  #-------------------------------------------------------------------------
  # ● Set Damage Frames
  #-------------------------------------------------------------------------
  def set_damage_frames
    # Setup Array
    damage_frames = []
    # Run Through Each Timing
    @timings.each do |timing|
      # Skip if not a damage frame
      next if not timing.damage?
      # Add Frame
      damage_frames << timing.frame
    end
    # Push Last if empty
    damage_frames << (self.frame_max-1) if damage_frames.empty?
    # Sort Frames
    @damage_frames = damage_frames.sort
  end
  #---------------------------------------------------------------------------
  # ● Animation Number of Hits
  #---------------------------------------------------------------------------
  def hits
    # Set Damage Frames if damage frames is undefined
    set_damage_frames if @damage_frames.nil?
    # Return number of damage frames
    return @damage_frames.size
  end
end
 
class RPG::Animation::Timing
  #-------------------------------------------------------------------------
  # ● Damage Pop Check
  #-------------------------------------------------------------------------
  def damage?
    return (self.se.name.empty? and self.flash_scope == 0 and
    self.flash_duration == 5 and self.condition == 0)
  end
end
#--------------------------------------------------------------------------
# ● End SDK Enabled Check
#--------------------------------------------------------------------------
end

#--------------------------------------------------------------------------
# ● Begin SDK Enabled Check
#--------------------------------------------------------------------------
if SDK.enabled?('Multi-Attack')
 
module RPG
class Weapon
  #---------------------------------------------------------------------------
  # ● Number of Hits
  #---------------------------------------------------------------------------   
  def hits
    # Get Animation
    animation = $data_animations[animation2_id]
    # If Animation is nil return 1 else return number of hits
    return animation.nil? ? 1 : animation.hits
  end
end
 
class Skill
  #---------------------------------------------------------------------------
  # ● Number of Hits
  #---------------------------------------------------------------------------
  def hits
    # Get Animation
    animation = $data_animations[animation2_id]
    # If Animation is nil return 1 else return number of hits
    return animation.nil? ? 1 : animation.hits
  end
end
   
class Item
  #---------------------------------------------------------------------------
  # ● Number of Hits
  #---------------------------------------------------------------------------
  def hits
    # Get Animation
    animation = $data_animations[animation2_id]
    # If Animation is nil return 1 else return number of hits
    return animation.nil? ? 1 : animation.hits
  end
end
end
 
class Game_Battler
  #---------------------------------------------------------------------------
  # ● Number of Hits
  #---------------------------------------------------------------------------
  def hits
    # Get Animation
    animation = $data_animations[animation2_id]
    # If Animation is nil return 1 else return number of hits
    return animation.nil? ? 1 : animation.hits
  end
end
#--------------------------------------------------------------------------
# ● End SDK Enabled Check
#--------------------------------------------------------------------------
end

#--------------------------------------------------------------------------
# ● Begin SDK Enabled Check
#--------------------------------------------------------------------------
if SDK.enabled?('Multi-Attack')
class Game_Battler
  #---------------------------------------------------------------------------
  # ● Public Instance Variables
  #---------------------------------------------------------------------------
  attr_reader :damage_hits
  attr_reader :critical_hits
  #---------------------------------------------------------------------------
  # ● Object Initialization
  #---------------------------------------------------------------------------
  alias_method :trick_multiattack_battler_initialize, :initialize
  def initialize
    # The Usual
    trick_multiattack_battler_initialize
    # Setup Instance Variables
    @damage_hits = []
    @critical_hits = []
  end
  #---------------------------------------------------------------------------
  # ● Attack Effect
  #---------------------------------------------------------------------------
  alias_method :trick_multiattack_battler_attack_effect, :attack_effect
  def attack_effect(attacker)
    # Clear Damage Info Arrays
    @damage_hits.clear
    @critical_hits.clear
    # Initialize Total Damage
    total_damage = 0
    # Do Attacker Hits Times
    attacker.hits.times do
      # The Usual
      trick_multiattack_battler_attack_effect(attacker)
      # Push Damage Done
      @damage_hits << self.damage
      # Add to Total Damage if a number
      total_damage += self.damage if self.damage.is_a?(Numeric)
      # Push Critical Flag
      @critical_hits << self.critical
    end
    # Set Damage
    self.damage = total_damage
    # Flatten Arrays
    @damage_hits.flatten!
    @critical_hits.flatten!
    # Return True
    return true
  end
  #---------------------------------------------------------------------------
  # ● Skill Effect
  #---------------------------------------------------------------------------
  alias_method :trick_multiattack_battler_skill_effect, :skill_effect
  def skill_effect(user, skill)
    # Clear Damage Info Arrays
    @damage_hits.clear
    @critical_hits.clear
    # Setup Effective Array
    effective = []
    # Initialize Total Damage
    total_damage = 0
    # Do Skill Hits Times
    skill.hits.times do
      # The Usual
      effective << trick_multiattack_battler_skill_effect(user, skill)
      # Push Damage Done
      @damage_hits << self.damage
      # Add to Total Damage if a number
      total_damage += self.damage if self.damage.is_a?(Numeric)
      # Push Critical Flag
      @critical_hits << self.critical
    end
    # Set Damage
    self.damage = total_damage
    # Flatten Arrays
    @damage_hits.flatten!
    @critical_hits.flatten!
    # Return Any Skill Was effective
    return effective.include?(true)
  end
  #---------------------------------------------------------------------------
  # ● Item Effect
  #--------------------------------------------------------------------------- 
  alias_method :trick_multiattack_battler_item_effect, :item_effect
  def item_effect(item)
    # Clear Damage Info Arrays
    @damage_hits.clear
    @critical_hits.clear
    # Setup Effective Array
    effective = []
    # Initialize Total Damage
    total_damage = 0
    # Do Item Hits Times
    item.hits.times do
      # The Usual
      effective << trick_multiattack_battler_item_effect(item)
      # Push Damage Done
      @damage_hits << self.damage
      # Add to Total Damage if a number
      total_damage += self.damage if self.damage.is_a?(Numeric)
      # Push Critical Flag
      @critical_hits << self.critical
    end
    # Set Damage
    self.damage = total_damage
    # Flatten Arrays
    @damage_hits.flatten!
    @critical_hits.flatten!
    # Return Any Skill Was effective
    return effective.include?(true)
  end
end
#--------------------------------------------------------------------------
# ● End SDK Enabled Check
#--------------------------------------------------------------------------
end