#======================#
                            #  Z-Systems by: Zetu  #
#===========================#======================#===========================#
#                    *  *  *  Alternate MP X v3.01  *  *  *                    #
#------------------------------------------------------------------------------#
#  Will Overwrite Draw Functions for MP.                                       #
#------------------------------------------------------------------------------#
# Known Compatable Battle Systems:                                             #
#   • Tankentai                                                                #
#------------------------------------------------------------------------------#
# Version History                                                              #
#  3.01 ALPHA                                                                  #
#=#==========================================================================#=#
  #  You may need slight scripting knowledge of working with arrays (but     #
  #  not a whole lot!).                                                      #
  #--------------------------------------------------------------------------#
  #   * * Anything in "< >" means replace with the described contents. * *   #
  #  REQUIRED PARAMETERS (Any resource without it will cause an error)       #
  #    :name, <name of resource>                                             #
  #    :abbv, <1 or 2 character abbv. of resource>                           #
  #    :color, <color 1>, <color 2>                                          #
  #        * These color attributes are indexes of the window skin           #
  #  OPTIONAL PARAMETERS                                                     #
  #  Resource Regen for each turn:                                           #
  #    :regen, <type>, <base>                                                #
  #        type can be :maxmp, :atk, :def, :spi, :agi, :set                  #
  #        base is number multiplied by type (:set is considered 1)          #
  #  Resource Regen on Damage                                                #
  #    :regenondamage, <type>, <base>                                        #
  #        type can be :damage, :maxmp, :set, :percentdmg                    #
  #        base in number multipled by type (:set is considered 1)           #
  #        (:percentdmg is ratio of maxmp and damage)                        #
  #    :regenelemental, <element_id>, <type>, <base>                         #
  #        same as :regenondamage, except on elemental damage (of            #
  #        element_ids) (may place more than 1 id)                           #
  #  Resource Change Out of Battle:                                          #
  #    :depleteoob     (Set to 0)                                            #
  #    :regenoob       (Set to Max)                                          #
  #  Resource Inversion                                                      #
  #    :invert                                                               #
  #        this allows the resource to Add instead of Subtract for its cost  #
  #        and disallows skill use if cost will exceed the maxmp             #
  #==========================================================================
#
module Z11
  
  RESOURCES = [
        :name, "Stamina",
        :abbv, "Stamina",
        :color, 23, 22
      ],[
        :depleteoob,
        :regen, :spi, 0.5,
        :name, "Magic",
        :abbv, "Magic",
        :color, 10, 2
      ]
  # If set to false, use RESBYCLASS's indexes as Actor IDs instead of Class IDs
  BIND_TO_CLASS = true
  
  # <Class ID> => <Array of Resources by :name parameter>
  # Recommended max is 2
  RESBYCLASS = {
    1 => ["Stamina", "Magic"],
    2 => ["Stamina", "Magic"],
    3 => ["Stamina", "Magic"],
  }
  
  # Default value if not in RESBYCLASS hash.
  DEF_RES = "Stamina"
  #=========================================================================#
  #  Note Tags: To be used in notebox        
  #  <regen: mana/stamina> (Heal)
  #  <ampx: mana/stamina> (Damage)
  #=========================================================================#
      #Skill Notes
      
      #States what Resource Skill uses.  Use :name parameter (case insensitive)
      #If tag does not exist, will default to actor's primary resource
      RESOURCECOSTTYPE = /<ampx[: ]+(.*)>/i
#========#======================#====#================================#========#
#--------#                      #----# DO NOT EDIT PAST THIS POINT!!! #--------#
#--------# End of Customization #----# Editing will cause death by    #--------#
#--------#                      #----# brain asplosions.              #--------#
#========#======================#====#================================#========#
  def self.get_resource_index(type)
    for array in RESOURCES
      if array[array.index(:name)+1].upcase == type.upcase
        return RESOURCES.index(array)
      end
    end
    return -1
  end
  
end

class Game_Resources
  
  attr_reader :name, :abbv, :color1, :color2, :value, :regenelemental,
      :regentype, :regenbase, :regenodtype, :regenodbase, :tags
  attr_accessor :max
  
  def initialize(type, actor)
    @index = Z11::get_resource_index(type)
    @actor = actor
    scan_object_variables(type)
  end
  
  def scan_object_variables(type)
    i = 0
    array=Z11::RESOURCES[@index]
    @tags = []
    @max = @actor.maxmp
    @value = @max
    @maxdefault = true
    @regenelemental = {}
    while (i < array.size)
      case array[i]
      when :name; @name = array[i+1]; i+=1
      when :abbv; @abbv = array[i+1]; i+=1
      when :color; @color1 = array[i+1]; @color2 = array[i+2]; i+=2
      when :regen; @regentype = array[i+1]; @regenbase = array[i+2]; i+=2
      when :regenondamage
        @regenodtype = array[i+1]
        @regenodbase = array[i+2]
        i+=2
      when :regenelemental
        i+=1
        id = []
        while (array[i].is_a?(Integer))
          id.push(array[i])
          i+=1
        end
        for n in id
          @regenelemental[n]= array[i], array[i+1]
        end
        i+=1
      when :max
        @max = array[i+1]
        i+=1
        @value = [@max, @value].min
        @maxdefault = false
      when :depleteoob; @tags.push(:depleteoob); @value = 0
      when :regenoob; @tags.push(:regenoob)
      when :invert; @tags.push(:invert)
      end
      i+=1
    end
  end
  
  def value=(new_value)
    @value = [[new_value, 0].max, @max].min
  end
  
end

class Game_Actor < Game_Battler
  
  alias ampx_setup setup
  def setup(actor_id)
    ampx_setup(actor_id)
    @ampx = []
    for resource in self.resources
      @ampx.push(Game_Resources.new(resource,self))
    end
  end
  
  def resources
    if Z11::BIND_TO_CLASS
      result = Z11::RESBYCLASS[self.class_id]
    else
      result = Z11::RESBYCLASS[self.actor_id]
    end
    return result.nil? ? [Z11::DEF_RES] : result
  end
  
  alias z11ed execute_damage unless $@
  def execute_damage(user)
    z11ed(user)
    ampx_on_hit(@hp_damage)
    self.mp -= @mp_damage####
    if @absorbed
      user.mp += @mp_damage####
    end
  end
  
  def resourcenameof(skill)
    skill.note.scan(Z11::RESOURCECOSTTYPE){
      return $1.upcase
    }
    return self.ampx[0].name.upcase
  end
  
end

class Game_Enemy < Game_Battler####
  
  alias ampx_initialize initialize
  def initialize(index, enemy_id)
    ampx_initialize(index, enemy_id)
    @ampx = [Game_Resources.new(Z11::DEF_RES,self)]
  end
  
  def resources
    return [Z11::DEF_RES]
  end
  
  def resourcenameof(skill)
    return Z11::DEF_RES
  end
  
end

class Game_Battler
  attr_reader :ampx
  
  def skill_can_use?(skill)
    return false unless skill.is_a?(RPG::Skill)
    return false unless movable?
    return false if silent? and skill.spi_f > 0
    resource = skill.resourceof(self)
    return false unless self.ampx.include?(resource)
    if resource.tags.include?(:invert)
      return false if calc_mp_cost(skill) + resource.value > resource.max
    else
      return false if calc_mp_cost(skill) > resource.value
    end
    if $game_temp.in_battle
      return skill.battle_ok?
    else
      return skill.menu_ok?
    end
  end
  
  alias z11ed execute_damage unless $@
  def execute_damage(user)
    z11ed(user)
    ampx_on_hit(@hp_damage)
    self.mp -= @mp_damage####
    if @absorbed
      user.mp += @mp_damage####
    end
  end
  
  def ampx_on_hit(damage)
    return unless damage > 0
    for resource in @ampx
      next if resource.regenodtype.nil?
      value = resource.regenodbase
      case resource.regenodtype
      when :damage
        value *= damage
      when :maxmp
        value *= resource.max
      when :percentdmg
        value *= 100*damage/resource.max
      end
      resource.value += value.to_i
      next if @obj.nil?
      total = 0
      value = 0
      for i in @obj.element_set
        if resource.regenelemental.key?(i)
          value = resource.regenelemental[i][1]
          case resource.regenelemental[i][0]
          when :damage;     value *= damage
          when :maxmp;      value *= resource.max
          when :percentdmg; value *= 100*damage/resource.max
          end
          total+=1
        end
      end
      resource.value += (value/total).to_i if total != 0
    end
  end
  
  def recover_all
    @hp = maxhp
    return if @ampx.nil?
    for resource in @ampx
      unless resource.tags.include?(:depleteoob)
        resource.value = resource.max
      end
    end
    for i in @states.clone
      remove_state(i)
    end
  end
    
  alias z11modv make_obj_damage_value unless $@
  def make_obj_damage_value(user, obj)
    @obj = obj
    z11modv(user,obj)
  end
  
  alias z11madv make_attack_damage_value
  def make_attack_damage_value(attacker)
    @obj = nil
    z11madv(attacker)
  end
    
end

class Scene_Base
  alias old_main main unless $@
  def main
    old_main
    refresh_zsr
  end
  
  def refresh_zsr
    for actor in $game_party.members
      for resource in actor.ampx
        if resource.tags.include?(:regenoob)
          resource.value=resource.max
        elsif resource.tags.include?(:depleteoob)
          resource.value=0
        end
      end
    end
  end
  
end

class Scene_Battle < Scene_Base
  
  def regen_ampx(actor)
    return if actor.dead?
    for resource in actor.ampx
      next if resource.regentype.nil?
      value = resource.regenbase
      case resource.regentype
      when :maxmp; value *= resource.max
      when :atk;   value *= actor.atk
      when :def;   value *= actor.def
      when :spi;   value *= actor.spi
      when :agi;   value *= actor.agi
      end
      resource.value += value.to_i
    end
    @status_window.refresh
  end
  
  def refresh_zsr
    for actor in $game_party.members
      for resource in actor.ampx
        if resource.tags.include?(:regenoob)
          resource.value = resource.max
        elsif resource.tags.include?(:depleteoob)
          resource.value = 0
        end
      end
    end
  end
  
end

class Scene_Skill < Scene_Base
  
  def use_skill_nontarget                                            # OVERWRITE
    Sound.play_use_skill
    resource = @skill.resourceof(@actor)
    if resource.tags.include?(:invert)
      resource.value += @actor.calc_mp_cost(@skill)
    else
      resource.value -= @actor.calc_mp_cost(@skill)
    end
    @status_window.refresh
    @skill_window.refresh
    @target_window.refresh
    if $game_party.all_dead?
      $scene = Scene_Gameover.new
    elsif @skill.common_event_id > 0
      $game_temp.common_event_id = @skill.common_event_id
      $scene = Scene_Map.new
    end
  end
  
end

class Scene_Item < Scene_Base
  
  def use_item_nontarget                                             # OVERWRITE
    Sound.play_use_item
    $game_party.consume_item(@item)
    @item_window.draw_item(@item_window.index)
    @target_window.refresh
    if $game_party.all_dead?
      $scene = Scene_Gameover.new
    elsif @item.common_event_id > 0
      $game_temp.common_event_id = @item.common_event_id
      $scene = Scene_Map.new
    end
  end
  
end

class RPG::Skill < RPG::UsableItem
  
  def resourceof(actor)
    unless actor.actor?
      return actor.ampx[0]
    end
    name = actor.resourcenameof(self)
    for resource in actor.ampx
      if resource.name.upcase==name
        return resource
      end
    end
    print "Error: def resourceof(#{actor.name}) for skill #{self.name} returned nil, type #{name}"
  end
  
end

class Window_Base < Window
  
  def draw_actor_mp(actor, x, y, width = 120)                        # OVERWRITE
    width = width/actor.ampx.size
    offset = width
    if actor.ampx.size != 1
      offset += 1
      width -= 1
    end
    for i in 0...actor.ampx.size
      draw_actor_ampx(actor.ampx[i], x+i*offset,y,width)
    end
  end
  
  def draw_actor_ampx(resource, x, y, width = 120)
    draw_actor_ampx_gauge(resource, x, y, width)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, resource.abbv)
    self.contents.font.color = text_color(resource.color1)
    last_font_size = self.contents.font.size
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 44, y, 44, WLH, resource.value, 2)
    else
      self.contents.draw_text(xr - 99, y, 44, WLH, resource.value, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
      self.contents.font.color = text_color(resource.color1)
      self.contents.draw_text(xr - 44, y, 44, WLH, resource.max, 2)
    end
  end
  
  def draw_actor_ampx_gauge(resource, x, y, width = 120)
    gw = width * resource.value / [resource.max, 1].max
    gc1 = text_color(resource.color1)
    gc2 = text_color(resource.color2)
    self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
  end
  
end

class Window_BattleStatus < Window_Selectable
  
  def draw_item(index)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    actor = $game_party.members[index]
    draw_actor_state(actor, 114, rect.y, 48)
    draw_actor_name(actor, 4, rect.y)
    draw_actor_hp(actor, 124, rect.y, 120)
    draw_actor_mp(actor, 260, rect.y, 120)
  end
  
end


#BS
class Scene_Battle < Scene_Base
  
  def display_mp_damage(target, obj = nil)                            #OVERWRITE
    return if target.dead?
    return if target.mp_damage == 0
    type = obj.regresource.name
    if target.absorbed
      fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
      text = sprintf(fmt, target.name, type, target.mp_damage)
    elsif target.mp_damage > 0
      fmt = target.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
      text = sprintf(fmt, target.name, type, target.mp_damage)
    else
      fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
      text = sprintf(fmt, target.name, type, -target.mp_damage)
      Sound.play_recovery
    end
    @message_window.add_instant_text(text)
    wait(30)
  end
  
  def execute_action_skill                                            #OVERWRITE
    skill = @active_battler.action.skill
    text = @active_battler.name + skill.message1
    resource = skill.resourceof(@active_battler)
    @message_window.add_instant_text(text)
    unless skill.message2.empty?
      wait(10)
      @message_window.add_instant_text(skill.message2)
    end
    targets = @active_battler.action.make_targets
    display_animation(targets, skill.animation_id)
    if resource.tags.include?(:invert)
      resource.value += @active_battler.calc_mp_cost(skill)
    else
      resource.value -= @active_battler.calc_mp_cost(skill)
    end
    $game_temp.common_event_id = skill.common_event_id
    for target in targets
      target.skill_effect(@active_battler, skill)
      display_action_effects(target, skill)
    end
  end
  
  alias old_battle_end battle_end unless $@
  def battle_end(result)
    old_battle_end(result)
    refresh_zsr
  end
  
  alias res_turn_end turn_end unless $@
  def turn_end(actor = nil)
    if actor.nil?
      res_turn_end
      for actor in $game_party.members
        regen_ampx(actor)
      end
    else
      res_turn_end(actor)
      regen_ampx(actor)      
    end
  end
  
end

module OZ004
#-------------------------------------------------------------------------------
#
# Dual mp script
# by Julian Villaruz (omegazion)
#
# this script allows you to have 2 sets of mp, one of which recovers after battle
# and the other one that recovers after rest.
#
# for my purposes i named the one that recovers after battle "sp" and the one
# that recovers after rest is the original "mp" but you can change that.
#
# Instructions:
# 1. put this script above main
# 2. change the terms and sp bar color to what you want
# Terms:
SP = "SP"
SP_a = "S" # sp abbreviated
# color of the sp bar
SpBarLeft = [ 220, 210, 10, 255 ] # [red, blue, green, opacity]
SpBarRight = [ 100, 100, 2, 255]
# 3. Ignore these 2 lines
class MaxSp
def self.initiate_max_sp
# 4. set up each actors max sp
# To set up an actors max sp type this:
#
# set_maxsp_growth(actor id, base, growth per lvl)
#-------------------------------------------------------------------------------
# Exactly below this line: (all are lower case!)(have as many as you want)
set_maxsp_growth(1, 90, 10)
set_maxsp_growth(2, 80, 20)
set_maxsp_growth(3, 95, 15)





#-------------------------------------------------------------------------------
# 5. to increase an actors max sp in an event, type this in the script section:
# "$data_actors[actor_id].inc_maxsp(val)"
# (without the double quotes) where actor_id is an integer representing actor id
# and val is the value maxsp would increase. (can be negative)
# 6. to designate a skill to use sp instead of mp type:
# "<SS>"
# (without the double quotes) in the skills note box
# 7. to designate a skill to use BOTH sp and mp type:
# "<mp&sp[val]>"
# (without the double quotes) in the skills note box
# where val is an integer equal to the sp consumed
# (the mp consumed is the one on the database)
# NOTE: make sure you dont type <SS> on skills with <mp&sp[val]> !
# 8. to make an item recover sp type this in the item's note box:
# "<sp rec[val]>"
# (without the double quotes)
# where val is an integer equal to the amount recovered (can be negative)
# make sure you set all these types of items like this to for battle only.
# 9. you can also set a skill to damage sp! (or heal with negative damage)
# to do that type in the skill notes box:
# "<damage to sp>"
# (without the double quotes) damage to mp must NOT be checked
# once you set a skill to damage sp it doesnt damage hp anymore
# 10. if you want (and if you can) you could edit the window display
# they are exactly below the end lines
# 11. Credit me in your work!
end
end
end

# this is the window display in battle
# the draw_actor_sp is modeled from original draw_actor_mp
class Window_BattleStatus < Window_Selectable
def draw_item(index)
rect = item_rect(index)
rect.x += 4
rect.width -= 8
self.contents.clear_rect(rect)
self.contents.font.color = normal_color
actor = $game_party.members[index]
draw_actor_name(actor, 4, rect.y)
draw_actor_state(actor, 114, rect.y, 48)
draw_actor_hp(actor, 167, rect.y, 67)
draw_actor_mp(actor, 240, rect.y, 67)
draw_actor_sp(actor, 313, rect.y, 67)
end
end
# this is the window display in the menu
class Window_MenuStatus < Window_Selectable
def refresh
self.contents.clear
@item_max = $game_party.members.size
for actor in $game_party.members
draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
x = 104
y = actor.index * 96 + WLH / 2
draw_actor_name(actor, x, y)
draw_actor_class(actor, x + 120, y)
draw_actor_level(actor, x, y + WLH * 1)
draw_actor_state(actor, x, y + WLH * 2)
draw_actor_hp(actor, x + 120, y + WLH/6 * 5)
draw_actor_mp(actor, x + 120, y + WLH/6 * 10)
draw_actor_sp(actor, x + 120, y + WLH/6 * 15)
end
end
end

# this is the window display in status
class Window_Status < Window_Base
def draw_basic_info(x, y)
draw_actor_level(@actor, x, y + WLH * 0)
draw_actor_state(@actor, x, y + WLH * 1)
draw_actor_hp(@actor, x, y + WLH * 2)
draw_actor_mp(@actor, x, y + WLH * 3)
draw_actor_sp(@actor, x, y + WLH * 4)
end
end

class Window_Base < Window
def draw_actor_sp_gauge(actor, x, y, width = 120)
gw = width * actor.sp / [actor.maxsp, 1].max
gc1 = Color.new(OZ004::SpBarLeft[0],OZ004::SpBarLeft[1],OZ004::SpBarLeft[2],OZ004::SpBarLeft[3])
gc2 = Color.new(OZ004::SpBarRight[0],OZ004::SpBarRight[1],OZ004::SpBarRight[2],OZ004::SpBarRight[3])
self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
end
def draw_actor_sp(actor, x, y, width = 120)
draw_actor_sp_gauge(actor, x, y, width)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 30, WLH, OZ004::SP_a)
self.contents.font.color = sp_color(actor)
last_font_size = self.contents.font.size
xr = x + width
if width < 120
self.contents.draw_text(xr - 44, y, 44, WLH, actor.sp, 2)
else
self.contents.draw_text(xr - 99, y, 44, WLH, actor.sp, 2)
self.contents.font.color = normal_color
self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxsp, 2)
end
end
def sp_color(actor)
return crisis_color if actor.sp < actor.maxsp / 4
return normal_color
end
end

class Window_Skill < Window_Selectable
def draw_item(index)
rect = item_rect(index)
self.contents.clear_rect(rect)
skill = @data[index]
if skill != nil
rect.width -= 4
enabled = @actor.skill_can_use?(skill)
draw_item_name(skill, rect.x, rect.y, enabled)
mp_cost = @actor.calc_mp_cost(skill)
if skill.special_skill?
self.contents.draw_text(rect, mp_cost.to_s + OZ004::SP_a, 2)
elsif skill.uses_both?
sp_cost = skill.sp_used
self.contents.draw_text(rect, mp_cost.to_s + Vocab.mp_a + '/' + sp_cost.to_s + OZ004::SP_a, 2)
else
self.contents.draw_text(rect, mp_cost.to_s + Vocab.mp_a, 2)
end
end
end
end

module OZ004
class MaxSp
def self.set_maxsp_growth(actor_index, base, growth)
actor = $data_actors[actor_index]
actor.maxsp_base = base
actor.maxsp_growth = growth
end
end
end

module RPG
class Actor
def maxsp(level)
base = @maxsp_base != nil ? @maxsp_base : 0
growth = @maxsp_growth != nil ? @maxsp_growth : 0
maxsp = base + growth*level
return maxsp
end
def inc_maxsp(num)
index = self.id
@maxsp_base += num
actor = $game_actors[index]
actor.sp = maxsp(actor.level)
end
attr_writer :maxsp_base
attr_writer :maxsp_growth
end
class Skill < UsableItem
def special_skill?
s = self.note.downcase
return true if s.include?("<ss>")
return false
end
def uses_both?
s = self.note.downcase
return true if s.include?("<mp&sp[") and s.include?("]>")
return false
end
def sp_used
str = self.note.downcase
sp = "0"
str.scan(/\<mp\&sp\[([0-9]+)\]/){|s| sp = s[0]}
return sp.to_i
end
def damage_to_sp
str = self.note.downcase
return true if str.include?("<damage to sp>")
return false
end
end
class Item < UsableItem
def sp_recover
str = self.note.downcase
sp_recover = "0"
sp_damage = "0"
str.scan(/\<sp\srec\[([0-9]+)\]/){|s| sp_recover = s[0]}
str.scan(/\<sp\srec\[(\-[0-9]+)\]/){|s| sp_damage = s[0]}
sp = sp_recover.to_i + sp_damage.to_i
return sp
end
end
end
#-------------------------------------------------------------------------------
class Scene_Title < Scene_Base
alias oz_start start
def start
oz_start
set_up_sp
end
def set_up_sp
OZ004::MaxSp.initiate_max_sp
end
end
#-------------------------------------------------------------------------------
class Scene_Battle < Scene_Base
alias oz_battle_end battle_end
alias oz_display_hp_damage display_hp_damage
def execute_action_skill
skill = @active_battler.action.skill
text = @active_battler.name + skill.message1
@message_window.add_instant_text(text)
unless skill.message2.empty?
wait(10)
@message_window.add_instant_text(skill.message2)
end
targets = @active_battler.action.make_targets
display_animation(targets, skill.animation_id)
if skill.special_skill?
@active_battler.sp -= @active_battler.calc_mp_cost(skill)
elsif skill.uses_both?
@active_battler.mp -= @active_battler.calc_mp_cost(skill)
@active_battler.sp -= skill.sp_used
else
@active_battler.mp -= @active_battler.calc_mp_cost(skill)
end
$game_temp.common_event_id = skill.common_event_id
for target in targets
target.skill_effect(@active_battler, skill)
display_action_effects(target, skill)
end
end
def display_damage(target, obj = nil)
if target.missed
display_miss(target, obj)
elsif target.evaded
display_evasion(target, obj)
else
display_hp_damage(target, obj)
display_mp_damage(target, obj)
display_sp_damage(target, obj)
end
end
def display_hp_damage(target, obj = nil)
if target.hp_damage == 0
return if obj.is_a?(RPG::Skill) and obj.damage_to_sp
end
oz_display_hp_damage(target, obj)
end
def display_sp_damage(target, obj = nil)
return if target.dead?
return if target.sp_damage == 0
return unless target.actor?
if target.sp_damage > 0 # Damage
fmt = Vocab::ActorLoss
text = sprintf(fmt, target.name, OZ004::SP, target.sp_damage)
else # Recovery
fmt = Vocab::ActorRecovery
text = sprintf(fmt, target.name, OZ004::SP, -target.sp_damage)
Sound.play_recovery
end
@message_window.add_instant_text(text)
wait(30)
end
def battle_end(result)
oz_battle_end(result)
for actor in $game_party.members
actor.sp = actor.maxsp
end
end
end
#-------------------------------------------------------------------------------
class Game_Battler
alias oz_initialize initialize
alias oz_clear_action_results clear_action_results
alias oz_clear_extra_values clear_extra_values
alias oz_recover_all recover_all
alias oz_make_obj_damage_value make_obj_damage_value
alias oz_item_effect item_effect
alias oz_execute_damage execute_damage
attr_reader :sp
attr_reader :sp_damage
def initialize
@sp = 0
oz_initialize
end
def skill_can_use?(skill)
return false unless skill.is_a?(RPG::Skill)
return false unless movable?
return false if silent? and skill.spi_f > 0
if skill.special_skill?
return false if calc_mp_cost(skill) > sp
elsif skill.uses_both?
return false if calc_mp_cost(skill) > mp or skill.sp_used > sp
else
return false if calc_mp_cost(skill) > mp
end
if $game_temp.in_battle
return skill.battle_ok?
else
return skill.menu_ok?
end
end
def clear_action_results
oz_clear_action_results
@sp_damage = 0
end
def clear_extra_values
oz_clear_extra_values
@maxsp_plus = 0
end
def maxsp
return 0 if self.is_a?(Game_Enemy)
return [[base_maxsp + @maxsp_plus, 0].max, 9999].min
end
def sp=(sp)
@sp = [[sp, maxsp].min, 0].max
end
def recover_all
oz_recover_all
@sp = maxsp
end
def make_obj_damage_value(user, obj)
oz_make_obj_damage_value(user, obj)
damage = @hp_damage != 0 ? @hp_damage : @mp_damage
@hp_damage = 0
@mp_damage = 0
if obj.damage_to_mp
@mp_damage = damage
elsif obj.is_a?(RPG::Skill)
@sp_damage = damage if obj.damage_to_sp
else
@hp_damage = damage
end
end
def item_effect(user, item)
clear_action_results
unless item_effective?(user, item)
@skipped = true
return
end
if rand(100) >= calc_hit(user, item) # determine hit ratio
@missed = true
return
end
if rand(100) < calc_eva(user, item) # determine evasion rate
@evaded = true
return
end
hp_recovery = calc_hp_recovery(user, item) # calc HP recovery amount
mp_recovery = calc_mp_recovery(user, item) # calc MP recovery amount
make_obj_damage_value(user, item) # damage calculation
@hp_damage -= hp_recovery # subtract HP recovery amount
@mp_damage -= mp_recovery # subtract MP recovery amount
@sp_damage -= item.sp_recover # subtract SP recovery amount
make_obj_absorb_effect(user, item) # calculate absorption effect
execute_damage(user) # damage reflection
item_growth_effect(user, item) # apply growth effect
if item.physical_attack and @hp_damage == 0 # physical no damage?
return
end
apply_state_changes(item) # state change
end
def execute_damage(user)
oz_execute_damage(user)
self.sp -= @sp_damage
end
end
#-------------------------------------------------------------------------------
class Game_Actor < Game_Battler
def base_maxsp
return actor.maxsp(@level)
end
end

###############################################################################
##  RSSBS - Reedo's Simple Side Battle System
##  Version 1.0
##  January 7, 2010
##  By Reedo
###############################################################################
##  SOURCE
##
##  Source thread:
##
##
##  Support thread:
##    http://www.rpgmakervx.net/index.php?showtopic=24587
###############################################################################
##  REFERENCES
##
##  None.  This is an original script by Reedo.
##  However other people have contributed ideas and bug finds. Please see the
##  support thread link above for details.
###############################################################################
##  DESCRIPTION
##
##  This script provides a plug-and-play Side Battle System for the default
##  battle system. This is purely an asthetic script, and as such, it only
##  modifies the visuals of the battle. It does not modify battle mechanics
##  when used by itself.
##
##  This script will:
##  1) Draw the party on the right side of the screen, facing left, during batle.
##  2) Cause actors to perform their stepping animation when they are on the
##     ground, and have no state restrictions applied.
##  3) Place a shadow under the actor.
##  4) Provide a target for animations, and optionally, animations themselves.
##  5) Line up actors in a staggerd row, top to bottom, with adjustable spacing,
##     recessed according to the position value of their class.
##  6) Cause actors to step forward when performing an action.
##  7) Draw actors lying down, whitened, and semi-transparent when dead.
##  8) Cause living actors to do a victory dance at the end of battle.
##  9) Provide the option to horizontally flip enemy images by enemy ID.
##
##  When used with the YERD or YEZ battle scripts, you then get even more
##  animation options (such as casting animations) and popups for most battle
##  event messages.  This SBS and YEZ combine to form an amazing SBS experience!
##     YEZ Script Link:  http://www.pockethouse.com/yez/
###############################################################################
##  COMPATIBILITY
##
##  Should be compatible with most other scripts.
##
##  This script overwrites 1 method: Spriteset_Battle.update_actors
##  All other methods are aliased, and those aliases are called.
##  The one overwrite should not cause an issue as the only functionality it
##  supresses is setting the party members to the current battle sprites. The
##  rest of the original method is maintained, and this script handles the
##  relationship between party members and battle sprites.
###############################################################################
##  REQUIREMENTS
##
##  None
###############################################################################
##  INSTALLATION
##
##  Plug-and-play. (and this time I mean it for reals!)
##
##  Insert below Materials, above other Reedo scripts.
##  All Reedo scripts should be below all YERD/YEZ scripts.
###############################################################################
##  RIGHTS & RESTRICTIONS
##
##  As with most Reedo scripts, this script is free to re-use, as-is,
##  in personal, educational, and commercial RPGVX development projects,
##  providing that:  this script, as well as the rpgmakervx.net forum link  
##  from which it was obtained, are credited in writing displayed readily
##  to the user of the final compiled code assembly.
##
##  Reedo and rgpmakervx.net retain all rights of intellect and ownership.
##  You forego all rights of warranty by utilizing this script.
###############################################################################
##  USAGE
##
##  Plug and play.  Suggested to use YEZ Battle Engine Zealous, and Reedo's
##  Tile-Based Battle Backgrounds scripts.
##
##  Some visual options can be modified below.
###############################################################################

###############################################################################
##  USER OPTIONS
###############################################################################
module REEDO_SBS

# If desired, you can modify the default script options using the constants
# below. In most cases though, you should not need to adjust these values.
  
###############################################################################
## This section controls the battle animations provided by this script
###############################################################################
  # This controls whether or not this script will provide animations during
  # battle. Set to 'true' when using this script without any other battle scene
  # enhancements. Set to 'false' when using battle scene enhancements such
  # as YEZ/YERD. Default is 'false'.
  SBS_ACTION_ANIMES = true
  
  # If this script is providing animations, then you can specify which
  # animations to use a default.
  SBS_DEFAULT_ATTACK_ANIME = 19
  # Skill and item animations will use the animation assigned to the skill or
  # item, if any. If none is assigned, then the default will be used. Specify
  # a value of 0 if you do not want a default animation. These values have no
  # effect if SBS_ACTION_ANIMES is set to 'false'.
  SBS_DEFAULT_SKILL_ANIME = 1
  SBS_DEFAULT_ITEM_ANIME = 1
  
###############################################################################
## This section adjusts the actors positions on screen
###############################################################################
  ACTOR_START_LINE = 432        # The left-most position of the first actor
  ACTOR_START_TOP = 80          # The top-most position of the first actor
  ACTOR_STAGGER_HORZ = 8        # The amount to recess each actor to the right
  ACTOR_STAGGER_VERT = 16       # The vertical spacing between characters
  ACTOR_CLASS_POS_STAGGER = 16  # The extra distance to the right for class position
  ACTOR_STEP_IN_DISTANCE = 64   # The distance an actor steps in during an action
  ACTOR_STEP_IN_RATE = 8        # The rate at which the actor covers the distance
  
###############################################################################
## This section controls when an actor displays their stepping animation
###############################################################################
  # If an actor has a state applied which has a restriction value listed in
  # the following array, the actor will not display their stepping animation
  # until the state is removed.
  NO_STEP_RESTRICTIONS = [4, 5]
  # Has the same effect as above, but halts the stepping animation based on
  # the state's ID, without regard to the state's restriction.
  NO_STEP_STATES = []
  
###############################################################################
## This section adjusts the appearance of an actor when dead
###############################################################################
  ACTOR_DEATH_OPACITY = 175              # The tranparency of dead actors
  ACTOR_DEATH_ANGLE = 270                # The angle to rotate the body
  ACTOR_DEATH_TONE = [128, 128, 128, 0]  # A color tone to apply to the image
  ACTOR_DEATH_OFFSET_X = -8              # A horizontal offset to move the body by
  ACTOR_DEATH_OFFSET_Y = -8              # A vertical offset to move the body by
  
###############################################################################
## This section adjusts the actor's shadow
###############################################################################
  ACTOR_SHADOW_IMAGE = "Shadow"       # The name of the system image to use
  ACTOR_SHADOW_CUSTOM_PICTURE = nil   # The name of a resource picture to use instead; nil to use system image
  ACTOR_SHADOW_OFFSET_X = 0           # The horizontal offset to the actor's position
  ACTOR_SHADOW_OFFSET_Y = 8           # The vertical offset to the actor's position
  ACTOR_DEATH_SHADOW_OFFSET_X = 8     # Additional X offset added when dead
  ACTOR_DEATH_SHADOW_OFFSET_Y = 2     # Additional Y offset added when dead
  
###############################################################################
## This section adjusts the victory dance
###############################################################################
  VICTORY_DANCE_JUMP_HEIGHT = 16    # The height of the jump
  VICTORY_DANCE_JUMP_INCREMENT = 2  # The rate of jump movement
  VICTORY_DANCE_JUMP_HOVER = 4      # The number of frames to wait in the air
  VICTORY_DANCE_JUMP_WAIT = 70      # The number of frames before jumping again
  VICTORY_DANCE_JUMP_TWIST = true   # True to twirl when jumping; false to face forward
  
###############################################################################
## This section adjusts the battle floor location
###############################################################################
  BATTLE_FLOOR_TOP = 128  # Allows you to set the top of the battle floor
  
###############################################################################
## This section adjusts enemy images
###############################################################################
  # Specify the ID of enemies who should have their image flipped in battle
  FLIP_ENEMY = [
                2, 3, 4, 5, 8, 10, 12, 13, 14, 16, 17,
                18, 19, 21, 22, 23, 25, 28, 29,
                
               ]
  
end
###############################################################################
##  MAIN SCRIPT
###############################################################################
##  EDITS BEYOND THIS POINT ARE AT YOUR OWN RISK!!!
###############################################################################
class Game_Battler
  alias reedo_sbs_gb_add_state add_state
  def add_state(state_id)
    reedo_sbs_gb_add_state(state_id)
    if self.is_a?(Game_Actor) and $scene.is_a?(Scene_Battle)
      bs = $scene.reedo_get_battle_sprite(reedo_battle_sprite_id)
      return if bs == nil
      bs.reedo_bc_sprite.character.step_anime = reedo_check_step_anime
      reedo_update_life_state
    end
  end
  
  alias reedo_sbs_gb_remove_state remove_state
  def remove_state(state_id)
    reedo_sbs_gb_remove_state(state_id)
    if self.is_a?(Game_Actor) and $scene.is_a?(Scene_Battle)
      bs = $scene.reedo_get_battle_sprite(reedo_battle_sprite_id)
      return if bs == nil
      bs.reedo_bc_sprite.character.step_anime = reedo_check_step_anime
      reedo_update_life_state
    end    
  end
  
  def reedo_check_step_anime
    return false if dead?
    for state in states
      return false if REEDO_SBS::NO_STEP_STATES.include?(state.id)
      return false if REEDO_SBS::NO_STEP_RESTRICTIONS.include?(state.restriction)
    end
    return true
  end
  
  def reedo_update_life_state(battle_sprite = nil)
    if dead?
      if !@reedo_dead_set
        reedo_set_dead_state(battle_sprite)
        @reedo_dead_set = true
      end
    else
      if @reedo_dead_set
        reedo_set_live_state(battle_sprite)
        @reedo_dead_set = false
      end
    end
  end
  
  def reedo_reset_dead_set
    @reedo_dead_set = false
  end
  
  def reedo_set_dead_state(battle_sprite = nil)
    if battle_sprite == nil
      bs = $scene.reedo_get_battle_sprite(reedo_battle_sprite_id)
    else
      bs = battle_sprite
    end
    return if bs == nil
    return if bs.reedo_bc_sprite.is_dead
    bs.reedo_bc_sprite.angle = REEDO_SBS::ACTOR_DEATH_ANGLE
    tone = REEDO_SBS::ACTOR_DEATH_TONE
    bs.reedo_bc_sprite.tone.set(tone[0], tone[1], tone[2], tone[3])
    bs.reedo_bc_sprite.character.opacity = REEDO_SBS::ACTOR_DEATH_OPACITY
    bs.reedo_bc_sprite.character.screen_x += REEDO_SBS::ACTOR_DEATH_OFFSET_X
    bs.reedo_bc_sprite.character.screen_y += REEDO_SBS::ACTOR_DEATH_OFFSET_Y
    bs.reedo_bc_sprite.shadow_sprite.x += REEDO_SBS::ACTOR_DEATH_SHADOW_OFFSET_X
    bs.reedo_bc_sprite.shadow_sprite.y += REEDO_SBS::ACTOR_DEATH_SHADOW_OFFSET_Y    
    bs.reedo_bc_sprite.is_dead = true
  end
  
  def reedo_set_live_state(battle_sprite = nil)
    if battle_sprite == nil
      bs = $scene.reedo_get_battle_sprite(reedo_battle_sprite_id)
    else
      bs = battle_sprite
    end
    return if bs == nil
    return if bs.reedo_bc_sprite.is_dead != true
    bs.reedo_bc_sprite.angle = 0
    bs.reedo_bc_sprite.tone.set(0, 0, 0, 0)
    bs.reedo_bc_sprite.character.opacity = 255
    bs.reedo_bc_sprite.character.screen_x -= REEDO_SBS::ACTOR_DEATH_OFFSET_X
    bs.reedo_bc_sprite.character.screen_y -= REEDO_SBS::ACTOR_DEATH_OFFSET_Y
    bs.reedo_bc_sprite.shadow_sprite.x -= REEDO_SBS::ACTOR_DEATH_SHADOW_OFFSET_X
    bs.reedo_bc_sprite.shadow_sprite.y -= REEDO_SBS::ACTOR_DEATH_SHADOW_OFFSET_Y
    bs.reedo_bc_sprite.is_dead = false
  end
end

class Game_Actor
  attr_accessor :reedo_battle_sprite_id
  attr_accessor :screen_x
  attr_accessor :screen_y
end

class Game_Actors
  def members
    return @data
  end
end

class Game_Troop
  def troop_id
    return @troop_id
  end
end

class Game_Character  
  alias reedo_sbs_gc_screen_x screen_x
  def screen_x
    if $scene.is_a?(Scene_Battle)
      return @battle_screen_x
    else
      return reedo_sbs_gc_screen_x
    end
  end

  alias reedo_sbs_gc_screen_y screen_y
  def screen_y
    if $scene.is_a?(Scene_Battle)
      return @battle_screen_y
    else
      return reedo_sbs_gc_screen_y
    end
  end
  
  def opacity=(value)
    @opacity = value
  end
  def screen_x=(value)
    @battle_screen_x = value
  end
  def screen_y=(value)
    @battle_screen_y = value
  end
  def step_anime
    return @step_anime
  end
  def step_anime=(value)
    @step_anime = value
  end
end

class Sprite_Base
  attr_accessor :reedo_victory_wait
end

class Sprite_Character
  attr_accessor :shadow_sprite
  attr_accessor :is_dead
  
  alias reedo_sbs_sc_dispose dispose
  def dispose
    @shadow_sprite.dispose if @shadow_sprite != nil
    reedo_sbs_sc_dispose
  end
  
  def create_shadow_sprite
    @shadow_sprite = Sprite_Base.new(self.viewport)
    bmp = Cache.picture(REEDO_SBS::ACTOR_SHADOW_CUSTOM_PICTURE) if REEDO_SBS::ACTOR_SHADOW_CUSTOM_PICTURE != nil
    bmp = Cache.system(REEDO_SBS::ACTOR_SHADOW_IMAGE) if bmp == nil
    @shadow_sprite.bitmap = bmp
    @shadow_sprite.src_rect = Rect.new(0, 0, bmp.width, bmp.height)
    @shadow_sprite.x = self.x - self.ox + REEDO_SBS::ACTOR_SHADOW_OFFSET_X
    @shadow_sprite.y = self.y - self.oy + REEDO_SBS::ACTOR_SHADOW_OFFSET_Y
    @shadow_sprite.z = self.z - 1
  end
  
  alias reedo_sbs_sc_update update
  def update
    reedo_sbs_sc_update
    @shadow_sprite.update if @shadow_sprite != nil
  end
end

class Sprite_Battler
  attr_accessor :reedo_bc_sprite

  alias reedo_sbs_sb_dispose dispose
  def dispose
    @reedo_bc_sprite.dispose if @reedo_bc_sprite != nil
    reedo_sbs_sb_dispose
  end
  
  alias reedo_sbs_sb_update update
  def update
    reedo_sbs_sb_update
    @reedo_bc_sprite.update if @reedo_bc_sprite != nil
  end
end

class Spriteset_Battle
  alias reedo_sbs_ssb_create_battlefloor create_battlefloor
  def create_battlefloor
    reedo_sbs_ssb_create_battlefloor
    @battlefloor_sprite.y = REEDO_SBS::BATTLE_FLOOR_TOP
  end
  
  alias reedo_sbs_ssb_create_actors create_actors
  def create_actors
    if @actor_sprites != nil
      dispose_actors
    end
    reedo_sbs_ssb_create_actors
    @reedo_start_points = {}
    @actor_sprites = []
    i = 1
    for actor in $game_party.members
      actor.reedo_battle_sprite_id = i - 1        
      gc = Game_Character.new
      gc.set_graphic(actor.character_name, actor.character_index)
      gc.set_direction(4)
      gc.screen_x = 0; gc.screen_y = 0
      bc = Sprite_Character.new(@viewport1, gc)
      gc.screen_x = REEDO_SBS::ACTOR_START_LINE +
                    ($data_classes[actor.class_id].position *
                    REEDO_SBS::ACTOR_CLASS_POS_STAGGER) +
                    ((i - 1) * REEDO_SBS::ACTOR_STAGGER_HORZ)
      gc.screen_y = REEDO_SBS::ACTOR_START_TOP + ((bc.height * i) +
                    (REEDO_SBS::ACTOR_STAGGER_VERT * i))
      actor.screen_x = gc.screen_x; actor.screen_y = gc.screen_y
      sb = Sprite_Battler.new(@viewport1, actor)
      sb.reedo_victory_wait = REEDO_SBS::VICTORY_DANCE_JUMP_HOVER
      sb.reedo_bc_sprite = bc
      gc.step_anime = actor.reedo_check_step_anime
      @reedo_start_points[sb] = [gc.screen_x, gc.screen_y]
      @actor_sprites.push(sb)  
      bc.update
      bc.create_shadow_sprite
      actor.reedo_reset_dead_set
      actor.reedo_update_life_state(sb)
      i += 1
    end
  end
  
  alias reedo_sbs_ssb_create_enemies create_enemies
  def create_enemies
    reedo_sbs_ssb_create_enemies
    for sprite in @enemy_sprites
      if REEDO_SBS::FLIP_ENEMY.include?(sprite.battler.enemy_id)
        sprite.mirror = true
      end
    end
  end
  
  def update_actors
    if $scene.is_a?(Scene_Battle)
      if $scene.victory_dance_time
        reedo_update_victory_dance
      end
    end    
    for sprite in @actor_sprites
      sprite.reedo_bc_sprite.character.update
      sprite.update
    end
  end
  
  def reedo_get_battle_sprite(sprite_id)
    return nil if !sprite_id.is_a?(Fixnum)
    return nil if sprite_id < 0
    return nil if sprite_id >= @actor_sprites.length
    return @actor_sprites[sprite_id]
  end
  
  def reedo_update_victory_dance
    if @victory_delta == nil
      @victory_delta = -REEDO_SBS::VICTORY_DANCE_JUMP_INCREMENT
      for sp in @actor_sprites
        sp.reedo_bc_sprite.character.step_anime = false
      end
    end
    for sp in @actor_sprites
      next if sp.battler.reedo_check_step_anime == false
      stpt = @reedo_start_points[sp]
      if sp.reedo_bc_sprite.character.screen_y < stpt[1] - REEDO_SBS::VICTORY_DANCE_JUMP_HEIGHT
        if sp.reedo_victory_wait <= 0
          @victory_delta = REEDO_SBS::VICTORY_DANCE_JUMP_INCREMENT
          sp.reedo_victory_wait = REEDO_SBS::VICTORY_DANCE_JUMP_WAIT
        else
          @victory_delta = 0
          sp.reedo_victory_wait -= 1
        end
      end
      if sp.reedo_bc_sprite.character.screen_y > stpt[1]
        if sp.reedo_victory_wait <= 0
          @victory_delta = -REEDO_SBS::VICTORY_DANCE_JUMP_INCREMENT
          sp.reedo_victory_wait = REEDO_SBS::VICTORY_DANCE_JUMP_HOVER
          sp.reedo_bc_sprite.character.step_anime = false
        else
          @victory_delta = 0
          sp.reedo_victory_wait -= 1
          sp.reedo_bc_sprite.character.step_anime = true if !sp.reedo_bc_sprite.character.step_anime
        end
      end
      if REEDO_SBS::VICTORY_DANCE_JUMP_TWIST
        if sp.reedo_bc_sprite.character.screen_y <= stpt[1]
          if (sp.reedo_bc_sprite.character.screen_y - stpt[1]) % (REEDO_SBS::VICTORY_DANCE_JUMP_HEIGHT / 4) == 0
            case sp.reedo_bc_sprite.character.direction
            when 4; sp.reedo_bc_sprite.character.set_direction(2)
            when 2; sp.reedo_bc_sprite.character.set_direction(6)
            when 6; sp.reedo_bc_sprite.character.set_direction(8)
            when 8; sp.reedo_bc_sprite.character.set_direction(4)
            end
          end
        else
          sp.reedo_bc_sprite.character.set_direction(4) if sp.reedo_bc_sprite.character.direction != 4
        end
      end
      sp.reedo_bc_sprite.character.screen_y += @victory_delta
      sp.battler.screen_y += @victory_delta
    end
  end
end

class Scene_Battle
  attr_reader :victory_dance_time
  
  alias reedo_sbs_sb_start start
  def start
    reedo_sbs_sb_start
    @current_party = $game_party.members
  end
  
  alias reedo_sbs_sb_terminate terminate
  def terminate
    reedo_teardown_actors
    reedo_sbs_sb_terminate
  end
  
  alias reedo_sbs_sb_update update
  def update
    if @current_party != $game_party.members
      @spriteset.create_actors
      @current_party = $game_party.members
    end
    reedo_sbs_sb_update
  end
  
  alias reedo_sbs_sb_execute_action_attack execute_action_attack
  def execute_action_attack
    reedo_do_execute_action("attack")
  end

  alias reedo_sbs_sb_execute_action_skill execute_action_skill
  def execute_action_skill
    reedo_do_execute_action("skill")
  end
  
  alias reedo_sbs_sb_execute_action_item execute_action_item
  def execute_action_item
    reedo_do_execute_action("item")
  end
  
  alias reedo_sbs_sb_process_victory process_victory
  def process_victory
    @victory_dance_time = true
    reedo_sbs_sb_process_victory
  end
  
  def reedo_get_battle_sprite(sprite_id)
    return @spriteset.reedo_get_battle_sprite(sprite_id)
  end
  
  def reedo_teardown_actors
    for actor in $game_actors.members
      actor.reedo_battle_sprite_id = nil if actor != nil
    end
  end
  
  def reedo_do_execute_action(action_method)
    targets = @active_battler.action.make_targets
    if @active_battler.is_a?(Game_Actor)
      reedo_actor_step_in
      if REEDO_SBS::SBS_ACTION_ANIMES
        targets.each do |t|
          if t.is_a?(Game_Actor)
            bs = reedo_get_battle_sprite(t.reedo_battle_sprite_id)
            bs.reedo_bc_sprite.character.animation_id = eval("reedo_get_" + action_method + "_animation") if bs != nil
          end
        end
      end
      eval("reedo_sbs_sb_execute_action_" + action_method)
      reedo_actor_step_back
    else
      if REEDO_SBS::SBS_ACTION_ANIMES
        targets.each do |t|
          if t.is_a?(Game_Actor)
            bs = reedo_get_battle_sprite(t.reedo_battle_sprite_id)
            bs.reedo_bc_sprite.character.animation_id = eval("reedo_get_" + action_method + "_animation") if bs != nil
          end
        end
      end
      eval("reedo_sbs_sb_execute_action_" + action_method)
    end
  end
  
  def reedo_get_attack_animation
    return REEDO_SBS::SBS_DEFAULT_ATTACK_ANIME
  end
  
  def reedo_get_skill_animation
    skill = $data_skills[@active_battler.action.skill_id]
    aid = REEDO_SBS::SBS_DEFAULT_SKILL_ANIME
    aid = skill.animation_id if skill.animation_id > 0    
    return aid
  end

  def reedo_get_item_animation
    item = $data_items[@active_battler.action.item_id]
    aid = REEDO_SBS::SBS_DEFAULT_ITEM_ANIME
    aid = item.animation_id if item.animation_id > 0    
    return aid
  end
  
  def reedo_actor_step_in
    delta = 0
    dr = REEDO_SBS::ACTOR_STEP_IN_RATE
    while delta < REEDO_SBS::ACTOR_STEP_IN_DISTANCE
      bs = reedo_get_battle_sprite(@active_battler.reedo_battle_sprite_id)
      return if bs == nil
      bs.reedo_bc_sprite.shadow_sprite.x -= dr
      bs.reedo_bc_sprite.character.screen_x -= dr
      bs.battler.screen_x -= dr
      Graphics.update
      @spriteset.update
      delta += dr
    end
  end
  
  def reedo_actor_step_back
    delta = 0
    dr = REEDO_SBS::ACTOR_STEP_IN_RATE
    while delta < REEDO_SBS::ACTOR_STEP_IN_DISTANCE
      bs = reedo_get_battle_sprite(@active_battler.reedo_battle_sprite_id)
      return if bs == nil
      bs.reedo_bc_sprite.shadow_sprite.x += dr
      bs.reedo_bc_sprite.character.screen_x += dr
      bs.battler.screen_x += dr
      Graphics.update
      @spriteset.update
      delta += dr
    end
  end
end