ParaDog's ATB

DerVVulfman · Dec 27, 2006

ParaDog's ATB
Version: 2.58
September 16, 2006
http://hometown.aol.com/Der%20VVulfman/ ... /TRANS.PNG[/img]
Originally designed by ParaDog, posted at http://2d6.parasite.jp/
Not by DerVVulfman

Posted before, but now completely translated into English.
Also contains the original Japanese version.

Introduction
Translated from the original Japanese code, Paradog's Front-View Battlesystem simulates an Active Timer Battle system so closely that this CTB (Conditional Timer Battle) system deserves ATB in it's name.

Complete with CT gauges that show who's going to be next to attack, a redesigned Battlestatus window system that lists the enemies you're facing and an altered 'Fight/Escape' system so action stays fast and furious, this system is one of the better battlesystems available.

Features

CT Gauges... 'nuff said?
Editable fill rates for the Gauges, based on game actions.
Displays enemies encountered in it's own window.
Adjustable Actor Command Window (he added for sideview system scripts)

Screenshots
http://hometown.aol.com/Der%20VVulfman/ ... araDog.png[/IMG]

Demo
ParaDog's ATB v 2.58

Script

I took a few liberties with the comments, using the syntax of the official English version of RMXP whenever possible.

Code:

#=============================================================================
# Active Time Battle v.2.58
# Script by ParaDog
# http://2d6.parasite.jp/
#------------------------------------------------------------------------------
# When the CT Gauge becomes filled,  the battler which it controls will then be
# able to perform his/her battle action.
# The system can also  adjust the positioning  of the BattleStatus window which
# works well with Sideview System scripts.
#------------------------------------------------------------------------------
# INSTALLING:
# When using this system,  it is recommended  that this script  be placed above
# all other 'Custom' scripts... directly below Scene_Debug if possible.
#------------------------------------------------------------------------------
# ESCAPE:
# While a battler's command window is active,  pressing the  [ESC]  button will
# activate the  'Fight / Escape' window   at the top  of the screen.   The more
# actors you have  with full CT,  the better  your chances  are of a successful
# escape, while fewer actors results in a lower chance to flee.
#
# NEXT/PREVIOUS BATTLER:
# When two or more actors can act,  you can toggle between the actors with full
# CT gauges with the [R] button or the [PageDown] key, or in reverse order with
# the [L] button or the [PageUp] key.
#==============================================================================

module PARA_CTB
  
  # CT gauge pauses while command window is open
  COMMAND_WAIT = false
  # CT gauge pauses when Skill and Item windows are open, and while targeting
  SELECT_WAIT = false
  # CT gauge pauses when battlers perform actions
  ANIMATION_WAIT = false
  
  # CT Gauge fill / Battle system speed
  BATTLE_SPEED   = 3

  # Maximum size in your Battle Party
  PARTY_SIZE     = 4
  
  # CT Cost in percentages for each action
  ACT_ATTACK_CT  = 100   # Normal attack
  ACT_GUARD_CT   = 100   # Defense
  ACT_ESCAPE_CT  = 100   # Escape
  ACT_SKILL_CT   = 100   # Skill
  ACT_ITEM_CT    = 100   # Item
  
  # Message when failed to escape
  UNESCAPE_MES   = "Escape failed"
  
  # Sound effect played when the CT Gauge is full (if "", plays no sound)
  # Sound effect stored in the project's "Audio/SE" folder
  FULL_CT_SE = "015-Jump01"
  # Sound Volume
  FULL_CT_SE_VOL = 80

  # Tone effect of the battler when the CT Gauge is full
  # A value of (0,0,0) performs no tone change
  FULL_CT_COLOR = Tone.new(32,0,0)
  
  # Color of HP gauge (gradation left edge)
  HP_COLOR_LEFT = Color.new(128, 0, 0, 255)
  # Color of HP gauge (gradation right edge)
  HP_COLOR_RIGHT= Color.new(255, 0, 0, 255)
  # Color of SP gauge (gradation left edge)
  SP_COLOR_LEFT = Color.new(0, 0, 128, 255)
  # Color of SP gauge (gradation right edge)
  SP_COLOR_RIGHT= Color.new(0, 0, 255, 255)
  # Color of CT gauge (gradation left edge)
  COLOR_LEFT = Color.new(128, 128, 64, 255)
  # Color of CT gauge (gradation left edge)
  COLOR_RIGHT= Color.new(255, 255, 128, 255)
  # Color of CT gauge (filled gauge)
  COLOR_FULL = Color.new(255, 225, 128, 255)
  
  # Gauge Frame Color
  FRAME_COLOR = Color.new(192, 192, 192, 255)
  # Gauge Frame Width
  FRAME_BORDER = 1
  # Gauge Frame Background Color
  BACK_COLOR = Color.new(128, 128, 128, 128)

  # Font Size of Actor Names
  NAME_FONT_SIZE = 16
  # Font Size of Actor HP/SP
  HPSP_FONT_SIZE = 18
  # Font Size of Enemy Names
  ENEMY_FONT_SIZE = 16
  # Draw maximum values for HP/SP
  MAX_DRAW = false

  # Group Enemy Names
  # Ex: Instead of "Ghost Ghost" it will say "Ghost2"
  ENEMY_GROUPING = true

  # Draw Bars for Enemies (0: None / 1: HP / 2: CT)
  # If ENEMY_GROUPING is used, then this setting is ignored
  ENEMY_DRAWING_MATER = 0
  
  # Draw Actor HP/SP bars in the help window
  HELP_DRAWING_MATER_ACTOR = false
  # Draw Enemy HP/SP bars in the help window
  HELP_DRAWING_MATER_ENEMY = false
  
  # Command Window Position System (true/false)
  # (Useful with side-view scripts if the position of the Actor Command Window
  # appears unnatural). The default setting is false, while true allows you to
  # adjust the x/y position of the window.
  WINDOWPOS_CHANGE = false
  WINDOWPOS_X = 100   # X coordinates of the Actor Command Window
  WINDOWPOS_Y = 320   # Y coordinates of the Actor Command Window

  # Opacity of the Actor Command Window
  WINDOW_OPACITY = 160
  
  # Sets the intervals of the CT bar updates
  # The lower a setting, the smoother the CT Bar fill will appear (0 Minimum).
  # The higher a setting, the faster the CT Bar refreshes (Useful if lagging).
  CT_SKIP = 2

# End of the config section
#------------------------------------------------------------------------------
end

#==============================================================================
# ** Scene_Battle 
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * CT Update
  #--------------------------------------------------------------------------
  def update_ct
    # When count rise is permitted
    if @countup
      for actor in $game_party.actors
        # If you can act?
        if actor.movable? == false and actor.ct_visible and @phase4_step != 5
          # In invisibility state count rise
          actor.ct_visible = false
          actor.countup = true
          actor.full_ct = false
        elsif actor.movable? and actor.ct_visible == false
          # Cancelling invisibility count rise
          clear_ct(actor)
          actor.ct_visible = true
        end
        # It corresponds to the replacement of the actor
        if actor.max_ct == 0
          actor.max_ct = @max_ct
        end
        # Count rise of actor
        if actor.countup
          # If the CT Gauge is filled and the actor is not in action
          if actor.now_ct >= @max_ct and !(@pre_action_battlers.include?(actor))
            # Adds the actor to the command input list
            @pre_action_battlers.push(actor)
            @action_count += 1
            # Play the CG Gauge SE
            if PARA_CTB::FULL_CT_SE != "" and actor.ct_visible
              Audio.se_play("Audio/SE/" + PARA_CTB::FULL_CT_SE,PARA_CTB::FULL_CT_SE_VOL)
            end
            # Stop filling the CT Gauge
            actor.countup = false
            actor.full_ct = true
          else
            # Count rise
            actor.make_action_speed
            ct_skip = PARA_CTB::CT_SKIP != 0 ? PARA_CTB::CT_SKIP : 1
            actor.now_ct += actor.current_action.speed * PARA_CTB::BATTLE_SPEED * ct_skip
          end
        end
      end
      for enemy in $game_troop.enemies
        # If you can act
        if enemy.movable? == false and enemy.ct_visible and @phase4_step == 5
          # In invisibility state count rise
          enemy.ct_visible = false
          enemy.countup = true
          enemy.full_ct = false
        elsif enemy.movable? and enemy.ct_visible == false
          # Clear the invisible CT
          clear_ct(enemy)
          enemy.ct_visible = true
        end
        # Count rise of enemy
        if enemy.countup
          # if the enemy CT Gauge is full and the enemy is not in action
          if enemy.now_ct >= @max_ct and ! @pre_action_battlers.include?(enemy)
            # Adds the enemy to the command input list
            @pre_action_battlers.push(enemy)
            @action_count += 1
            # Stop filling the CT Gauge
            enemy.countup = false
            enemy.full_ct = true
          else
            # Count rise
            enemy.make_action_speed
            enemy.now_ct += enemy.current_action.speed * PARA_CTB::BATTLE_SPEED
          end
        end
      end
      # Redrawing CT gauge
      @status_window.refresh_ct
      @status_window2.refresh_ct
    end
  end
  #--------------------------------------------------------------------------
  # * Clear the battler CT
  #--------------------------------------------------------------------------
  def clear_ct(battler)
    battler.countup = true
    battler.now_ct = 0
    battler.full_ct = false
  end
  #--------------------------------------------------------------------------
  # * Percentage of battler CT
  #--------------------------------------------------------------------------
  def declease_ct(battler,percent)
    battler.countup = true
    battler.now_ct = battler.now_ct * percent / 100
    battler.full_ct = false
  end
  #--------------------------------------------------------------------------
  # * CT Initialization
  #--------------------------------------------------------------------------
  def initialize_ct
    # Deciding the reference level of CT
    max_ct
    for battler in $game_party.actors + $game_troop.enemies
      if battler.movable?
        n = $game_party.actors.size + $game_troop.enemies.size
        # Set the CT starting level
        battler.now_ct = battler.agi * 60 * n
        battler.ct_visible = true
      else
        clear_ct(battler)
        battler.ct_visible = false
      end
      battler.countup = true
      battler.full_ct = false
      battler.max_ct = @max_ct
    end
  end
  #--------------------------------------------------------------------------
  # * Set the reference level of empty CT based on the Battler's speed
  #--------------------------------------------------------------------------
  def max_ct
    for battler in $game_party.actors + $game_troop.enemies
      @max_ct += battler.agi
    end
    @max_ct *= 100
  end
  #--------------------------------------------------------------------------
  # * Modify the Battler's order of performance
  #--------------------------------------------------------------------------
  def shift_activer(shift)
    # When one shifting, the actor of rear 2 or more
    if @pre_action_battlers != nil
      if shift == 1 and @pre_action_battlers.size >= @actor_array_index + 3
        # Acquiring the present actor
        act = @pre_action_battlers[@actor_array_index]
        # Inserting the present actor in two rear
        @pre_action_battlers.insert(@actor_array_index+2, act)
        # Presently eliminating position
        @pre_action_battlers.delete_at(@actor_array_index)
        @actor_array_index -= 1
        phase3_next_actor
      else
        act = @pre_action_battlers[@actor_array_index]
        # Most adding the present actor to rear
        @pre_action_battlers.push(act)
        # Presently eliminating position
        @pre_action_battlers.delete_at(@actor_array_index)
        @actor_array_index -= 1
        phase3_next_actor
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Main processing
  #--------------------------------------------------------------------------
  alias main_ctb main
  def main
    # Drawing up the enemy name window
    @status_window2 = Window_BattleStatus_enemy.new
    @action_battlers = []
    @pre_action_battlers = []
    @max_ct = 0
    @countup = false
    @ct_wait = 0
    @action_count = 0
    main_ctb
    # Dispose the enemy name window
    @status_window2.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame renewal
  #--------------------------------------------------------------------------
  alias ctb_update update
  def update
    # If battle event is running
    if $game_system.battle_interpreter.running?
      # Update interpreter
      $game_system.battle_interpreter.update
      # If a battler which is forcing actions doesn't exist
      if $game_temp.forcing_battler == nil
        # If battle event has finished running
        unless $game_system.battle_interpreter.running?
          # Rerun battle event set up if battle continues
          unless judge
            setup_battle_event
          end
        end
        # If not after battle phase
        if @phase != 5
          # Refresh status window
          @status_window.refresh
          # Refresh enemy status window
          @status_window2.refresh
        end
      end
    else
      if PARA_CTB::CT_SKIP == 0
        update_ct
      else
        if @ct_wait > 0
          @ct_wait -= 1
        else
          update_ct
          @ct_wait = PARA_CTB::CT_SKIP
        end
      end
    end
    ctb_update
  end
  #--------------------------------------------------------------------------
  # * Start Pre-Battle Phase
  #--------------------------------------------------------------------------
  alias ctb_start_phase1 start_phase1
  def start_phase1
    # CT Initialization
    initialize_ct
    # Start of Count Rise
    @countup = true
    # Run original call
    ctb_start_phase1
  end
  #--------------------------------------------------------------------------
  # * Frame Update (pre-battle phase)
  #--------------------------------------------------------------------------
  def update_phase1
    # Renew the enemy name list
    @status_window2.refresh
    # Determine win/loss situation
    if judge
      # If won or lost: end method
      return
    end
    # Start actor command phase
    start_phase3
  end
  #--------------------------------------------------------------------------
  # * Start Party Command Phase
  #--------------------------------------------------------------------------
  def start_phase2
    # Shift to phase 2
    @phase = 2
    # Set actor to non-selecting
    @actor_index = -1
    @active_battler = nil
    # Enable party command window
    @party_command_window.active = true
    @party_command_window.visible = true
    # Disable actor command window
    @actor_command_window.active = false
    @actor_command_window.visible = false
    # Clear main phase flag
    $game_temp.battle_main_phase = false
    # If impossible to input command
    unless $game_party.inputable?
      # Start main phase
      start_phase4
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (party command phase: escape)
  #--------------------------------------------------------------------------
  def update_phase2_escape
    # Calculate enemy agility average
    enemies_agi = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        enemies_agi += enemy.agi
      end
    end
    # Calculate actor agility average
    actors_agi = 0
    for actor in @pre_action_battlers
      if actor.is_a?(Game_Actor) and actor.exist?
        actors_agi += actor.agi
      end
    end
    # Determine if escape is successful
    success = rand(100) < 50 * actors_agi / enemies_agi
    # If escape is successful
    if success
      # Play escape SE
      $game_system.se_play($data_system.escape_se)
      # Return to BGM before battle started
      $game_system.bgm_play($game_temp.map_bgm)
      # Clear the Battlers' CT
      for battler in $game_party.actors
        clear_ct(battler)
      end
      # Battle ends
      battle_end(1)
    # If escape is failure
    else
      # Set the "Escape Failure" message to the help window
      @help_window.set_text(PARA_CTB::UNESCAPE_MES, 1)
      # Clearing action and CT of the actor
      pre_action_battlers = @pre_action_battlers.clone
      for act in pre_action_battlers
        if act.is_a?(Game_Actor)
          declease_ct(act, 100-PARA_CTB::ACT_ESCAPE_CT)
          act.current_action.clear
          @pre_action_battlers.delete(act)
        end
      end
      @party_command_window.visible = false
      # Hide the help window
      @help_window.visible = true
      @wait_count = 20
      # Start main phase
      start_phase4
    end
  end
  #--------------------------------------------------------------------------
  # * Start Actor Command Phase
  #--------------------------------------------------------------------------
  def start_phase3
    # Shift to phase 3
    @phase = 3
    # Set actor as unselectable
    @actor_index = -1
    @active_battler = nil
    @actor_array_index = -1
    # To command input of the following actor
    if @pre_action_battlers != []
      phase3_next_actor
    else
      start_phase4
    end
  end
  #--------------------------------------------------------------------------
  # * Go to Command Input for Next Actor
  #--------------------------------------------------------------------------
  def phase3_next_actor
    # Loop
    begin
      # Actor blink effect OFF
      if @active_battler != nil
        @active_battler.blink = false
      end
      # If last actor
      if @actor_array_index + 1 == @pre_action_battlers.size
        # Start main phase
        start_phase4
        return
      # The next in case of enemy
      elsif $game_troop.enemies.include?(@pre_action_battlers[@actor_array_index + 1])
        # Start main phase
        start_phase4
        return
      end
      # Advance actor index
      @actor_array_index += 1
      @actor_index = @pre_action_battlers[@actor_array_index].index
      @active_battler = $game_party.actors[@actor_index]
      @active_battler.blink = true
      @active_battler.current_action.clear
    # Once more if actor refuses command input
    end until @active_battler.inputable?
    # Set up actor command window
    phase3_setup_command_window
  end
  #--------------------------------------------------------------------------
  # * Go to Command Input of Previous Actor
  #--------------------------------------------------------------------------
  def phase3_prior_actor
    # Loop
    begin
      # Actor blink effect OFF
      if @active_battler != nil
        @active_battler.blink = false
      end
      # If first actor
      if @actor_array_index <= 0
        # Start party command phase
        start_phase2
        return
      end
      # Return to actor index
      @actor_array_index -= 1
      @actor_index = @pre_action_battlers[@actor_array_index].index
      @active_battler = $game_party.actors[@actor_index]
      @active_battler.blink = true
      @active_battler.current_action.clear
    # Once more if actor refuses command input
    end until @active_battler.inputable?
    # Set up actor command window
    phase3_setup_command_window
  end
  #--------------------------------------------------------------------------
  # * Actor Command Window Setup
  #--------------------------------------------------------------------------
  alias phase3_setup_command_window_ctb phase3_setup_command_window
  def phase3_setup_command_window
    @actor_command_window.back_opacity = PARA_CTB::WINDOW_OPACITY
    phase3_setup_command_window_ctb
    if PARA_CTB::WINDOWPOS_CHANGE
      # Set actor command window position
      @actor_command_window.x = PARA_CTB::WINDOWPOS_X
      @actor_command_window.y = PARA_CTB::WINDOWPOS_Y
      # Way it does not hide in the status window
      @actor_command_window.z = 9999
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (actor command phase)
  #--------------------------------------------------------------------------
  def update_phase3
    # If enemy arrow is enabled
    if @enemy_arrow != nil
      @countup = PARA_CTB::SELECT_WAIT ? false : true
      update_phase3_enemy_select
    # If actor arrow is enabled
    elsif @actor_arrow != nil
      @countup = PARA_CTB::SELECT_WAIT ? false : true
      update_phase3_actor_select
    # If skill window is enabled
    elsif @skill_window != nil
      @countup = PARA_CTB::SELECT_WAIT ? false : true
      update_phase3_skill_select
    # If item window is enabled
    elsif @item_window != nil
      @countup = PARA_CTB::SELECT_WAIT ? false : true
      update_phase3_item_select
    # If actor command window is enabled
    elsif @actor_command_window.active
      @countup = PARA_CTB::COMMAND_WAIT ? false : true
      update_phase3_basic_command
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (actor command phase : basic command)
  #--------------------------------------------------------------------------
  alias ctb_update_phase3_basic_command update_phase3_basic_command
  def update_phase3_basic_command
    ctb_update_phase3_basic_command
    # If left or right buttons are pressed
    if Input.trigger?(Input::R)
      shift_activer(1)
    end
     if Input.trigger?(Input::L)
      shift_activer(-1)
    end
  end
  #--------------------------------------------------------------------------
  # * Start Main Phase
  #--------------------------------------------------------------------------
  def start_phase4
    # Shift to phase 4
    @phase = 4
    battler_count = $game_party.actors.size + $game_troop.enemies.size
    if @action_count >= battler_count or $game_temp.battle_turn == 0
      # Search all battle event pages
      for index in 0...$data_troops[@troop_id].pages.size
        # Get event page
        page = $data_troops[@troop_id].pages[index]
        # If this page span is [turn]
        if page.span == 1
          # Clear action completed flags
          $game_temp.battle_event_flags[index] = false
        end
      end
      # Turn count
      $game_temp.battle_turn += 1
      @action_count = 0
    end
    # Set actor as unselectable
    @actor_index = -1
    @active_battler = nil
    # Enable party command window
    @party_command_window.active = false
    @party_command_window.visible = false
    # Disable actor command window
    @actor_command_window.active = false
    @actor_command_window.visible = false
    # Set main phase flag
    $game_temp.battle_main_phase = true
    # Make enemy action
    for enemy in $game_troop.enemies
      enemy.make_action
    end
    # Make action orders
    make_action_orders
    # Shift to step 1
    @phase4_step = 1
  end
  #--------------------------------------------------------------------------
  # * Make Action Orders
  #--------------------------------------------------------------------------
  def make_action_orders
    # Initialize @action_battlers array
    @action_battlers = []
    if @pre_action_battlers != []
      for i in 0..@actor_array_index
        # Add the actors to the @action_battle array
        @action_battlers.push(@pre_action_battlers[0])
        @pre_action_battlers.shift
      end
      if @pre_action_battlers.size != 0
      loop do
        if $game_troop.enemies.include?(@pre_action_battlers[0])
          # Add the enemies to the @action_battle array
          @action_battlers.push(@pre_action_battlers[0])
          @pre_action_battlers.shift
        else
          break
        end
      end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 1 : action preparation)
  #--------------------------------------------------------------------------
  alias ctb_update_phase4_step1 update_phase4_step1
  def update_phase4_step1
    @countup = true
    # Hide the help window
    @help_window.visible = false
    # Determine win/loss situation
    if judge
      # If won or lost: end method
      return
    end
    # If no actionless battlers exist (all have performed an action)
    if @action_battlers.size == 0
      # Start actor command phase
      start_phase3
      return
    end
    ctb_update_phase4_step1
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 2 : start action)
  #--------------------------------------------------------------------------
  alias ctb_update_phase4_step2 update_phase4_step2
  def update_phase4_step2
    # If not a forcing action
    unless @active_battler.current_action.forcing
      # If restriction is [cannot perform action]
      if @active_battler.restriction == 4
        # Clear the CT
        clear_ct(@active_battler)
        # Clear battler being forced into action
        $game_temp.forcing_battler = nil
        # Shift to step 1
        @phase4_step = 1
        return
      end
    end
    # Determines if CT Gauge is filled during animation
    @countup = PARA_CTB::ANIMATION_WAIT ? false : true
    ctb_update_phase4_step2
  end
  #--------------------------------------------------------------------------
  # * Make Basic Action Results
  #--------------------------------------------------------------------------
  alias make_basic_action_result_ctb make_basic_action_result
  def make_basic_action_result
    # If doing nothing
    if @active_battler.current_action.basic == 3
      # Clear the battler's CT
      clear_ct(@active_battler)
      # Clear battler being forced into action
      $game_temp.forcing_battler = nil
      # Shift to step 1
      @phase4_step = 1
      return
    end
    make_basic_action_result_ctb
  end
  #--------------------------------------------------------------------------
  # * Make Skill Action Results
  #--------------------------------------------------------------------------
  def make_skill_action_result
    # Get skill
    @skill = $data_skills[@active_battler.current_action.skill_id]
    # If not a forcing action
    unless @active_battler.current_action.forcing
      # If unable to use due to SP running out
      unless @active_battler.skill_can_use?(@skill.id)
        # Clear battler being forced into action
        $game_temp.forcing_battler = nil
        # Clear the CT
        declease_ct(@active_battler,100-PARA_CTB::ACT_SKILL_CT)
        # Shift to step 1
        @phase4_step = 1
        return
      end
    end
    # Use up SP
    @active_battler.sp -= @skill.sp_cost
    # Refresh status window
    @status_window.refresh
    # Show skill name on help window
    @help_window.set_text(@skill.name, 1)
    # Set animation ID
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # Set command event ID
    @common_event_id = @skill.common_event_id
    # Set target battlers
    set_target_battlers(@skill.scope)
    # Apply skill effect
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
  end
  #--------------------------------------------------------------------------
  # * Make Item Action Results
  #--------------------------------------------------------------------------
  alias ctb_make_item_action_result make_item_action_result
  def make_item_action_result
    # Get item
    @item = $data_items[@active_battler.current_action.item_id]
    # If unable to use due to items running out
    unless $game_party.item_can_use?(@item.id)
      # Clear the CT
      declease_ct(@active_battler,100-PARA_CTB::ACT_ITEM_CT)
      # Shift to step 1
      @phase4_step = 1
      return
    end
    ctb_make_item_action_result
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 5 : damage display)
  #--------------------------------------------------------------------------
  alias update_phase4_step5_ctb update_phase4_step5
  def update_phase4_step5
    # Display damage
    for target in @target_battlers
      if target.damage != nil
        target.movable_backup = target.movable?
      end
    end
    update_phase4_step5_ctb
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 6 : refresh)
  #--------------------------------------------------------------------------
  alias update_phase4_step6_ctb update_phase4_step6
  def update_phase4_step6
    @active_battler.countup = true
    if @active_battler.current_action.basic == 1
      # Defense
      declease_ct(@active_battler,100-PARA_CTB::ACT_GUARD_CT)
    else
      case @active_battler.current_action.kind
      # Attack
      when 0
        declease_ct(@active_battler,100-PARA_CTB::ACT_ATTACK_CT)
      # Skill
      when 1
        declease_ct(@active_battler,100-PARA_CTB::ACT_SKILL_CT)
      # Item
      when 2
        declease_ct(@active_battler,100-PARA_CTB::ACT_ITEM_CT)
      else
        clear_ct(@active_battler)
      end
    end
    # Clear the CT if the battler is incapacitated
    for target in @target_battlers
      if target.movable? == false and target.movable_backup == true
        clear_ct(target)
        @status_window.refresh_ct
      end
    end
    # Renew the Enemy Name List
    @status_window2.refresh
    update_phase4_step6_ctb
  end
  #--------------------------------------------------------------------------
  # * Start After Battle Phase
  #--------------------------------------------------------------------------
  alias ctb_start_phase5 start_phase5
  def start_phase5
    @countup = false
    ctb_start_phase5
  end
end

#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================

class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(160, 320, 480, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    @level_up_flags = [false, false, false, false]
    @before_hp = []
    @before_sp = []
    @before_states = []
    @now_hp = []
    @now_sp = []
    @now_states = []
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    @item_max = $game_party.actors.size
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      line_height = 120 / PARA_CTB::PARTY_SIZE
      actor_y = i * line_height + 4
      # Present status in arrangement
      @now_hp[i] = actor.hp
      @now_sp[i] = actor.sp
      @now_states[i] = actor.states
      # If leveling up
      if @level_up_flags[i]
        self.contents.fill_rect(344, actor_y+14, 100, 8, Color.new(0, 0, 0, 0))
        self.contents.font.color = normal_color
        self.contents.draw_text(344, actor_y, 120, 32, "LEVEL UP!")
      end
    end
    # Light weight conversion processing of battle status
    # When arrangement of status changes only, drawing processing
    if @before_hp == nil or @before_sp == nil or @before_states == nil or
    @before_hp != @now_hp or @before_sp != @now_sp or @before_states != @now_states
      self.contents.clear
      for i2 in 0...$game_party.actors.size
        actor = $game_party.actors[i2]
        line_height = 120 / PARA_CTB::PARTY_SIZE
        actor_y = i2 * line_height + 4
        self.contents.font.size = PARA_CTB::NAME_FONT_SIZE
        # Draw Actor Name
        draw_actor_name(actor, 4, actor_y+16-PARA_CTB::NAME_FONT_SIZE)
        # Draw HP
        hp_color1 = PARA_CTB::HP_COLOR_LEFT
        hp_color2 = PARA_CTB::HP_COLOR_RIGHT
        draw_meter(actor.hp, actor.maxhp, 125, actor_y+14, 80, 8, hp_color1, hp_color2)
        draw_actor_hp(actor, 102, actor_y+16-PARA_CTB::HPSP_FONT_SIZE, 100)
        # Draw SP
        sp_color1 = PARA_CTB::SP_COLOR_LEFT
        sp_color2 = PARA_CTB::SP_COLOR_RIGHT
        draw_meter(actor.sp, actor.maxsp, 245, actor_y+14, 80, 8, sp_color1, sp_color2)
        draw_actor_sp(actor, 222, actor_y+16-PARA_CTB::HPSP_FONT_SIZE, 100)
        # Status after the changing in arrangement
        @before_hp[i2] = actor.hp
        @before_sp[i2] = actor.sp
        @before_states[i2] = actor.states
        # If Leveling up
        if @level_up_flags[i2]
          self.contents.fill_rect(344, actor_y, 100, 8, Color.new(0, 0, 0, 0))
          self.contents.font.color = normal_color
          self.contents.draw_text(344, actor_y, 120, 32, "LEVEL UP!")
        end
      end
    end
    refresh_ct
  end
  #--------------------------------------------------------------------------
  # * Refresh the CT Gauge
  #--------------------------------------------------------------------------
  def refresh_ct
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      line_height = 120 / PARA_CTB::PARTY_SIZE
      actor_y = i * line_height + 4
      # When the CT gauge is full, color of gauge
      ct_color_full = PARA_CTB::COLOR_FULL
      # Color of CT gauge (left hand edge)
      ct_color_start = actor.full_ct ? ct_color_full : PARA_CTB::COLOR_LEFT
      # Color of CT gauge (right hand edge)
      ct_color_end = actor.full_ct ? ct_color_full : PARA_CTB::COLOR_RIGHT
      if @level_up_flags[i] != true and actor.ct_visible
        draw_meter(actor.now_ct, actor.max_ct, 344, actor_y+14, 100, 8, ct_color_start, ct_color_end)
      elsif @level_up_flags[i] != true
        draw_meter(0, actor.max_ct, 344, actor_y+14, 100, 8, ct_color_start, ct_color_end)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Renewal
  #--------------------------------------------------------------------------
  def update
    super
  end
  #--------------------------------------------------------------------------
  # * Draw HP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #--------------------------------------------------------------------------
  def draw_actor_hp(actor, x, y, width = 144)
    # Draw the "HP" text
    self.contents.font.color = system_color
    self.contents.font.size = 16
    self.contents.draw_text(x, y+2, 32, 32, $data_system.words.hp)
    self.contents.font.color = normal_color
    self.contents.font.size = PARA_CTB::HPSP_FONT_SIZE
    if PARA_CTB::MAX_DRAW
      # Draw the MaxHP
      self.contents.draw_text(x, y, width, 32, actor.maxhp.to_s, 2)
      text_size = self.contents.text_size(actor.maxhp.to_s) 
      text_x = x + width - text_size.width - 12
      self.contents.draw_text(text_x, y, 12, 32, "/", 1)
      # Draw the HP
      self.contents.font.color = actor.hp == 0 ? knockout_color :
        actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
      text_x = text_x - text_size.width
      self.contents.draw_text(text_x, y, text_size.width, 32, actor.hp.to_s, 2)
    else
      self.contents.font.color = actor.hp == 0 ? knockout_color :
        actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
      self.contents.draw_text(x, y, width, 32, actor.hp.to_s, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw SP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #--------------------------------------------------------------------------
  def draw_actor_sp(actor, x, y, width = 144)
    # Draw the "SP" text
    self.contents.font.color = system_color
    self.contents.font.size = 16
    self.contents.draw_text(x, y+2, 32, 32, $data_system.words.sp)
    self.contents.font.color = normal_color
    self.contents.font.size = PARA_CTB::HPSP_FONT_SIZE
    if PARA_CTB::MAX_DRAW
    # Draw the MaxSP
      self.contents.draw_text(x, y, width, 32, actor.maxsp.to_s, 2)
      text_size = self.contents.text_size(actor.maxsp.to_s) 
      text_x = x + width - text_size.width - 12
      self.contents.draw_text(text_x, y, 12, 32, "/", 1)
      # Draw the SP
      self.contents.font.color = actor.sp == 0 ? knockout_color :
        actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
      text_x = text_x - text_size.width
      self.contents.draw_text(text_x, y, text_size.width, 32, actor.sp.to_s, 2)
    else
      self.contents.font.color = actor.sp == 0 ? knockout_color :
        actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
      self.contents.draw_text(x, y, width, 32, actor.sp.to_s, 2)
    end
  end
end

#==============================================================================
# ** Window_BattleStatus_enemy
#------------------------------------------------------------------------------
#  This window displays the status of all enemy troops on the battle screen.
#==============================================================================

class Window_BattleStatus_enemy < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 320, 160, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.font.size = PARA_CTB::ENEMY_FONT_SIZE
    @exist_enemies = []
    if $game_troop.enemies != nil
      if PARA_CTB::ENEMY_GROUPING
        ememy_list = []
        ememy_list_index = []
        # Loop through the Enemy Troop
        for i in 0...$game_troop.enemies.size
          enemy = $game_troop.enemies[i]
          if enemy.exist?
            if ememy_list.include?(enemy.name)
              ememy_list_index[ememy_list.index(enemy.name)] += 1
            else
              # Store the enemy name
              ememy_list.push(enemy.name)
              ememy_list_index[ememy_list.index(enemy.name)] = 1
            end
          end
        end
        # Draw the name and number of the enemy
        enemy_index = 0
        for enemy_name in ememy_list
          enemy_y = enemy_index * (PARA_CTB::ENEMY_FONT_SIZE+6) + 4
          if ememy_list_index[enemy_index] > 1
            enemy_name = enemy_name + " " + ememy_list_index[enemy_index].to_s
          end
          self.contents.draw_text(4, enemy_y, 160, 20, enemy_name)
          enemy_index += 1
        end
      else
        # Draw the enemy name
        enemy_index = 0
        for i in 0...$game_troop.enemies.size
          enemy = $game_troop.enemies[i]
          if enemy.exist?
            @exist_enemies.push(enemy)
            line_height = PARA_CTB::ENEMY_FONT_SIZE + 6
            if PARA_CTB::ENEMY_DRAWING_MATER != 0
              line_height += 10
            end
            enemy_y = enemy_index * line_height + 4
            self.contents.draw_text(4, enemy_y, 160, 20, enemy.name)
            enemy_index += 1
            if PARA_CTB::ENEMY_DRAWING_MATER == 1
              hp_color1 = PARA_CTB::HP_COLOR_LEFT
              hp_color2 = PARA_CTB::HP_COLOR_RIGHT
              y = enemy_y + PARA_CTB::ENEMY_FONT_SIZE + 3
              draw_meter(enemy.hp, enemy.maxhp, 4, y, 80, 8, hp_color1, hp_color2)
            end
          end
        end
      end
    end
    refresh_ct
  end
  #--------------------------------------------------------------------------
  # * Refresh the CT gauge
  #--------------------------------------------------------------------------
  def refresh_ct
    if PARA_CTB::ENEMY_DRAWING_MATER == 2 and @exist_enemies != nil
      enemy_index = 0
      for enemy in @exist_enemies
        line_height = PARA_CTB::ENEMY_FONT_SIZE + 16
        enemy_y = enemy_index * line_height + 4
        y = enemy_y + PARA_CTB::ENEMY_FONT_SIZE + 3
        # When the CT gauge is full, color of gauge
        ct_color_full = PARA_CTB::COLOR_FULL
        # Color of CT gauge (the left edge)
        ct_color_start = enemy.full_ct ? ct_color_full : PARA_CTB::COLOR_LEFT
        # Color of CT gauge (the right edge)
        ct_color_end = enemy.full_ct ? ct_color_full : PARA_CTB::COLOR_RIGHT
        if enemy.ct_visible
          draw_meter(enemy.now_ct, enemy.max_ct, 4, y, 100, 8, ct_color_start, ct_color_end)
        else
          draw_meter(0, enemy.max_ct, 4, y, 100, 8, ct_color_start, ct_color_end)
        end
        enemy_index += 1
      end
    end
  end
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Draw the meter
  #--------------------------------------------------------------------------
  def draw_meter(now, max, x, y, width, height, start_color, end_color=start_color )
    self.contents.fill_rect(x, y, width, height, PARA_CTB::FRAME_COLOR)
    self.contents.fill_rect(x+PARA_CTB::FRAME_BORDER, y+PARA_CTB::FRAME_BORDER, width -
    PARA_CTB::FRAME_BORDER*2, height-PARA_CTB::FRAME_BORDER*2, PARA_CTB::BACK_COLOR)
    now = now > max ? max : now
    percentage = max != 0 ? (width-2) * now / max.to_f : 0
    if start_color == end_color
      self.contents.fill_rect(x+1, y+1, percentage, height-2, start_color)
    else
      for i in 1..percentage
        r = start_color.red + (end_color.red - start_color.red) / percentage * i
        g = start_color.green + (end_color.green - start_color.green) / percentage * i
        b = start_color.blue + (end_color.blue - start_color.blue) / percentage * i
        a = start_color.alpha + (end_color.alpha - start_color.alpha) / percentage * i
        self.contents.fill_rect(x+i, y+1, 1, height-2, Color.new(r, g, b, a))
      end
    end
  end
end

#==============================================================================
# ** Game_Battler 
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass for the Game_Actor
#  and Game_Enemy classes.
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :max_ct
  attr_accessor :now_ct
  attr_accessor :full_ct
  attr_accessor :countup
  attr_accessor :ct_visible
  attr_accessor :movable_backup
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias ctb_initialize initialize
  def initialize
    ctb_initialize
    @max_ct = 0
    @now_ct = 0
    @full_ct = false
    @countup = true
    @ct_visible = true
  end
end

#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
#  This sprite is used to display the battler.It observes the Game_Character
#  class and automatically changes sprite conditions.
#==============================================================================

class Sprite_Battler < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias ctb_update update
  def update
    ctb_update
    if @battler != nil
      if @battler.full_ct and @battler.ct_visible
        # Change the color tone of the battler when the CT Gauge is full
        fullct_color = PARA_CTB::FULL_CT_COLOR
        self.tone = fullct_color
      else
        fullct_color = Tone.new(0,0,0)
        self.tone = fullct_color
      end
    end
  end
end

#==============================================================================
# ** Window_Help
#------------------------------------------------------------------------------
#  This window shows skill and item explanations along with actor status.
#==============================================================================

class Window_Help < Window_Base
  #--------------------------------------------------------------------------
  # * Set Actor
  #     actor : status displaying actor
  #--------------------------------------------------------------------------
  alias set_actor_ctb set_actor
  def set_actor(actor)
    if PARA_CTB::HELP_DRAWING_MATER_ACTOR
      self.contents.clear
      draw_actor_name(actor, 4, 0)
      draw_actor_state(actor, 140, 0)
      hp_color1 = PARA_CTB::HP_COLOR_LEFT
      hp_color2 = PARA_CTB::HP_COLOR_RIGHT
      draw_meter(actor.hp, actor.maxhp, 316, 18, 112, 8, hp_color1, hp_color2)
      draw_actor_hp(actor, 284, 0)
      sp_color1 = PARA_CTB::SP_COLOR_LEFT
      sp_color2 = PARA_CTB::SP_COLOR_RIGHT
      draw_meter(actor.sp, actor.maxsp, 492, 18, 112, 8, sp_color1, sp_color2)
      draw_actor_sp(actor, 460, 0)
      @actor = actor
      @text = nil
      self.visible = true
    else
      set_actor_ctb(actor)
    end
  end
  #--------------------------------------------------------------------------
  # * Set Enemy
  #     enemy : name and status displaying enemy
  #--------------------------------------------------------------------------
  alias set_enemy_ctb set_enemy
  def set_enemy(enemy)
    if PARA_CTB::HELP_DRAWING_MATER_ENEMY
      self.contents.clear
      draw_actor_name(enemy, 4, 0)
      draw_actor_state(enemy, 140, 0)
      hp_color1 = PARA_CTB::HP_COLOR_LEFT
      hp_color2 = PARA_CTB::HP_COLOR_RIGHT
      draw_meter(enemy.hp, enemy.maxhp, 316, 18, 112, 8, hp_color1, hp_color2)
      draw_actor_hp(enemy, 284, 0)
      sp_color1 = PARA_CTB::SP_COLOR_LEFT
      sp_color2 = PARA_CTB::SP_COLOR_RIGHT
      draw_meter(enemy.sp, enemy.maxsp, 492, 18, 112, 8, sp_color1, sp_color2)
      draw_actor_sp(enemy, 460, 0)
      self.visible = true
    else
      set_enemy_ctb(enemy)
    end
  end
end

Code:

#==============================================================================
#ã€€ï¼‹ï¼‹ã€€ã‚¢ã‚¯ãƒ†ã‚£ãƒ–ã‚¿ã‚¤ãƒ ãƒãƒˆãƒ«ã€€ver. 2.58ã€€ï¼‹ï¼‹
#ã€€ã€€Script by ãƒ‘ãƒ©çŠ¬
#ã€€ã€€http://2d6.parasite.jp/
#------------------------------------------------------------------------------
# CTã‚²ãƒ¼ã‚¸ãŒæºœã¾ã£ãŸãƒãƒˆãƒ©ãƒ¼ã‹ã‚‰é †ã«ã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›ã™ã‚‹æˆ¦é—˜å½¢å¼ã€‚
# ãƒãƒˆãƒ«ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ç”»é¢ã‚’ã‚µã‚¤ãƒ‰ãƒ“ãƒ¥ãƒ¼ã‚‰ã—ãã™ã‚‹æ©Ÿèƒ½ã‚‚ã‚ã‚Šã¾ã™ã€‚
# ãƒãƒˆãƒ©ãƒ¼ã‚’ã‚µã‚¤ãƒ‰ãƒ“ãƒ¥ãƒ¼ã‚¿ã‚¤ãƒ—ã«è¡¨ç¤ºã™ã‚‹ã‚¹ã‚¯ãƒªãƒ—ãƒˆã¯ã€ãŠå¥½ããªã‚‚ã®ã‚’
# ç”¨æ„ã—ã¦ãã ã•ã„ã€‚
#------------------------------------------------------------------------------
#ï¼»è¨ç½®ä¸Šã®æ³¨æ„ï¼½
# æˆ¦é—˜ç³»ã‚¹ã‚¯ãƒªãƒ—ãƒˆã‚’ä½µç”¨ã™ã‚‹ã¨ãã¯ã§ãã‚‹ã ã‘ä¸Šã®ã»ã†ã«ç½®ã„ã¦ãã ã•ã„ã€‚
# ï¼ˆScene_Debugã‚ˆã‚Šã¯ä¸‹ï¼‰
#------------------------------------------------------------------------------
#ï¼»æ“ä½œï¼½
#ãƒ»é€ƒèµ°
#ã€€å‘³æ–¹ãƒãƒˆãƒ©ãƒ¼ã®ä¸€äººä»¥ä¸ŠãŒã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›å¾…ã¡ã®ã¨ãã«ã‚ãƒ£ãƒ³ã‚»ãƒ«ãƒœã‚¿ãƒ³ã‚’æŠ¼ã™ã“ã¨ã§
#ã€€ã€Œé€ƒã’ã‚‹ã€ã‚³ãƒžãƒ³ãƒ‰ãŒé¸æŠžã§ãã¾ã™ã€‚
#ã€€æ•µã®æ•°ãŒå¤šã‹ã£ãŸã‚Šã€ã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›å¾…ã¡ã®ãƒãƒˆãƒ©ãƒ¼ãŒå°‘ãªã„ã¨ã€
#ã€€é€ƒèµ°æˆåŠŸçŽ‡ãŒä½Žããªã‚Šã¾ã™ã€‚
#
#ãƒ»è¡Œå‹•é †ã®å…¥ã‚Œæ›¿ãˆ
#ã€€è¤‡æ•°ã®ãƒãƒˆãƒ©ãƒ¼ãŒè¡Œå‹•å¯èƒ½ã®ã¨ãã€
#ã€€Rãƒœã‚¿ãƒ³ï¼ˆPageDownã‚ãƒ¼ï¼‰ã§æ¬¡ã®ãƒãƒˆãƒ©ãƒ¼ã¨é †ç•ªã‚’å…¥ã‚Œæ›¿ãˆã€
#ã€€Lãƒœã‚¿ãƒ³ï¼ˆPageUpã‚ãƒ¼ï¼‰ã§è¡Œå‹•é †ã‚’ã„ã¡ã°ã‚“æœ€å¾Œã«å›žã—ã¾ã™ã€‚
#==============================================================================

module PARA_CTB
  
  # ã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›æ™‚ã«CTã®ã‚«ã‚¦ãƒ³ãƒˆã‚’æ¢ã‚ã‚‹ã‹ï¼ˆtrue:æ¢ã‚ã‚‹ / false:æ¢ã‚ãªã„ï¼‰
  COMMAND_WAIT = false
  # ã‚¢ã‚¤ãƒ†ãƒ ã€ã‚¹ã‚ãƒ«ã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆé¸æŠžæ™‚ã«CTã®ã‚«ã‚¦ãƒ³ãƒˆã‚’æ¢ã‚ã‚‹ã‹ï¼ˆtrue:æ¢ã‚ã‚‹ / false:æ¢ã‚ãªã„ï¼‰
  SELECT_WAIT = true
  # ã‚¢ãƒ‹ãƒ¡ãƒ¼ã‚·ãƒ§ãƒ³è¡¨ç¤ºæ™‚ã«CTã®ã‚«ã‚¦ãƒ³ãƒˆã‚’æ¢ã‚ã‚‹ã‹ï¼ˆtrue:æ¢ã‚ã‚‹ / false:æ¢ã‚ãªã„ï¼‰
  ANIMATION_WAIT = false
  
  # ãƒãƒˆãƒ«ã‚¹ãƒ”ãƒ¼ãƒ‰ï¼ˆæ•°å€¤ãŒå¤§ãã„ã»ã©CTã®æºœã¾ã‚ŠãŒé€Ÿããªã‚‹ï¼‰
  BATTLE_SPEED = 3

  # ãƒãƒˆãƒ«ãƒ¡ãƒ³ãƒãƒ¼ã®æœ€å¤§æ•°ï¼ˆå¤šäººæ•°PTã‚¹ã‚¯ãƒªãƒ—ãƒˆã‚’å°Žå…¥ã—ã¦ã„ã‚‹æ™‚ã«è¨å®šï¼‰
  PARTY_SIZE = 4
  
  # è¡Œå‹•çµ‚äº†æ™‚ã®CTæ¸›å°‘ãƒ‘ãƒ¼ã‚»ãƒ³ãƒ†ãƒ¼ã‚¸
  ACT_ATTACK_CT = 100   # é€šå¸¸æ”»æ’ƒ
  ACT_GUARD_CT = 100    # é˜²å¾¡
  ACT_ESCAPE_CT = 100   # é€ƒèµ°å¤±æ•—
  ACT_SKILL_CT = 100    # ã‚¹ã‚ãƒ«
  ACT_ITEM_CT = 100     # ã‚¢ã‚¤ãƒ†ãƒ 
  
  # é€ƒèµ°å¤±æ•—æ™‚ã®ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸
  UNESCAPE_MES = "é€ƒèµ°å¤±æ•—"

  # CTæº€ã‚¿ãƒ³æ™‚ã®åŠ¹æžœéŸ³ï¼ˆ""ã§éŸ³ã‚’é³´ã‚‰ã•ãªã„ï¼‰
  # åŠ¹æžœéŸ³ã¯ã€ŒAudio/SEã€ãƒ•ã‚©ãƒ«ãƒ€å†…
  FULL_CT_SE = "015-Jump01"
  # åŠ¹æžœéŸ³ã®ãƒœãƒªãƒ¥ãƒ¼ãƒ 
  FULL_CT_SE_VOL = 80

  # CTæº€ã‚¿ãƒ³æ™‚ã®ãƒãƒˆãƒ©ãƒ¼ã®è‰²èª¿ï¼ˆ(0,0,0)ã§å¤‰åŒ–ãªã—ï¼‰
  FULL_CT_COLOR = Tone.new(32,0,0)
  
  # HPã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å·¦ç«¯ï¼‰
  HP_COLOR_LEFT = Color.new(128, 0, 0, 255)
  # HPã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å³ç«¯ï¼‰
  HP_COLOR_RIGHT= Color.new(255, 0, 0, 255)
  # SPã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å·¦ç«¯ï¼‰
  SP_COLOR_LEFT = Color.new(0, 0, 128, 255)
  # SPã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å³ç«¯ï¼‰
  SP_COLOR_RIGHT= Color.new(0, 0, 255, 255)
  # CTã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å·¦ç«¯ï¼‰
  COLOR_LEFT = Color.new(128, 128, 64, 255)
  # CTã‚²ãƒ¼ã‚¸ã®è‰²ï¼ˆã‚°ãƒ©ãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³å³ç«¯ï¼‰
  COLOR_RIGHT= Color.new(255, 255, 128, 255)
  # CTãŒæº€ã‚¿ãƒ³ã«ãªã£ãŸã¨ãã®ã‚²ãƒ¼ã‚¸ã®è‰²
  COLOR_FULL = Color.new(255, 225, 128, 255)
  
  # ã‚²ãƒ¼ã‚¸æž ã®è‰²
  FRAME_COLOR = Color.new(192, 192, 192, 255)
  # ã‚²ãƒ¼ã‚¸æž ã®å¤ªã•
  FRAME_BORDER = 1
  # ã‚²ãƒ¼ã‚¸ã®èƒŒæ™¯è‰²
  BACK_COLOR = Color.new(128, 128, 128, 128)

  # åå‰ã®ãƒ•ã‚©ãƒ³ãƒˆã‚µã‚¤ã‚º
  NAME_FONT_SIZE = 16
  # HP/SPã®ãƒ•ã‚©ãƒ³ãƒˆã‚µã‚¤ã‚º
  HPSP_FONT_SIZE = 18
  # ã‚¨ãƒãƒŸãƒ¼åã®ãƒ•ã‚©ãƒ³ãƒˆã‚µã‚¤ã‚º
  ENEMY_FONT_SIZE = 16
  # æœ€å¤§HP/SPã‚’æç”»ã™ã‚‹ã‹ï¼ˆ true / false ï¼‰
  MAX_DRAW = false

  # ã‚¨ãƒãƒŸãƒ¼åã‚’ã‚°ãƒ«ãƒ¼ãƒ—åŒ–ï¼ˆ true / false ï¼‰
  # ï¼ˆtrueã«ã™ã‚‹ã¨ã€Œã‚´ãƒ¼ã‚¹ãƒˆ 2ã€ã®ã‚ˆã†ã«ã¾ã¨ã‚ã¦è¡¨ç¤ºã—ã¾ã™ï¼‰
  ENEMY_GROUPING = false

  # ã‚¨ãƒãƒŸãƒ¼åã®ä¸‹ã«ã‚²ãƒ¼ã‚¸ã‚’è¡¨ç¤ºï¼ˆ 0:ãªã— / 1:HP / 2:CT ï¼‰
  # ï¼ˆã‚¨ãƒãƒŸãƒ¼åã‚’ã‚°ãƒ«ãƒ¼ãƒ—åŒ–ã—ã¦ã„ã‚‹å ´åˆã¯ç„¡åŠ¹ï¼‰
  ENEMY_DRAWING_MATER = 0
  
  # ã‚¢ã‚¯ã‚¿ãƒ¼ã®ãƒ˜ãƒ«ãƒ—ã‚¦ã‚¤ãƒ³ãƒ‰ã‚¦ã«HP/SPã‚²ãƒ¼ã‚¸ã‚’è¡¨ç¤ºï¼ˆ true / false ï¼‰
  HELP_DRAWING_MATER_ACTOR = false
  # ã‚¨ãƒãƒŸãƒ¼ã®ãƒ˜ãƒ«ãƒ—ã‚¦ã‚¤ãƒ³ãƒ‰ã‚¦ã«HP/SPã‚²ãƒ¼ã‚¸ã‚’è¡¨ç¤ºï¼ˆ true / false ï¼‰
  HELP_DRAWING_MATER_ENEMY = false
  
  # ã‚³ãƒžãƒ³ãƒ‰ã‚¦ã‚¤ãƒ³ãƒ‰ã‚¦ã®ä½ç½®ã‚’å¼·åˆ¶æŒ‡å®šï¼ˆ true / false ï¼‰
  #ï¼ˆä»–ã®æ–¹ã®ã‚µã‚¤ãƒ‰ãƒ“ãƒ¥ãƒ¼ã‚¹ã‚¯ãƒªãƒ—ãƒˆã‚’ä½µç”¨ã—ã¦ã„ã¦
  # ã‚³ãƒžãƒ³ãƒ‰ã‚¦ã‚¤ãƒ³ãƒ‰ã‚¦ã®ä½ç½®ãŒã©ã†ã—ã¦ã‚‚ä¸è‡ªç„¶ã«ãªã‚‹ãªã‚‰trueã«ï¼‰
  # â€»trueã«ã—ã¦ã‚‚é©ç”¨ã•ã‚Œãªã„å ´åˆã€ã“ã®ã‚¹ã‚¯ãƒªãƒ—ãƒˆã‚’
  # ã€€ã‚µã‚¤ãƒ‰ãƒ“ãƒ¥ãƒ¼ã‚ˆã‚Šã‚‚ä¸‹ã«ç½®ã„ã¦ã¿ã¦ãã ã•ã„
  WINDOWPOS_CHANGE = false
  WINDOWPOS_X = 100   # Xåº§æ¨™
  WINDOWPOS_Y = 320   # Yåº§æ¨™

  # ã‚³ãƒžãƒ³ãƒ‰ã‚¦ã‚¤ãƒ³ãƒ‰ã‚¦ã®ä¸é€æ˜Žåº¦
  WINDOW_OPACITY = 160
  
  # CTã®ã‚«ã‚¦ãƒ³ãƒˆé–“éš”ã€‚å°‘ãªã„ã»ã©ã‚²ãƒ¼ã‚¸æç”»ãŒãªã‚ã‚‰ã‹ã«ã€‚(æœ€å°å€¤ã¯0)
  # å‡¦ç†ãŒé‡ã„å ´åˆã¯ã€ã“ã®æ•°å€¤ã‚’ä¸Šã’ã¦ãã ã•ã„ã€‚
  CT_SKIP = 2

end

# â†‘ è¨å®šé …ç›®ã“ã“ã¾ã§
#------------------------------------------------------------------------------

#==============================================================================
# â–  Scene_Battle
#==============================================================================

class Scene_Battle

  #--------------------------------------------------------------------------
  # â—‹ CTã®ã‚«ã‚¦ãƒ³ãƒˆ
  #--------------------------------------------------------------------------
  def update_ct
    # ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—ãŒè¨±å¯ã•ã‚Œã¦ã„ã‚‹ã¨ã
    if @countup
      for actor in $game_party.actors
        # è¡Œå‹•ã§ãã‚‹ã‹
        if actor.movable? == false and actor.ct_visible and @phase4_step != 5
          # ä¸å¯è¦–çŠ¶æ…‹ã§ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
          actor.ct_visible = false
          actor.countup = true
          actor.full_ct = false
        elsif actor.movable? and actor.ct_visible == false
          # ä¸å¯è¦–ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—ã‚’è§£é™¤
          clear_ct(actor)
          actor.ct_visible = true
        end
        # ã‚¢ã‚¯ã‚¿ãƒ¼ã®å…¥ã‚Œæ›¿ãˆã«å¯¾å¿œ
        if actor.max_ct == 0
          actor.max_ct = @max_ct
        end
        # ã‚¢ã‚¯ã‚¿ãƒ¼ã®ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
        if actor.countup
          # CTãŒmaxã«ãªã£ã¦ãŠã‚Šã€ã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›å¾…ã¡ã‚¢ã‚¯ã‚¿ãƒ¼ã«å«ã¾ã‚Œãªã„
          if actor.now_ct >= @max_ct and !(@pre_action_battlers.include?(actor))
            # ã‚³ãƒžãƒ³ãƒ‰å…¥åŠ›å¾…ã¡ã‚¢ã‚¯ã‚¿ãƒ¼ã«è¿½åŠ 
            @pre_action_battlers.push(actor)
            @action_count += 1
            # åŠ¹æžœéŸ³ã‚’é³´ã‚‰ã™
            if PARA_CTB::FULL_CT_SE != "" and actor.ct_visible
              Audio.se_play("Audio/SE/" + PARA_CTB::FULL_CT_SE,PARA_CTB::FULL_CT_SE_VOL)
            end
            # ãã‚Œä»¥ä¸Šã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—ã—ãªã„
            actor.countup = false
            actor.full_ct = true
          else
            # ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
            actor.make_action_speed
            ct_skip = PARA_CTB::CT_SKIP != 0 ? PARA_CTB::CT_SKIP : 1
            actor.now_ct += actor.current_action.speed * PARA_CTB::BATTLE_SPEED * ct_skip
          end
        end
      end
      for enemy in $game_troop.enemies
        # è¡Œå‹•ã§ãã‚‹ã‹
        if enemy.movable? == false and enemy.ct_visible and @phase4_step == 5
          # ä¸å¯è¦–çŠ¶æ…‹ã§ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
          enemy.ct_visible = false
          enemy.countup = true
          enemy.full_ct = false
        elsif enemy.movable? and enemy.ct_visible == false
          # ä¸å¯è¦–ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—ã‚’è§£é™¤
          clear_ct(enemy)
          enemy.ct_visible = true
        end
        # ã‚¨ãƒãƒŸãƒ¼ã®ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
        if enemy.countup
          # CTãŒmaxã«ãªã£ã¦ãŠã‚Šã€è¡Œå‹•å¾…ã¡ã‚¨ãƒãƒŸãƒ¼ã«å«ã¾ã‚Œãªã„
          if enemy.now_ct >= @max_ct and ! @pre_action_battlers.include?(enemy)
            # è¡Œå‹•å¾…ã¡ã‚¨ãƒãƒŸãƒ¼ã«è¿½åŠ 
            @pre_action_battlers.push(enemy)
            @action_count += 1
            # ãã‚Œä»¥ä¸Šã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—ã—ãªã„
            enemy.countup = false
            enemy.full_ct = true
          else
            # ã‚«ã‚¦ãƒ³ãƒˆã‚¢ãƒƒãƒ—
            enemy.make_action_speed
            enemy.now_ct += enemy.current_action.speed * PARA_CTB::BATTLE_SPEED
          end
        end
      end
      # CTã‚²ãƒ¼ã‚¸ã‚’å†æç”»
      @status_window.refresh_ct
      @status_window2.refresh_ct
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ ãƒãƒˆãƒ©ãƒ¼ã®CTã‚’0ã«
  #--------------------------------------------------------------------------
  def clear_ct(battler)
    battler.countup = true
    battler.now_ct = 0
    battler.full_ct = false
  end
  #--------------------------------------------------------------------------
  # â—‹ ãƒãƒˆãƒ©ãƒ¼ã®CTã‚’ä»»æ„ã®ãƒ‘ãƒ¼ã‚»ãƒ³ãƒ†ãƒ¼ã‚¸ã«
  #--------------------------------------------------------------------------
  def declease_ct(battler,percent)
    battler.countup = true
    battler.now_ct = battler.now_ct * percent / 100
    battler.full_ct = false
  end
  #--------------------------------------------------------------------------
  # â—‹ CTã®åˆæœŸåŒ–
  #--------------------------------------------------------------------------
  def initialize_ct
    # CTã®åŸºæº–å€¤ã‚’æ±ºå®š
    max_ct
    for battler in $game_party.actors + $game_troop.enemies
      if battler.movable?
        n = $game_party.actors.size + $game_troop.enemies.size
        # æˆ¦é—˜é–‹å§‹æ™‚ã«ã‚ã‚‹ç¨‹åº¦ã®CTã‚’æºœã‚ã¦ãŠã
        battler.now_ct = battler.agi * 60 * n
        battler.ct_visible = true
      else
        clear_ct(battler)
        battler.ct_visible = false
      end
      battler.countup = true
      battler.full_ct = false
      battler.max_ct = @max_ct
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ ãƒãƒˆãƒ©ãƒ¼å…¨å“¡ã®ç´ æ—©ã•ã‹ã‚‰CTã®åŸºæº–å€¤ã‚’æ±ºå®š
  #--------------------------------------------------------------------------
  def max_ct
    for battler in $game_party.actors + $game_troop.enemies
      @max_ct += battler.agi
    end
    @max_ct *= 100
  end
  #--------------------------------------------------------------------------
  # â—‹ ãƒãƒˆãƒ©ãƒ¼ã®&#3489

Landarma · Dec 27, 2006

And here are compatible side view scripts:
ParaDog's Side-view(Character Sprite as Battler)
Side-view from RGSS Wiki
(And perhaps) RaiseField's Side-view scripts

Mimi Chan · Dec 27, 2006

pretty neat, i guess i found the 'other half' of my battlesystem thanks guys

err what does the other add on do?

Landarma · Dec 27, 2006

Excuse me, which add on?

Mimi Chan · Dec 27, 2006

all of them @_@...if possible please

Reaper* · Dec 27, 2006

Dervvulfman i had posted it already in my thread "front view battle system" but you can leave it here if you want

DerVVulfman · Dec 27, 2006

Actually, you have v 1.14 of an add-on. It's not exactly the same. The website (http://2d6.parasite.jp/) has a copy of your posted script, the new v 2.58 system, and the add-ons that Landarma just mentioned.

Edit: What you have is the Sideview script, not the CTB. (Babelfished it).

Reaper* · Dec 28, 2006

I had made a copy of the script if you scroll down in the last posts

DerVVulfman · Dec 28, 2006

Ah... I see... megaupload link. I missed seeing it.

Reaper* · Dec 29, 2006

Leave it here they will see more yours then mine (I mean the atb script)

WithViolence · Feb 11, 2007

Sorry to rez. a dead post, but I was wondering if how you could change the battlers alignment. Normally, they would align left-to-right, but I don't like how the last battler overlaps the enemies window, and I'll only be using three characters anyway. Any ideas?

DerVVulfman · Feb 11, 2007

Hey, it's only been a month and a half... dead usually means a 'few' months at least.

As a frontview system, it still uses the same positioning system of the default system for the actors and enemies. You'd be looking at Game_Actor/def screen_x to make any adjustments.

return self.index * 160 + 80
This spaces the battlers 160 pixels apart (640/4) and centers the first battler at pixel 80.
This would hold true for the default system as well...

But to ensure that ParaDog's system has only 3 battlers available, you'd be setting the PARTY_SIZE value to 3. And I'd recommend using Fomar0153's Large Party script to limit your party size to 3, though it was really designed to increase your party to sizes above 4.

Mimi Chan · Feb 11, 2007

i was just wondering why skills animation that has a 'screen' tag dont show properly (they are way below) e.g. is the mass earth skill, you cant even see the spike sinces it is covered by the battle status window

DerVVulfman · Feb 12, 2007

The designer of that screen animation only expected the rocks to rise up only so far. It's just bad luck that they made it only rise 40 pixels higher than the top of the battlestatus window.

Mimi Chan · Feb 12, 2007

no, i mean err...just look at this screen thingy:
http://i19.photobucket.com/albums/b170/Teh-Mimi/untitled-2.jpg
see how the lightning is way lower than where it supposed to be

and oh i get this errors too:
http://i19.photobucket.com/albums/b170/Teh-Mimi/errors.jpg
the first one happens, well when i go into battle everything is fine not until i battle a second time and that error pops up (maybe it has something to do about it placed below ABS) though when i put it on top of ABS the second error pops up (err the consiquences of having a dual battle system *sob*)

DerVVulfman · Feb 13, 2007

I took a look... and it's not ParaDog's system afterall. It's Animated Battlers... when the animation affects the whole screen and not a specific battler (so it was easily overlooked). For some reason, it shifts the FULL-SCREEN battle animations down 160 pixels, exactly the size difference between the screen's height and the battlescreen's default 320 height.

Gonna look into it and see about fixing that. (Posting error in Anim Battlers.)

As far as getting those other errors fixed, it may be dual-battlesystem related. But as I'm not working on a dual system myself, and haven't messed with an ABS (yep... not even SBABS...), I don't know.

Twin Matrix · Feb 13, 2007

Is this better than the RTAB? oO

DerVVulfman · Feb 13, 2007

It can use more 'default-based' scripts than RTAB, but it's more of a 'Conditional Battle System' even with the AT bars.

If you want the Enemies to attack you while you're making up your mind, use RTAB or Trickster's ATB+CTB system.

If you want an AT Bar system (but without the enemies attacking you until its their 'turn') and compatability, use this.

Petros · Jul 20, 2007

This battle system is great and easy to use and install. However as it's not SDK it does clash with a few things here and there, most of which I've weeded through, with one exception, the Limit Break script by DerVVulfmann, any idea on how to fix this?

DerVVulfman · Jul 20, 2007

Yeah, by using the ParaDog/Limit Break Adaption patch in the Limit Break topic.

Envision, Create, Share

ParaDog's ATB

DerVVulfman

Landarma

Mimi Chan

Landarma

Mimi Chan

Reaper*

DerVVulfman

Reaper*

DerVVulfman

Reaper*

WithViolence

DerVVulfman

Mimi Chan

DerVVulfman

Mimi Chan

DerVVulfman

Twin Matrix

DerVVulfman

Petros

DerVVulfman

Share this page

Thank you for viewing

Discord

RPG Maker

Content