ACTIVE TIME BATTLE SYSTEM LIKE FF7???

[Karo Rushe]

I was looking around for that, and did some search, all I got was this:

The topic or board you are looking for appears to be either missing or off limits to you.

G'rrr...I want it, can someone post it? or does know where can I get it?

[Kokowam]

I've seen multiple ATB on hbgames.org that need SDK. Try searching there.

[Karo Rushe]

I've seen multiple ATB on hbgames.org that need SDK. Try searching there.

I have seen some, but some of them Messes up, mostly 'cause their from someone who uses more than 200 Lines of uselesness 

I'll search for one and post it here.

[Kaitenshin]

Sounds good, I'm interested.

[Irgna]

Here's Minkoff's:

HP/SP/Exp Bars:

Code Select Expand


# HP/SP/EXP?????????? Ver 1.00
# ????????URL
# http://members.jcom.home.ne.jp/cogwheel/

#==============================================================================
# ? Game_Actor
#------------------------------------------------------------------------------
# ???????????????????? Game_Actors ??? ($game_actors)
# ?????????Game_Party ??? ($game_party) ??????????
#==============================================================================

class Game_Actor < Game_Battler
  def now_exp
    return @exp - @exp_list[@level]
  end
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end

#==============================================================================
# ? Window_Base
#------------------------------------------------------------------------------
# ??????????????????????????
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ? HP ??????
  #--------------------------------------------------------------------------
  # ??????HP??? draw_actor_hp_hpsp ?????
  alias :draw_actor_hp_hpsp :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # ??rate? ???HP/MHP???
    if actor.maxhp != 0
      rate = actor.hp.to_f / actor.maxhp
    else
      rate = 0
    end
    # plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
    # plus_width:???? rate_width:????(%) height:??
    # align1:?????1 0:??? 1:???? 2:???
    # align2:?????2 0:??? 1:???? 2:???
    # align3:?????? 0:??? 1:???
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ????????? grade1:???? grade2:????
    # (0:????????? 1:????????? 2:??????????(??)?
    grade1 = 1
    grade2 = 0
    # ????color1:???color2:??
    # color3:???????????color4:??????????
    # color5:???????????color6:??????????
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    # ??sp?????????????
    if actor.maxhp != 0
      hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    else
      hp = 0
    end
    # ??????
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, hp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ??????HP?????????
    draw_actor_hp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # ? SP ??????
  #--------------------------------------------------------------------------
  # ??????SP??? draw_actor_sp_hpsp ?????
  alias :draw_actor_sp_hpsp :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # ??rate? ???SP/MSP???
    if actor.maxsp != 0
      rate = actor.sp.to_f / actor.maxsp
    else
      rate = 1
    end
    # plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
    # plus_width:???? rate_width:????(%) height:??
    # align1:?????1 0:??? 1:???? 2:???
    # align2:?????2 0:??? 1:???? 2:???
    # align3:?????? 0:??? 1:???
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ????????? grade1:???? grade2:????
    # (0:????????? 1:????????? 2:??????????(??)?
    grade1 = 1
    grade2 = 0
    # ????color1:???color2:??
    # color3:???????????color4:??????????
    # color5:???????????color6:??????????
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(0, 64, 0, 192)
    color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    # ??sp?????????????
    if actor.maxsp != 0
      sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    else
      sp = (width + plus_width) * rate_width / 100
    end
    # ??????
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, sp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ??????SP?????????
    draw_actor_sp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # ? EXP ??????
  #--------------------------------------------------------------------------
  # ??????EXP??? draw_actor_sp_hpsp ?????
  alias :draw_actor_exp_hpsp :draw_actor_exp
  def draw_actor_exp(actor, x, y, width = 204)
    # ??rate? ???exp/nextexp???
    if actor.next_exp != 0
      rate = actor.now_exp.to_f / actor.next_exp
    else
      rate = 1
    end
    # plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
    # plus_width:???? rate_width:????(%) height:??
    # align1:?????1 0:??? 1:???? 2:???
    # align2:?????2 0:??? 1:???? 2:???
    # align3:?????? 0:??? 1:???
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ????????? grade1:???? grade2:????
    # (0:????????? 1:????????? 2:??????????(??)?
    grade1 = 1
    grade2 = 0
    # ????color1:???color2:??
    # color3:???????????color4:??????????
    # color5:???????????color6:??????????
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    # ??exp?????????????
    if actor.next_exp != 0
      exp = (width + plus_width) * actor.now_exp * rate_width /
                                                          100 / actor.next_exp
    else
      exp = (width + plus_width) * rate_width / 100
    end
    # ??????
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, exp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ??????EXP?????????
    draw_actor_exp_hpsp(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # ? ??????
  #--------------------------------------------------------------------------
  def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    case align1
    when 1
      x += (rect_width - width) / 2
    when 2
      x += rect_width - width
    end
    case align2
    when 1
      y -= height / 2
    when 2
      y -= height
    end
    # ???
    self.contents.fill_rect(x, y, width, height, color1)
    self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    if align3 == 0
      if grade1 == 2
        grade1 = 3
      end
      if grade2 == 2
        grade2 = 3
      end
    end
    if (align3 == 1 and grade1 == 0) or grade1 > 0
      color = color3
      color3 = color4
      color4 = color
    end
    if (align3 == 1 and grade2 == 0) or grade2 > 0
      color = color5
      color5 = color6
      color6 = color
    end
    # ???????
    self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                  color3, color4, grade1)
    if align3 == 1
      x += width - gauge
    end
    # ???????
    self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                  color5, color6, grade2)
  end
end

#------------------------------------------------------------------------------
# ?Bitmap????????????????
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # ? ????????????
  #     color1 : ???????
  #     color2 : ??????
  #     align  :  0:?????????
  #               1:?????????
  #               2:???????????????????
  #--------------------------------------------------------------------------
  def gradation_rect(x, y, width, height, color1, color2, align = 0)
    if align == 0
      for i in x...x + width
        red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - x) / (width - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - x) / (width - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - x) / (width - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(i, y, 1, height, color)
      end
    elsif align == 1
      for i in y...y + height
        red   = color1.red +
                (color2.red - color1.red) * (i - y) / (height - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - y) / (height - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - y) / (height - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - y) / (height - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(x, i, width, 1, color)
      end
    elsif align == 2
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    elsif align == 3
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    end
  end
end


ABS:

Code Select Expand


#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
#  Animated Battlers by Minkoff, Updated by DerVVulfman
#==============================================================================

class Sprite_Battler < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize(viewport, battler = nil)

    # Configuration
    @speed              = 7      # Framerate speed of the battlers
    @frames             = 4      # Number of frames in each pose
    @poses              = 11     # Number of poses (stances) in the template
    @mirror_enemies     = true   # Enemy battlers use reversed image
    @stationary_enemies = false  # If the enemies don't move while attacking
    @stationary_actors  = false  # If the actors don't move while attacking
    @calculate_speed    = true   # System calculates a mean/average speed
    @phasing            = true   # Characters fade in/out while attacking
    @default_collapse   = false  # Restores the old 'red fade' effect to enemies
    # Array that holds the id # of weapons that forces the hero to be stationary
    @stationary_weapons = [17,18,19,20,21,22,23,24] # (examples are bows & guns)

    # DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU'RE DOING
    @frame, @pose = 0, 0
    @last_time = 0
    @last_move_time = 0
    cbs_initialize(viewport, battler)
    self.mirror = !!battler and @mirror_enemies
    viewport.z = 99
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  alias cbs_update update
  def update
    return unless @battler

    # Regular Update
    cbs_update

    # Start Routine
    unless @started
      @pose = state
      @width = @width / @frames
      @height = @height / @poses
      @display_x = @battler.screen_x
      @display_y = @battler.screen_y
      @destination_x = @display_x
      @destination_y = @display_y
      @started = true
    end

    # Cut Out Frame
    self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

    # Position Sprite
    self.x = @display_x
    self.y = @display_y
    self.z = @display_y
    self.ox = @width / 2
    self.oy = @height

    # Setup Animation
    time = Graphics.frame_count / (Graphics.frame_rate / @speed)
    if @last_time < time
      @frame = (@frame + 1) % @frames
      if @frame == 0
        if @freeze
          @frame = @frames - 1
          return
        end
        @pose = state
      end
    end
    @last_time = time

    # Move It
    move if moving
  end
  #--------------------------------------------------------------------------
  # * Current State
  #--------------------------------------------------------------------------
  def state
    # Damage State
    if [nil,{}].include?(@battler.damage)
      # Battler Fine
      @state = 0
      # Battler Wounded
      @state = 2 if @battler.hp < @battler.maxhp / 4

      if @default_collapse
        # Battler Dead (Red-Out Collapse)
        if @battler.dead? and @battler.is_a?(Game_Actor)
          @state = 10
          # Fix Opacity
          self.opacity = 255
        end
      else
        # Battler Dead (Pose-Type Collapse)
        if @battler.dead?
          @state = 10
          # Fix Opacity
          self.opacity = 255
        end
      end
    end
    # Guarding State
    @state = 3 if @battler.guarding?
    # Moving State
    if moving
      # If enemy battler moving
      if @battler.is_a?(Game_Enemy)
        # Battler Moving Left
        @state = 5 if moving.eql?(0)
        # Battler Moving Right
        @state = 4 if moving.eql?(1)
      # Else actor battler moving
      else
        # Battler Moving Left
        @state = 4 if moving.eql?(0)
        # Battler Moving Right
        @state = 5 if moving.eql?(1)
      end
    end
    # Return State
    return @state
  end
  #--------------------------------------------------------------------------
  # * Move
  #--------------------------------------------------------------------------
  def move
    time = Graphics.frame_count / (Graphics.frame_rate.to_f / (@speed * 5))
    if @last_move_time < time

      # Pause for Animation
      return if @pose != state

      # Phasing
      if @phasing
        d1 = (@display_x - @original_x).abs
        d2 = (@display_y - @original_y).abs
        d3 = (@display_x - @destination_x).abs
        d4 = (@display_y - @destination_y).abs
        self.opacity = [255 - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max
      end

      # Calculate Difference
      difference_x = (@display_x - @destination_x).abs
      difference_y = (@display_y - @destination_y).abs

      # Done? Reset, Stop
      if [difference_x, difference_y].max.between?(0, 8)
        @display_x = @destination_x
        @display_y = @destination_y
        @pose = state
        return
      end

      # Calculate Movement Increments
      increment_x = increment_y = 1
      if difference_x < difference_y
        increment_x = 1.0 / (difference_y.to_f / difference_x)
      elsif difference_y < difference_x
        increment_y = 1.0 / (difference_x.to_f / difference_y)
      end
     
      # Calculate Movement Speed
      if @calculate_speed
        total = 0; $game_party.actors.each{ |actor| total += actor.agi }
        speed = @battler.agi.to_f / (total / $game_party.actors.size)
        increment_x *= speed
        increment_y *= speed
      end
     
      # Multiply and Move
      multiplier_x = (@destination_x - @display_x > 0 ? 8 : -8)
      multiplier_y = (@destination_y - @display_y > 0 ? 8 : -8)
      @display_x += (increment_x * multiplier_x).to_i
      @display_y += (increment_y * multiplier_y).to_i
    end
    @last_move_time = time
  end
  #--------------------------------------------------------------------------
  # * Set Movement
  #--------------------------------------------------------------------------
  def setmove(destination_x, destination_y)
    unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or
           (@battler.is_a?(Game_Actor) and @stationary_actors)
      unless @stationary_weapons.include?(@battler.weapon_id)
        @original_x = @display_x
        @original_y = @display_y
        @destination_x = destination_x
        @destination_y = destination_y
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Movement Check
  #--------------------------------------------------------------------------
  def moving
    if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)
      return (@display_x > @destination_x ? 0 : 1)
    end
  end
  #--------------------------------------------------------------------------
  # * Set Pose
  #--------------------------------------------------------------------------
  def pose=(pose)
    @pose = pose
    @frame = 0
  end
  #--------------------------------------------------------------------------
  # * Freeze
  #--------------------------------------------------------------------------
  def freeze
    @freeze = true
  end
  #--------------------------------------------------------------------------
  # * Fallen Pose
  #--------------------------------------------------------------------------
  alias cbs_collapse collapse
  def collapse
    if @default_collapse
      cbs_collapse if @battler.is_a?(Game_Enemy)
      end
    end
  end

#==============================================================================
# ** Game_Actor
#==============================================================================

class Game_Actor
  #--------------------------------------------------------------------------
  # * Actor X Coordinate
  #--------------------------------------------------------------------------
  def screen_x
    if self.index != nil
      return self.index * 45 + 450
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # * Actor Y Coordinate
  #--------------------------------------------------------------------------
  def screen_y
    return self.index * 35 + 200
  end
  #--------------------------------------------------------------------------
  # * Actor Z Coordinate
  #--------------------------------------------------------------------------
  def screen_z
    return screen_y
  end
end

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Action Animation, Movement
  #--------------------------------------------------------------------------
  alias cbs_update_phase4_step3 update_phase4_step3
  def update_phase4_step3(battler = @active_battler)
    @rtab = !@target_battlers
    target = (@rtab ? battler.target : @target_battlers)[0]
    @moved = {} unless @moved
    return if @spriteset.battler(battler).moving
    case battler.current_action.kind
    when 0 # Attack
      if not (@moved[battler] or battler.guarding?)
        offset = (battler.is_a?(Game_Actor) ? 40 : -40)
        @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y)
        @moved[battler] = true
        return
      elsif not battler.guarding?
        @spriteset.battler(battler).pose = 6 + rand(2)
        @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
      end
    when 1 # Skill
      @spriteset.battler(battler).pose = 8
    when 2 # Item
      @spriteset.battler(battler).pose = 8
    end
    @moved[battler] = false
    @rtab ? cbs_update_phase4_step3(battler) : cbs_update_phase4_step3
  end
  #--------------------------------------------------------------------------
  # * Hit Animation
  #--------------------------------------------------------------------------
  alias cbs_update_phase4_step4 update_phase4_step4
  def update_phase4_step4(battler = @active_battler)
    for target in (@rtab ? battler.target : @target_battlers)
      damage = (@rtab ? target.damage[battler] : target.damage)
      if damage.is_a?(Numeric) and damage > 0
        @spriteset.battler(target).pose = 1
      end
    end
    @rtab ? cbs_update_phase4_step4(battler) : cbs_update_phase4_step4
  end
  #--------------------------------------------------------------------------
  # * Victory Animation
  #--------------------------------------------------------------------------
  alias cbs_start_phase5 start_phase5
  def start_phase5
    for actor in $game_party.actors
      return if @spriteset.battler(actor).moving
    end
    for actor in $game_party.actors
      unless actor.dead?
        @spriteset.battler(actor).pose = 9
        @spriteset.battler(actor).freeze
      end
    end
    cbs_start_phase5
  end
  #--------------------------------------------------------------------------
  # * Change Arrow Viewport
  #--------------------------------------------------------------------------
  alias cbs_start_enemy_select start_enemy_select
  def start_enemy_select
    cbs_start_enemy_select
    @enemy_arrow.dispose
    @enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)
    @enemy_arrow.help_window = @help_window
  end
end

#==============================================================================
# ** Spriteset_Battle
#==============================================================================

class Spriteset_Battle
  #--------------------------------------------------------------------------
  # * Change Enemy Viewport
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize
    cbs_initialize
    @enemy_sprites = []
    for enemy in $game_troop.enemies.reverse
      @enemy_sprites.push(Sprite_Battler.new(@viewport2, enemy))
    end
  end
  #--------------------------------------------------------------------------
  # * Find Sprite From Battler Handle
  #--------------------------------------------------------------------------
  def battler(handle)
    for sprite in @actor_sprites + @enemy_sprites
      return sprite if sprite.battler == handle
    end
  end
end

#==============================================================================
# ** Arrow_Base
#==============================================================================

class Arrow_Base < Sprite
  #--------------------------------------------------------------------------
  # * Reposition Arrows
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize(viewport)
    cbs_initialize(viewport)
    self.ox = 14
    self.oy = 10
  end
end


Battler Example:



I like it, personally. Does not have the timer between attacks thing the FF series has, though.