Save-Point

If anyone's up to the challenge, I have a modified battle system that I'd like to have it converted to an Active Time Battle, with MP being the ATB. I'd also like it to be compatible with Straycat's 15 and 11d scripts, as well as KGC's. In addition, if for any matter you'd have to rescript the whole system, I'd like it to be able to fit 640*480.

I'd prefer if the interface is the same, thus suggesting the MP being the ATB bar.

The current script requires 2 images - Help.png(640*48) and Arrow.png(24*24)
Content Hidden
Code:
#==============================================================================#

# Configuration                                                                #

#------------------------------------------------------------------------------#

module BattleConfig

  # System Images (in the system folder)

  HelpStripImage = "Help"

  TargetImage = "Arrow"

  HelpFont = "Trebuchet MS"

  EndImage = "BattleEnd"

  # Messages shown in-battle

  FightMessage = "Engage in battle"

  RunMessage = "Escape from battle"

  ForbidRunMessage = "You can't escape from this battle!"

  AttackText = "Attack with current weapon"

  SkillText = "Use a skill"

  GuardText = "Defend self"

  ItemText = "Use an item"

  ShakeRate = 4

  ShakeDuration = 8

  GM_HUE = 100

end

#------------------------------------------------------------------------------#

# End Configuration                                                            #

#==============================================================================#

# Window_Base                                                                  #

#------------------------------------------------------------------------------#

class Window_Base < Window

  def set_text(text, align = 0)

    if text != @text or align != @align

      self.contents.clear

      self.contents.font.color = normal_color

      self.contents.draw_text(4, 0, self.width - 40, WLH, text, align)

      @text = text

      @align = align

    end

  end

  def slide(dx, dy)

    if self.x != dx

      self.x += ((dx - self.x) / 2)

    end

    if self.y != dy

      self.y += ((dy - self.y) / 2)

    end

  end

  def start_shake(power, time)

    @shake_time = time*2

    @shake_power =power

  end

  def update_shake

    @shake_time = 0 if @shake_time.nil?

    return if @shake_time <= 0

    @shake_time -= 1

    if @shake_time%2 == 0 #even

      self.x += @shake_power

    else #odd

      self.x -= @shake_power

    end

  end

end

#==============================================================================#

# Window_Command                                                               #

#------------------------------------------------------------------------------#

class Window_Command < Window_Selectable

  attr_reader   :commands

  def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32)

    if row_max == 0

      row_max = (commands.size + column_max - 1) / column_max

    end

    super(0, 0, width, row_max * WLH + 32, spacing)

    @commands = commands

    @item_max = commands.size

    @column_max = column_max

    refresh

    self.index = 0

  end

  def refresh

    self.contents.clear

    for i in 0...@item_max

      draw_item(i)

    end

  end

end

#==============================================================================#

# Window_BattleHelp                                                            #

#------------------------------------------------------------------------------#

class Window_BattleHelp < Window_Base

  def initialize

    super(0, 0, 640, WLH + 32)

  end

  def set_text(text, align = 1)

    if text != @text or align != @align

      self.contents.clear

      self.contents.font.name = BattleConfig::HelpFont

      self.contents.font.color = Color.new(0, 0, 0, 255)

      self.contents.draw_text(4, 1, self.width - 40, WLH, text, align)

      self.contents.draw_text(4, -1, self.width - 40, WLH, text, align)

      self.contents.draw_text(5, 0, self.width - 40, WLH, text, align)

      self.contents.draw_text(3, 0, self.width - 40, WLH, text, align)

      self.contents.font.color = normal_color

      self.contents.draw_text(4, 0, self.width - 40, WLH, text, align)

      @text = text

      @align = align

    end

  end

  def add_instant_text(text)

    set_text(text)

  end

end

#==============================================================================#

# Window_PartyCommand                                                          #

#------------------------------------------------------------------------------#

class Window_PartyCommand < Window_Command

  def initialize

    s1 = "Fight"#draw_icon(BattleConfig::FightIcon, self.x, self.y)

    if $game_troop.can_escape == true

      s2 = "Escape"#draw_icon(BattleConfig::RunIcon, self.x, self.y)

    else

      s2 = "Can't Escape"#draw_icon(BattleConfig::ForbidRunIcon, self.x, self.y)

    end

    super(640, [s1, s2], 1, 1)

    @item_max = 2

    @column_max = 2

    draw_item(0, true)

    if $game_troop.can_escape == true

      draw_item(1, $game_troop.can_escape)

    else

      draw_item(1, $game_troop.can_escape)

    end

    self.active = false

  end

end

#==============================================================================#

# Window_ActorCommand                                                          #

#------------------------------------------------------------------------------#

class Window_ActorCommand < Window_Command

  def initialize

    super(640, [], 1, 1)

    self.active = false

  end

  def setup(actor)

    @commands = ["Attack", "Skill", "Guard", "Item"]

    @item_max = 4

    @column_max = 4

    refresh

    self.index = 0

  end

  def refresh

    self.contents.clear

    draw_item(0)

    draw_item(1)

    draw_item(2)

    draw_item(3)

  end

end

#==============================================================================#

# Window_ActorBattleStatus                                                     #

#------------------------------------------------------------------------------#

class Window_ActorBattleStatus < Window_Base

  def initialize(x, y)

    super(x, y, 160, 64)

  end

end

#==============================================================================#

# Window_ActorStatus                                                           #

#------------------------------------------------------------------------------#

class Window_ActorStatus < Window_Base

  def initialize(x, y, actor)

    super(x, y, 200, 200)

    @actor = actor

    self.opacity = 0

    self.z = 1500

    refresh

  end

  def refresh

    self.contents.clear

    draw_actor_name(@actor, 108, 16)

    draw_actor_state(@actor, 10, 52, 64)

    draw_actor_hp(@actor, 72, 38, 80)

    draw_actor_mp(@actor, 84, 48, 58)

  end

end

#==============================================================================#

# Window_ActorBattleStatusFace                                                 #

#------------------------------------------------------------------------------#

class Window_ActorBattleStatusFace < Sprite_Base

  #--------------------------------------------------------------------------

  # * Constants

  #--------------------------------------------------------------------------

  WHITEN    = 1                      # Flash white (start action)

  BLINK     = 2                      # Blink (damage)

  APPEAR    = 3                      # Appear (appear, revive)

  DISAPPEAR = 4                      # Disappear (escape)

  COLLAPSE  = 5                      # Collapse (incapacitated)

  def initialize(x, y, actor, viewport)

    x += 2

    y += 14

    #super(viewport)

    super(nil)

    self.x = x

    self.y = y

    self.z = 200

    @actor = actor

    @effect_duration = 0

    @effect_type = 0

    self.opacity =0

    self.bitmap = Bitmap.new(96,96)

    @battler_visible = false

    refresh

  end

  def refresh

    return if @actor.nil?

    self.bitmap.clear

    if @character_name != @actor.face_name or 

        @character_index != @actor.face_index

      @character_name = @actor.face_name

      @character_index = @actor.face_index

    end

    draw_face(@character_name, @character_index, 0,0)

    update

  end

  def update

    super

    return if @actor.nil?

    if @effect_type == COLLAPSE and @effect_duration < 1

      self.visible = false

      return if @actor.dead? and @actor.animation_id == 0

      self.visible = true

      @effect_type = APPEAR

      @effect_duration = 16

      @battler_visible = true

    end

    setup_new_effect

    update_effect

    update_shake

  end

  def slide(dx, dy)

    if self.x != dx

      self.x += ((dx - self.x) / 2)

    end

    if self.y+30 != dy

      self.y += ((dy - self.y+30) / 2)

    end

  end

  def draw_actor_state(actor, x, y, width = 96)

    count = 0

    for state in actor.states

      draw_icon(state.icon_index, x + 24 * count, y-10)

      count += 1

      break if (x + 24 * count > width - 24)

    end

  end

  def draw_icon(icon_index, x, y, enabled = true)

    bitmap = Cache.system("Iconset")

    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)

    self.bitmap.blt(x, y, bitmap, rect, enabled ? 255 : 128)

  end

  def draw_face(face_name, face_index, x, y, size = 96)

    bitmap = Cache.face(face_name)

    rect = Rect.new(0, 0, 0, 0)

    rect.x = face_index % 4 * 96 + (96 - size) / 2

    rect.y = face_index / 4 * 96 + (96 - size) / 2

    rect.width = size

    rect.height = size

    self.bitmap.blt(x, y, bitmap, rect)

    if @actor.dead?

      @effect_type = COLLAPSE

      @effect_duration = 0

      update_collapse

    end

    bitmap.dispose

  end 

  def start_shake(power, time)

    @shake_time = time*2

    @shake_power =power

  end

  def update_shake

    @shake_time = 0 if @shake_time.nil?

    return if @shake_time <= 0

    @shake_time -= 1

    if @shake_time%2 == 0 #even

      self.x += @shake_power

    else #odd

      self.x -= @shake_power

    end

  end

  def setup_new_effect

    if @actor.white_flash

      @effect_type = WHITEN

      @effect_duration = 16

      @actor.white_flash = false

    end

    if @actor.blink

      @effect_type = BLINK

      @effect_duration = 20

      @actor.blink = false

    end

    if not @battler_visible and @actor.exist?

      @effect_type = APPEAR

      @effect_duration = 16

      @battler_visible = true

    end

    if @battler_visible and @actor.hidden

      @effect_type = DISAPPEAR

      @effect_duration = 32

      @battler_visible = false

    end

    if @actor.collapse

      @effect_type = COLLAPSE

      @effect_duration = 48

      @actor.collapse = false

      @battler_visible = false

      @dead = true

    end

    if @actor.animation_id != 0

      animation = $data_animations[@actor.animation_id]

      mirror = @actor.animation_mirror

      start_animation(animation, mirror)

      @actor.animation_id = 0

    end

  end

  def update_effect

    if @effect_duration > 0

      @effect_duration -= 1

      case @effect_type

      when WHITEN

        update_whiten

      when BLINK

        update_blink

      when APPEAR

        update_appear

      when DISAPPEAR

        update_disappear

      when COLLAPSE

        update_collapse

      end

    end

  end

  def update_whiten

    self.blend_type = 0

    self.color.set(255, 255, 255, 128)

    self.opacity = 255

    self.color.alpha = 128 - (16 - @effect_duration) * 10

  end

  def update_blink

    self.blend_type = 0

    self.color.set(0, 0, 0, 0)

    self.opacity = 255

    self.visible = (@effect_duration % 10 < 5)

  end

  def update_appear

    self.blend_type = 0

    self.color.set(0, 0, 0, 0)

    self.opacity = (16 - @effect_duration) * 16

  end

  def update_disappear

    self.blend_type = 0

    self.color.set(0, 0, 0, 0)

    self.opacity = 256 - (32 - @effect_duration) * 10

  end

  def update_collapse

    self.blend_type = 1

    self.color.set(255, 128, 128, 128)

    self.opacity = 256 - (48 - @effect_duration) * 6

  end

end

#==============================================================================#

# Scene_Battle                                                                 #

#------------------------------------------------------------------------------#

class Scene_Battle < Scene_Base

  # Start process

  def start

    super

    $game_temp.in_battle = true

    @spriteset = Spriteset_Battle.new

    @message_window = Window_BattleMessage.new

    @message_window.opacity = 0

    @message_window.x = 640

    @action_battlers = []

    create_info_viewport

  end

  def post_start

    super

    process_battle_start

  end

  def terminate

    super

    dispose_info_viewport

    @message_window.dispose

    if @battleend == nil

    else

      @battleend.dispose

    end

    @spriteset.dispose

    unless $scene.is_a?(Scene_Gameover)

      $scene = nil if $BTEST

    end

  end

  def update_basic(main = false)

    Graphics.update unless main   

    Input.update unless main      

    $game_system.update     

    $game_troop.update           

    update_info_viewport

    @spriteset.update    

    @message_window.update   

  end

  def wait(duration, no_fast = false)

    for i in 0...duration

      update_basic

      break if not no_fast and i >= duration / 2 and show_fast?

    end

  end

  def wait_for_message

    @message_window.update

    while $game_message.visible

      update_basic

    end

  end

  def wait_for_animation

    while @spriteset.animation?

      update_basic

    end

    while actor_animation?

      update_basic

    end

  end

  def actor_animation?

    for face in @face_actor_windows

      return true if face.animation?

    end

    return false

  end

  def show_fast?

    return (Input.press?(Input::A) or Input.press?(Input::C))

  end

  # Update Method

  def update

    super

    update_basic(true)

    if $game_message.visible

      @info_viewport.visible = false

      @message_window.visible = true

    end

    unless $game_message.visible      

      return if judge_win_loss       

      update_scene_change

      if @target_enemy_window != nil

        update_target_enemy_selection    

      elsif @target_actor_window != nil

        update_target_actor_selection   

      elsif @skill_window != nil

        update_skill_selection     

      elsif @item_window != nil

        update_item_selection      

      elsif @party_command_window.active

        update_party_command_selection  

      elsif @actor_command_window.active

        update_actor_command_selection   

      else

        process_battle_event            

        process_action                 

        process_battle_event        

      end

    end

  end

  # Creating info Viewport

  def create_info_viewport

    @info_viewport = Viewport.new(0, 0, 640, 480)

    @info_viewport.z = 100

    @bhelp_window = Window_BattleHelp.new

    @bhelp_window.opacity = 0

    @bhelp_window.x = -640

    @bhelp_window.y = 0

    @strip_thingy = Sprite.new

    @strip_thingy.bitmap = Cache.system(BattleConfig::HelpStripImage)

    @strip_thingy.y = 18

    @strip_thingy.opacity = 160

    @status_window = Window_BattleStatus.new

    @status_window.y = 534

    @status_window.x = 640

    @actor_windows = []

    @actors_windows = []

    @face_actor_windows = []

    for i in 0...$game_party.members.size

      actor = $game_party.members[i]

      @actor_windows.push(Window_ActorBattleStatus.new(i*160, 376)) 

      @actors_windows.push(Window_ActorStatus.new((i*160)-24, 344, actor))

      @face_actor_windows.push(Window_ActorBattleStatusFace.new(i*160, 310, actor, @info_viewport))

    end

    @party_command_window = Window_PartyCommand.new

    @actor_command_window = Window_ActorCommand.new

    @status_window.viewport = @info_viewport

    @party_command_window.viewport = @info_viewport

    @party_command_window.x = 0

    @party_command_window.y = 424

    @actor_command_window.viewport = @info_viewport

    @actor_command_window.x = -640

    @actor_command_window.y = 424

    @status_window.x = 128

    @actor_command_window.x = 544

    @info_viewport.visible = false

  end

  def dispose_info_viewport

    @strip_thingy.dispose

    @status_window.dispose

    @bhelp_window.dispose

    @party_command_window.dispose

    @actor_command_window.dispose

    @info_viewport.dispose

    for window in @actor_windows

      window.dispose

    end

    for window in @actors_windows

      window.dispose

    end

    for window in @face_actor_windows

      window.dispose

    end

  end

  def update_info_viewport

    @party_command_window.update

    @actor_command_window.update

    @status_window.update

    for window in @actor_windows

      window.update

    end

    for window in @face_actor_windows

      window.update

    end

    if @party_command_window.active# and @info_viewport.ox < 128

      for i in 0..3

        unless @actor_windows[i].nil?

          @actor_windows[i].slide(@actor_windows[i].x, 360)

          @actors_windows[i].slide(@actors_windows[i].x, 328)

          @face_actor_windows[i].slide(@face_actor_windows[i].x, 296)

        end

      end

      @actor_command_window.slide(-640, 424)

      @party_command_window.slide(0, 424)

      #@status_window.slide(64, 416)

      @bhelp_window.slide(0, 0)

      #@total_damage_window.slide(544, 48)

    elsif @actor_command_window.active# and @info_viewport.ox < 128

      for i in 0..3

        unless @actor_windows[i].nil?

          if @actor_index == i

            @actor_windows[i].slide(@actor_windows[i].x, 340)

            @actors_windows[i].slide(@actors_windows[i].x, 308)

            @face_actor_windows[i].slide(@face_actor_windows[i].x, 276)

          else

            @actor_windows[i].slide(@actor_windows[i].x, 360)

            @actors_windows[i].slide(@actors_windows[i].x, 328)

            @face_actor_windows[i].slide(@face_actor_windows[i].x, 296)

          end

        end

      end

      @party_command_window.slide(640, 424)

      @actor_command_window.slide(0, 424)

      #@status_window.slide(64, 288)

      @bhelp_window.slide(0, 0)

      #@total_damage_window.slide(544, 48)

    elsif @target_actor_window != nil and @target_actor_window.active

      for i in 0..3

        unless @actor_windows[i].nil? #is same as == nil

          if @target_actor_window.index == i

            @actor_windows[i].slide(@actor_windows[i].x, 340)

            @actors_windows[i].slide(@actors_windows[i].x, 308)

            @face_actor_windows[i].slide(@face_actor_windows[i].x, 276)

          else

            @actor_windows[i].slide(@actor_windows[i].x, 360)

            @actors_windows[i].slide(@actors_windows[i].x, 328)

            @face_actor_windows[i].slide(@face_actor_windows[i].x, 296)

          end

        end

      end 

    else

      @bhelp_window.slide(0, 0)

      for i in 0..3

        unless @actor_windows[i] == nil

          @actor_windows[i].slide(@actor_windows[i].x, 360)

          @actors_windows[i].slide(@actors_windows[i].x, 328)

          @face_actor_windows[i].slide(@face_actor_windows[i].x, 296)

        end

      end

    end

  end

  def refresh_actor_status_windows

    for window in @actors_windows

      window.refresh

    end

    for window in @face_actor_windows

      window.refresh

    end

  end

  # Battle event Processing

  def process_battle_event

    loop do

      return if judge_win_loss

      return if $game_temp.next_scene != nil

      $game_troop.interpreter.update

      $game_troop.setup_battle_event

      @message_window.x = 95

      @message_window.y = 176

      wait_for_message

      @message_window.x = 640

      process_action if $game_troop.forcing_battler != nil

      return unless $game_troop.interpreter.running?

      update_basic

    end

  end

  def judge_win_loss

    if $game_temp.in_battle

      if $game_party.all_dead?

        process_defeat

        return true

      elsif $game_troop.all_dead?

        process_victory

        return true

      else

        return false

      end

    else

      return true

    end

  end

  def battle_end(result)

    if result == 2 and not $game_troop.can_lose

      call_gameover

    else

      $game_party.clear_actions

      $game_party.remove_states_battle

      $game_troop.clear

      if $game_temp.battle_proc != nil

        $game_temp.battle_proc.call(result)

        $game_temp.battle_proc = nil

      end

      #unless $BTEST

      #  $game_temp.map_bgm.play

      #  $game_temp.map_bgs.play

      #end

      $scene = Scene_Map.new

      @message_window.clear

      Graphics.fadeout(30)

    end

    $game_temp.in_battle = false

  end

  def next_actor

    loop do

      if @actor_index == $game_party.members.size-1

        start_main

        return

      end

      @status_window.index = @actor_index += 1

      @active_battler = $game_party.members[@actor_index]

      if @active_battler.auto_battle

        @active_battler.make_action

        next

      end

      break if @active_battler.inputable?

    end

    start_actor_command_selection

  end

  def prior_actor

    loop do

      if @actor_index == 0

        start_party_command_selection

        return

      end

      @status_window.index = @actor_index -= 1

      @active_battler = $game_party.members[@actor_index]

      next if @active_battler.auto_battle

      break if @active_battler.inputable?

    end

    start_actor_command_selection

  end

  # Party Command Selection

  def start_party_command_selection

    if $game_temp.in_battle  

      @status_window.refresh

      @status_window.index = @actor_index = -1

      refresh_actor_status_windows

      @active_battler = nil

      @info_viewport.visible = true

      @message_window.visible = false

      @party_command_window.active = true

      @party_command_window.index = 0

      @actor_command_window.active = false

      $game_party.clear_actions

      if $game_troop.surprise or not $game_party.inputable?

        start_main

      end

    end

  end

  def update_party_command_selection

    case @party_command_window.index

    when 0

      @bhelp_window.set_text(BattleConfig::FightMessage)

    when 1

      if $game_troop.can_escape == false

        @bhelp_window.set_text(BattleConfig::ForbidRunMessage)

      else

        @bhelp_window.set_text(BattleConfig::RunMessage)

      end

    end

    if Input.trigger?(Input::C)

      case @party_command_window.index

      when 0  # Fight

        Sound.play_decision

        @status_window.index = @actor_index = -1

        next_actor

      when 1  # Escape

        if $game_troop.can_escape == false

          Sound.play_buzzer

          return

        end

        Sound.play_decision

        process_escape

      end

    end

  end

  # Actor Command Selection

  def start_actor_command_selection

    @party_command_window.active = false

    @actor_command_window.setup(@active_battler)

    @actor_command_window.active = true

    @actor_command_window.index = 0

  end

  def update_actor_command_selection

    case @actor_command_window.index

    when 0

      @bhelp_window.set_text(BattleConfig::AttackText)

    when 1

      @bhelp_window.set_text(BattleConfig::SkillText)

    when 2

      @bhelp_window.set_text(BattleConfig::GuardText)

    when 3

      @bhelp_window.set_text(BattleConfig::ItemText)

    end

    if Input.trigger?(Input::B)

      Sound.play_cancel

      prior_actor

    elsif Input.trigger?(Input::C)

      case @actor_command_window.index

      when 0  # Attack

        Sound.play_decision

        @active_battler.action.set_attack

        start_target_enemy_selection

      when 1  # Skill

        Sound.play_decision

        start_skill_selection

      when 2  # Guard

        Sound.play_decision

        @active_battler.action.set_guard

        next_actor

      when 3  # Item

        Sound.play_decision

        start_item_selection

      end

    end

  end

  # Target Selection

  def start_target_enemy_selection

    @target_enemy_window = Window_TargetEnemy.new

    @target_enemy_window.y = 650#@info_viewport.rect.y + 429495

    #@info_viewport.rect.x += @target_enemy_window.width

    #@info_viewport.ox += @target_enemy_window.width

    @arrow = Sprite.new

    @arrow.visible = false

    @arrow.bitmap = Cache.system(BattleConfig::TargetImage)

    @actor_command_window.active = false

  end

  def end_target_enemy_selection

    #@info_viewport.rect.x -= @target_enemy_window.width

    #@info_viewport.ox -= @target_enemy_window.width

    @target_enemy_window.dispose

    @arrow.dispose

    @target_enemy_window = nil

    if @actor_command_window.index == 0

      @actor_command_window.active = true

    end

  end

  def update_target_enemy_selection

    @target_enemy_window.update

    unless @skill_window == nil

      @skill_window.slide(1240, @skill_window.y)

      @help_window.slide(384, @help_window.y)

      @help_window.set_text(@skill_window.skill.name)

    end

    unless @item_window == nil

      @item_window.slide(1240, @item_window.y)

    end

    @bhelp_window.set_text("Target: " + @target_enemy_window.enemy.name)

    @arrow.x = @target_enemy_window.enemy.screen_x

    @arrow.y = @target_enemy_window.enemy.screen_y

    @arrow.visible = true

    if Input.trigger?(Input::B)

      Sound.play_cancel

      end_target_enemy_selection

      if @skill_window

        @bhelp_window.set_text("Use a skill/ability")

      end

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      @active_battler.action.target_index = @target_enemy_window.enemy.index

      end_target_enemy_selection

      end_skill_selection

      end_item_selection

      next_actor

    end

  end

  def start_target_actor_selection

    @target_actor_window = Window_BattleStatus.new

    @target_actor_window.x = (640 - @target_actor_window.width) / 2

    @target_actor_window.y = (480 - @target_actor_window.height) / 2

    @target_actor_window.openness = 0

    @target_actor_window.index = 0

    @target_actor_window.active = true

    #@target_actor_window.y = 288#@info_viewport.rect.y

    #@info_viewport.rect.x += @target_actor_window.width

    #@info_viewport.ox += @target_actor_window.width

    @actor_command_window.active = false

  end

  def end_target_actor_selection

    #@info_viewport.rect.x -= @target_actor_window.width

    #@info_viewport.ox -= @target_actor_window.width

    @target_actor_window.dispose

    @target_actor_window = nil

  end

  def update_target_actor_selection

    @target_actor_window.update

    @target_actor_window.open

    @target_actor_window.visible = false

    @bhelp_window.set_text("Target: " + $game_party.members[@target_actor_window.index].name)

    if Input.trigger?(Input::DOWN) or Input.trigger?(Input::LEFT)

      index = (@target_actor_window.index + ($game_party.members.size - 1)) % $game_party.members.size

      @target_actor_window.index = index

    elsif Input.trigger?(Input::UP) or Input.trigger?(Input::RIGHT)

      index = (@target_actor_window.index + 1) % $game_party.members.size

      @target_actor_window.index = index

    elsif Input.trigger?(Input::B)

      Sound.play_cancel

      end_target_actor_selection

      if @skill_window

        @bhelp_window.set_text("Use a skill/ability")

      end

    elsif Input.trigger?(Input::C)

      Sound.play_decision

      @active_battler.action.target_index = @target_actor_window.index

      end_target_actor_selection

      end_skill_selection

      end_item_selection

      next_actor

    end

  end

  # Skill and Item Selection

  def start_skill_selection

    @help_window = Window_BattleHelp.new

    #@help_window.x = 0

    @help_window.opacity = 0

    @help_window.x = -1024

    @skill_window = Window_Skill.new(0, 56, 544, 232, @active_battler)

    @skill_window.x = 48

    @skill_window.y = -544

    @skill_window.help_window = @help_window

    @actor_command_window.active = false

  end

  def end_skill_selection

    #@skill_window.x = -544

    if @skill_window != nil

      @skill_window.dispose

      @skill_window = nil

      @help_window.dispose

      @help_window = nil

    end

    @actor_command_window.active = true

  end

  def update_skill_selection

    #@status_window.slide(64, 416)

    @bhelp_window.slide(0, 20)

    @help_window.slide(0, 0)

    @skill_window.slide(48, 64)

    @skill_window.active = true

    @skill_window.update

    @help_window.update

    if Input.trigger?(Input::B)

      Sound.play_cancel

      end_skill_selection

    elsif Input.trigger?(Input::C)

      @skill = @skill_window.skill

      if @skill != nil

        @active_battler.last_skill_id = @skill.id

      end

      if @active_battler.skill_can_use?(@skill)

        Sound.play_decision

        determine_skill

      else

        Sound.play_buzzer

      end

      @bhelp_window.set_text("")

    end

  end

  def determine_skill

    @active_battler.action.set_skill(@skill.id)

    @skill_window.active = false

    if @skill.need_selection?

      if @skill.for_opponent?

        start_target_enemy_selection

      else

        start_target_actor_selection

      end

    else

      end_skill_selection

      next_actor

    end

  end

  def start_item_selection

    @help_window = Window_BattleHelp.new

    #@help_window.x = 0

    @help_window.x = -1024

    @help_window.opacity = 0

    @item_window = Window_Item.new(0, 56, 544, 232)

    @item_window.x = 48

    @item_window.y = -544

    @item_window.help_window = @help_window

    @actor_command_window.active = false

  end

  def end_item_selection

    #@item_window.x = -544

    if @item_window != nil

      @item_window.dispose

      @item_window = nil

      @help_window.dispose

      @help_window = nil

    end

    @actor_command_window.active = true

  end

  def update_item_selection

    #@status_window.slide(64, 416)

    @bhelp_window.slide(0, 20)

    @help_window.slide(0, 0)

    @item_window.slide(48, 64)

    @item_window.active = true

    @item_window.update

    @help_window.update

    if Input.trigger?(Input::B)

      Sound.play_cancel

      end_item_selection

    elsif Input.trigger?(Input::C)

      @item = @item_window.item

      if @item != nil

        $game_party.last_item_id = @item.id

      end

      if $game_party.item_can_use?(@item)

        Sound.play_decision

        determine_item

      else

        Sound.play_buzzer

      end

    end

  end

  def determine_item

    @active_battler.action.set_item(@item.id)

    @item_window.active = false

    if @item.need_selection?

      if @item.for_opponent?

        start_target_enemy_selection

      else

        start_target_actor_selection

      end

    else

      end_item_selection

      next_actor

    end

  end

  def process_battle_start

    @message_window.clear

    make_escape_ratio

    process_battle_event

    start_party_command_selection

  end

  # Battle escape, victory, etc

  def make_escape_ratio

    actors_agi = $game_party.average_agi

    enemies_agi = $game_troop.average_agi

    @escape_ratio = 150 - 100 * enemies_agi / actors_agi

  end

  def process_escape

    @info_viewport.visible = false

    @message_window.visible = true

    text = sprintf(Vocab::EscapeStart, $game_party.name)

    $game_message.texts.push(text)

    @bhelp_window.set_text("Escaping...")

    if $game_troop.preemptive

      success = true

    else

      success = (rand(100) < @escape_ratio)

    end

    Sound.play_escape

    if success

      @bhelp_window.set_text("Escaped successfully")

      wait_for_message

      battle_end(1)

    else

      @escape_ratio += 10

      $game_message.texts.push('\.' + Vocab::EscapeFailure)

      @bhelp_window.set_text("Escape failed")

      wait_for_message

      $game_party.clear_actions

      start_main

    end

  end

  def process_victory

    @info_viewport.visible = false

    @message_window.visible = true

    @battleend = Sprite.new

    @battleend.bitmap = Cache.system(BattleConfig::EndImage)

    @battleend.opacity = 160

    @message_window.x = 0

    @message_window.y = 176

    $game_system.battle_end_me.play

    #unless $BTEST

    #  $game_temp.map_bgm.play

    #  $game_temp.map_bgs.play

    #end

    display_exp_and_gold

    display_drop_items

    display_level_up

    battle_end(0)

  end

  def display_exp_and_gold

    #@message_window.contents.hue = BattleConfig::GM_HUE

    exp = $game_troop.exp_total

    gold = $game_troop.gold_total

    $game_party.gain_gold(gold)

    #text = sprintf(Vocab::Victory, $game_party.name)

    #$game_message.texts.push('\|' + text)

    if exp > 0

      text = sprintf(Vocab::ObtainExp, exp)

      $game_message.texts.push('\.' + text)

    end

    if gold > 0

      text = sprintf(Vocab::ObtainGold, gold, Vocab::gold)

      $game_message.texts.push('\.' + text)

    end

    wait_for_message

    #@message_window.contents.hue = 0

  end

  def display_drop_items

    drop_items = $game_troop.make_drop_items

    for item in drop_items

      $game_party.gain_item(item, 1)

      text = sprintf(Vocab::ObtainItem, item.name)

      $game_message.texts.push(text)

    end

    wait_for_message

  end

  def display_level_up

    exp = $game_troop.exp_total

    for actor in $game_party.existing_members

      last_level = actor.level

      last_skills = actor.skills

      actor.gain_exp(exp, true)

    end

    wait_for_message

  end

  def process_defeat

    @info_viewport.visible = false

    @message_window.visible = true

    text = sprintf(Vocab::Defeat, $game_party.name)

    $game_message.texts.push(text)

    @bhelp_window.set_text("Defeated...")

    wait_for_message

    battle_end(2)

  end

  def update_scene_change

    case $game_temp.next_scene

    when "map"

      call_map

    when "gameover"

      call_gameover

    when "title"

      call_title

    else

      $game_temp.next_scene = nil

    end

  end

  def call_map

    $game_temp.next_scene = nil

    battle_end(1)

  end

  def call_gameover

    $game_temp.next_scene = nil

    $scene = Scene_Gameover.new

    @message_window.clear

  end

  def call_title

    $game_temp.next_scene = nil

    $scene = Scene_Title.new

    @message_window.clear

    Graphics.fadeout(60)

  end

  def start_main

    $game_troop.increase_turn

    @info_viewport.visible = false

    @info_viewport.ox = 0

    @message_window.visible = true

    @party_command_window.active = false

    @actor_command_window.active = false

    @status_window.index = @actor_index = -1

    @active_battler = nil

    @message_window.clear

    $game_troop.make_actions

    make_action_orders

    wait(10)

    10.times do 

      update_basic

      update_info_viewport

    end

  end

  def make_action_orders

    @action_battlers = []

    unless $game_troop.surprise

      @action_battlers += $game_party.members

    end

    unless $game_troop.preemptive

      @action_battlers += $game_troop.members

    end

    for battler in @action_battlers

      battler.action.make_speed

    end

    @action_battlers.sort! do |a,b|

      b.action.speed - a.action.speed

    end

  end

  def process_action

    return if judge_win_loss

    return if $game_temp.next_scene != nil

    set_next_active_battler

    if @active_battler == nil

      turn_end

      return

    elsif @active_battler.dead?

      return

    end

    @message_window.clear

    wait(5)

    @active_battler.white_flash = true

    unless @active_battler.action.forcing

      @active_battler.action.prepare

    end

    if @active_battler.is_a?(Game_Enemy)

      index = -1

    elsif @active_battler.is_a?(Game_Actor)

      index = $game_party.members.index(@active_battler)

    end

#    for i in 0..3

#      unless @actor_windows[index].nil?

#        if i == index

#          @actor_windows[i].slide(@actor_windows[i].x, 320)

#          @face_actor_windows[i].slide(@face_actor_windows[i].x, 272)

#        else

#          @actor_windows[i].slide(@actor_windows[i].x, 344)

#          @face_actor_windows[i].slide(@face_actor_windows[i].x, 308)

#        end

#      end

#    end

    15.times do

      for i in 0..3

        if !@actor_windows[i].nil?

          @actor_windows[i].update

          @face_actor_windows[i].update

        end

      end

      update_basic

    end

    if @active_battler.action.valid?

      execute_action

    end

    unless @active_battler.action.forcing

      @message_window.clear

      remove_states_auto

      display_current_state

    end

    @active_battler.white_flash = false

    @message_window.clear

  end

  def execute_action

    case @active_battler.action.kind

    when 0  

      case @active_battler.action.basic

      when 0  

        execute_action_attack

      when 1  

        execute_action_guard

      when 2  

        execute_action_escape

      when 3 

        execute_action_wait

      end

    when 1  

      execute_action_skill

    when 2  

      execute_action_item

    end

  end

  def turn_end

    $game_troop.turn_ending = true

    $game_party.slip_damage_effect

    $game_troop.slip_damage_effect

    $game_party.do_auto_recovery

    $game_troop.preemptive = false

    $game_troop.surprise = false

    process_battle_event

    $game_troop.turn_ending = false

    start_party_command_selection

  end

  def set_next_active_battler

    loop do

      if $game_troop.forcing_battler != nil

        @active_battler = $game_troop.forcing_battler

        @action_battlers.delete(@active_battler)

        $game_troop.forcing_battler = nil

      else

        @active_battler = @action_battlers.shift

      end

      return if @active_battler == nil

      return if @active_battler.index != nil

    end

  end

  def remove_states_auto

    last_st = @active_battler.states

    @active_battler.remove_states_auto

    if @active_battler.states != last_st

      wait(5)

      display_state_changes(@active_battler)

      wait(6)

      @message_window.clear

    end

  end

  def display_current_state

    state_text = @active_battler.most_important_state_text

    unless state_text.empty?

      wait(5)

      text = @active_battler.name + state_text

      #@message_window.add_instant_text(text)

      @bhelp_window.add_instant_text(text)

      wait(6)

      @message_window.clear

    end

  end

  # Action execution

  def execute_action_attack

    text = sprintf(Vocab::DoAttack, @active_battler.name)

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    targets = @active_battler.action.make_targets

    display_attack_animation(targets)

    wait(6)

    for target in targets

      target.attack_effect(@active_battler)

      display_action_effects(target)

    end

  end

  def execute_action_guard

    text = sprintf(Vocab::DoGuard, @active_battler.name)

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    wait(6)

  end

  def execute_action_escape

    text = sprintf(Vocab::DoEscape, @active_battler.name)

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    @active_battler.escape

    Sound.play_escape

    wait(6)

  end

  def execute_action_wait

    text = sprintf(Vocab::DoWait, @active_battler.name)

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    wait(6)

  end

  def execute_action_skill

    skill = @active_battler.action.skill

    text = @active_battler.name + skill.message1

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    unless skill.message2.empty?

      wait(3)

      @message_window.add_instant_text(skill.message2)

    end

    targets = @active_battler.action.make_targets

    display_user_animation(@active_battler, skill.animation_id_u)

    display_animation(targets, skill.animation_id)

    @active_battler.mp -= @active_battler.calc_mp_cost(skill)

    $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 execute_action_item

    item = @active_battler.action.item

    text = sprintf(Vocab::UseItem, @active_battler.name, item.name)

    #@message_window.add_instant_text(text)

    @bhelp_window.add_instant_text(text)

    targets = @active_battler.action.make_targets

    display_user_animation(@active_battler, item.animation_id_u)

    display_animation(targets, item.animation_id)

    $game_party.consume_item(item)

    $game_temp.common_event_id = item.common_event_id

    for target in targets

      target.item_effect(@active_battler, item)

      display_action_effects(target, item)

    end

  end

  # Animation

  def display_user_animation(targets, animation_id)

    return if animation_id == nil

    if animation_id > 0

      @active_battler.animation_id = animation_id

    end

    wait(6)

    wait_for_animation

  end

  def display_animation(targets, animation_id)

    if animation_id < 0

      display_attack_animation(targets)

    else

      display_normal_animation(targets, animation_id)

    end

    wait(6)

    wait_for_animation

  end

  def display_attack_animation(targets)

    if @active_battler.is_a?(Game_Enemy)  

      Sound.play_enemy_attack

      wait(6, true)

    end

    aid1 = @active_battler.atk_animation_id

    aid2 = @active_battler.atk_animation_id2

    display_normal_animation(targets, aid1, false)

    display_normal_animation(targets, aid2, true)

    wait_for_animation

  end

  def display_normal_animation(targets, animation_id, mirror = false)

    animation = $data_animations[animation_id]

    if animation != nil

      to_screen = (animation.position == 3)      

      for target in targets.uniq

        target.animation_id = animation_id

        target.animation_mirror = mirror

        wait(6, true) unless to_screen     

      end

      wait(6, true) if to_screen          

    end

  end

  # Stuff that are displayed on the help strip thing

  def display_action_effects(target, obj = nil)

    refresh_actor_status_windows

    unless target.skipped

      line_number = @message_window.line_number

      wait(1)

      display_critical(target, obj)

      display_damage(target, obj)

      display_state_changes(target, obj)

      if line_number == @message_window.line_number

        display_failure(target, obj) unless target.states_active?

      end

      if line_number != @message_window.line_number

        wait(6)

      end

      @message_window.back_to(line_number)

    end

  end

  def display_critical(target, obj = nil)

    if target.critical

      target.add_state(3)

      if target.actor?

        text = Vocab::CriticalToActor

      else

        text = Vocab::CriticalToEnemy

      end

      #@message_window.add_instant_text(text)

      @bhelp_window.set_text("Break!!")

      wait(6)

    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)

    end

  end

  def display_miss(target, obj = nil)

    if obj == nil or obj.physical_attack

      if target.actor?

        text = sprintf(Vocab::ActorNoHit, target.name)

      else

        text = sprintf(Vocab::EnemyNoHit, target.name)

      end

      Sound.play_miss

    else

      text = sprintf(Vocab::ActionFailure, target.name)

    end

    @message_window.add_instant_text(text)

    @bhelp_window.set_text(text)

    wait(6)

  end

  def display_evasion(target, obj = nil)

    if target.actor?

      text = sprintf(Vocab::ActorEvasion, target.name)

    else

      text = sprintf(Vocab::EnemyEvasion, target.name)

    end

    Sound.play_evasion

    @message_window.add_instant_text(text)

    @bhelp_window.set_text(text)

    wait(6)

  end

  def display_hp_damage(target, obj = nil)

    if target.hp_damage == 0       

      return if obj != nil and obj.damage_to_mp

      return if obj != nil and obj.base_damage == 0

      fmt = target.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage

      text = sprintf(fmt, target.name)

    elsif target.absorbed               

      fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain

      text = sprintf(fmt, target.name, Vocab::hp, target.hp_damage)

    elsif target.hp_damage > 0         

      if target.actor?

        text = sprintf(Vocab::ActorDamage, target.name, target.hp_damage)

        Sound.play_actor_damage

        #$game_troop.screen.start_shake(5, 5, 10)

        if target.is_a?(Game_Actor)

          if target == 0

            index = 0

          else

            index = $game_party.members.index(target)

          end

          #if !@actor_windows[index].nil?

            @actor_windows[index].start_shake(BattleConfig::ShakeRate,BattleConfig::ShakeDuration)

            @face_actor_windows[index].start_shake(BattleConfig::ShakeRate,BattleConfig::ShakeDuration)

          #end

        end

        15.times do 

          for i in 0..3

            if !@actor_windows[i].nil?

              update_basic

              @actor_windows[i].update

              @face_actor_windows[i].update

            end

          end

        end

      else

        text = sprintf(Vocab::EnemyDamage, target.name, target.hp_damage)

        Sound.play_enemy_damage

        target.blink = true

      end

    else                             

      fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery

      text = sprintf(fmt, target.name, Vocab::hp, -target.hp_damage)

      Sound.play_recovery

    end

    @message_window.add_instant_text(text)

    @bhelp_window.set_text(text)

    wait(6)

  end

  def display_mp_damage(target, obj = nil)

    return if target.dead?

    return if target.mp_damage == 0

    if target.absorbed                  

      fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain

      text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)

    elsif target.mp_damage > 0       

      fmt = target.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss

      text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)

    else                          

      fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery

      text = sprintf(fmt, target.name, Vocab::mp, -target.mp_damage)

      Sound.play_recovery

    end

    @message_window.add_instant_text(text)

    @bhelp_window.set_text(text)

    wait(6)

  end

  def display_state_changes(target, obj = nil)

    return if target.missed or target.evaded

    return unless target.states_active?

    if @message_window.line_number < 4

      @message_window.add_instant_text("")

    end

    display_added_states(target, obj)

    display_removed_states(target, obj)

    display_remained_states(target, obj)

    if @message_window.last_instant_text.empty?

      @message_window.back_one

    else

      wait(3)

    end

  end

  def display_added_states(target, obj = nil)

    for state in target.added_states

      if target.actor?

        next if state.message1.empty?

        text = target.name + state.message1

      else

        next if state.message2.empty?

        text = target.name + state.message2

      end

      if state.id == 1       

        target.perform_collapse

      end

      @message_window.replace_instant_text(text)

      wait(6)

    end

  end

  def display_removed_states(target, obj = nil)

    for state in target.removed_states

      next if state.message4.empty?

      text = target.name + state.message4

      @message_window.replace_instant_text(text)

      wait(6)

    end

  end

  def display_remained_states(target, obj = nil)

    for state in target.remained_states

      next if state.message3.empty?

      text = target.name + state.message3

      @message_window.replace_instant_text(text)

      wait(6)

    end

  end

  def display_failure(target, obj)

    text = sprintf(Vocab::ActionFailure, target.name)

    @message_window.add_instant_text(text)

    @bhelp_window.set_text(text)

    wait(6)

  end

end

  # Sprite Battler

class Sprite_Battler < Sprite_Base

  alias sbupd_fix_collapse_bug update

  def update

    if @battler == nil

      self.bitmap = nil

    else

      if @effect_type == COLLAPSE and @effect_duration < 1

        self.visible = false

        return if @battler.dead?

        self.visible = true

        @effect_type = APPEAR

        @effect_duration = 16

        @battler_visible = true

      end

    end

    sbupd_fix_collapse_bug

  end

end

  # Game Enemy

class Game_Enemy < Game_Battler

  attr_reader :atk_animation_id

  attr_reader :atk_animation_id2

  alias game_enemy_atk_animation initialize

  def initialize(index, enemy_id)

    game_enemy_atk_animation(index, enemy_id)

    parse_battler_name_for_atk_animation

  end

  def parse_battler_name_for_atk_animation

    @atk_animation_id = 0

    @atk_animation_id2 = 0

    @original_name.gsub!(/\\a\[([0-999]+)\]/i) { set_atk_anim($1.to_i) }

  end

  def set_atk_anim(id)

    @atk_animation_id = id

    return ""

  end

end

  # Scene Title and miscellaneous stuff

class Scene_Title < Scene_Base

  alias load_database_user_skill_anim load_database

  def load_database

    load_database_user_skill_anim

    init_user_skill_anims

  end

  def init_user_skill_anims

    for id in 1...$data_skills.size

      skill = $data_skills[id]

      skill.name.gsub!(/\\u\[([0-999]+)\]/i) { skill.set_user_anim($1.to_i) }

    end

    for id in 1...$data_items.size

      item = $data_items[id]

      item.name.gsub!(/\\u\[([0-999]+)\]/i) { item.set_user_anim($1.to_i) }

    end

  end

end

class RPG::UsableItem

  attr_reader :animation_id_u

  def set_user_anim(anim_id)

    @animation_id_u = anim_id

    return ""

  end

end

class Game_Actor < Game_Battler

  def screen_x

    return (48 + (self.index * 160))

  end

  def screen_y

    return 352

  end

end
Save-Point

Save-Point

decibel
