Chaos Project

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Easy Overdrive System by Blizzard
# Version: 2.0
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

module BlizzCFG
  
  MAX_RATE = false
  OVERDRIVE_RATE = 1000
  DRAW_OVERDRIVE = true
  DRAW_BAR = true
  OVERDRIVE_NAME = 'OD'
  OVERDRIVE_COMMAND_NAME = 'Overdrive'
  OVERDRIVE_COLOR = Color.new(0, 128, 255)
  OVERDRIVE_KIND = 11
  
end

#==============================================================================
# Game_Battler
#==============================================================================

class Game_Battler
  
  alias hp_is_equal_to_overdrive_later hp=
  def hp=(val)
    last_hp = self.hp
    hp_is_equal_to_overdrive_later(val)
    if self.is_a?(Game_Actor)
      if self.dead?
        self.overdrive = 0
      elsif self.hp < last_hp
        self.overdrive += (last_hp - self.hp) * BlizzCFG::OVERDRIVE_RATE /
            [last_hp, self.hp].min
      end
    end
  end
  
end

#==============================================================================
# Game_Actor
#==============================================================================

class Game_Actor
  
  attr_reader :overdrive
  attr_reader :overdrive_skills
  
  alias setup_overdrive_later setup
  def setup(actor_id)
    @overdrive = 0
    @overdrive_skills = []
    setup_overdrive_later(actor_id)
  end
  
  def overdrive=(val)
    @overdrive = val
    @overdrive = 0 if @overdrive < 0
    @overdrive = 1000 if @overdrive > 1000
  end
  
  def learn_overdrive(skill_id)
    if skill_id > 0 && !@overdrive_skills.include?(skill_id)
      @overdrive_skills.push(skill_id)
      @overdrive_skills.sort!
    end
  end
  
  def forget_overdrive(skill_id)
    @overdrive_skills.delete(skill_id)
  end
  
  def overdrive_can_use?(id)
    return (self.overdrive / 10 >= $data_skills[id].sp_cost)
  end
  
  def overdrive_text
    return "#{@overdrive/10}.#{@overdrive%10}%"
  end
  
end

#==============================================================================
# Window_Base
#==============================================================================

class Window_Base
  
  def draw_actor_overdrive(actor, x, y, w = 144)
    w = 120 if !$scene.is_a?(Scene_Menu)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y-16, width, 64, BlizzCFG::OVERDRIVE_NAME)
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, w, 32, actor.overdrive_text, 2)
  end
  
  def draw_actor_overdrive_with_bar(actor, x, y, w = 148)
    w -= 12
    rate = actor.overdrive.to_f / 1000
    color1 = Color.new(80, 0, 0, 192)
    color2 = Color.new(240, 0, 0, 192)
    color3 = Color.new(80, 0, 0, 192)
    self.contents.gradient_bar(x, y, w, color1, color2, color3, rate)
    if $scene.is_a?(Scene_Battle)
      draw_actor_overdrive(actor, x, y, w)
    else
      draw_actor_overdrive(actor, x, y)
    end
  end
  
end

#==============================================================================
# Window_BattleStatus
#==============================================================================

class Window_BattleStatus
  
  alias refresh_overdrive_later refresh
  def refresh(number = 0)
    if !BlizzCFG::DRAW_OVERDRIVE
      refresh_overdrive_later
      return
    end
    self.contents.clear
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    $game_party.actors.each_index {|i|
        if $tons_version != nil && $tons_version >= 4.82 &&
            $game_system.CENTER_BATTLER
          actor_x = case $game_party.actors.size
          when 1 then 4 + 240
          when 2 then 4 + 80 + i * 320
          when 3 then 4 + 80 + i * 160
          when 4 then 4 + i * 160
          end
        else
          actor_x = i * 160 + 4
        end
        draw_actor_name($game_party.actors[i], actor_x, -8)
        draw_actor_hp($game_party.actors[i], actor_x, 14, 120)
        draw_actor_sp($game_party.actors[i], actor_x, 44, 120)
        if BlizzCFG::DRAW_BAR && $tons_version != nil && $tons_version >= 4.82
          draw_actor_overdrive_with_bar($game_party.actors[i], actor_x, 74, 120)
        else
          draw_actor_overdrive($game_party.actors[i], actor_x, 74, 120)
        end
        if @level_up_flags[i]
          self.contents.font.color = normal_color
          self.contents.draw_text(actor_x, 100, 120, 32, 'LEVEL UP!')
        else
          draw_actor_state($game_party.actors[i], actor_x, 100)
        end}
  end
  
end

#==============================================================================
# Window_Command
#==============================================================================

class Window_Command
  
  attr_accessor :commands
  
  alias initialize_overdrive_later initialize
  def initialize(width, commands)
    initialize_overdrive_later(width, commands)
    @command2 = BlizzCFG::OVERDRIVE_COMMAND_NAME
  end
  
  def swap_commands
    @commands[1], @command2 = @command2, @commands[1]
    refresh
  end
  
  alias refresh_overdrive_later refresh
  def refresh
    refresh_overdrive_later
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    if self.index != 1 || @commands[1] != BlizzCFG::OVERDRIVE_COMMAND_NAME
      draw_item(1, normal_color)
      self.contents.draw_text(4, 31, width-40, 32, '››', 2)
    elsif @commands[1] == BlizzCFG::OVERDRIVE_COMMAND_NAME
      self.contents.font.color = BlizzCFG::OVERDRIVE_COLOR
      (0...6).each {|j|
          self.contents.fill_rect(0, 32, width-32, 32, Color.new(0, 0, 0, 0))
          rect = Rect.new(164-j * 32, 32, width-40, 32)
          self.contents.draw_text(rect, @commands[1])
          Graphics.update}
    end
  end
  
end

#==============================================================================
# Window_Overdrive
#==============================================================================

class Window_Overdrive < Window_Skill
  
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    @actor.overdrive_skills.each {|i| @data.push($data_skills[i]) if $data_skills[i] != nil}
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      if $fontface != nil
        self.contents.font.name = $fontface
        self.contents.font.size = $fontsize
      elsif $defaultfonttype != nil
        self.contents.font.name = $defaultfonttype
        self.contents.font.size = $defaultfontsize
      end
      (0...@item_max).each {|i| draw_item(i)}
    end
  end
  
  def draw_item(i)
    skill = @data[i]
    if @actor.overdrive_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + i % 2 * (288 + 32)
    y = i / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    self.contents.draw_text(x + 232, y, 48, 32, "#{skill.sp_cost}%", 2)
  end
  
end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle
  
  alias main_overdrive_later main
  def main
    main_overdrive_later
    @overdrive_window.dispose if @overdrive_window != nil
  end
  
  alias update_phase3_overdrive_later update_phase3
  def update_phase3
    if @overdrive_window != nil && @overdrive_window.visible
      @overdrive_window.update unless defined?(SDK)
      update_phase3_overdrive_select
    else
      update_phase3_overdrive_later
    end
  end
  
  alias update_phase3_enemy_select_overdrive_later update_phase3_enemy_select
  def update_phase3_enemy_select
    end_overdrive_select_plus if Input.trigger?(Input::B)
    update_phase3_enemy_select_overdrive_later
  end
  
  alias update_phase3_actor_select_overdrive_later update_phase3_actor_select
  def update_phase3_actor_select
    end_overdrive_select_plus if Input.trigger?(Input::B)
    update_phase3_actor_select_overdrive_later
  end
  
  alias phase3_next_actor_overdrive_later phase3_next_actor
  def phase3_next_actor
    end_overdrive_select if @overdrive_window != nil
    phase3_next_actor_overdrive_later
  end
  
  def update_phase3_overdrive_select
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      end_overdrive_select if @overdrive_window.visible
    elsif Input.trigger?(Input::C) 
      @skill = @overdrive_window.skill
      if @skill == nil || !@active_battler.overdrive_can_use?(@skill.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      @active_battler.current_action.skill_id = @skill.id
      @overdrive_window.visible = false
      if @skill.scope == 1
        start_enemy_select
      elsif [3, 5].include?(@skill.scope)
        start_actor_select
      else
        phase3_next_actor
      end
    end
  end
  
  def start_overdrive_select
    @overdrive_window = Window_Overdrive.new(@active_battler)
    @overdrive_window.help_window = @help_window
    @actor_command_window.active = @actor_command_window.visible = false
  end
  
  def end_overdrive_select
    end_overdrive_select_plus
    @actor_command_window.swap_commands
    @overdrive_window.dispose
    @overdrive_window, @help_window.visible = nil, false
  end
  
  def end_overdrive_select_plus
    if @overdrive_window != nil
      if @overdrive_window.visible
        @actor_command_window.active = @actor_command_window.visible = true
        @help_window.visible = false
      else
        @overdrive_window.active = @overdrive_window.visible = true
      end
    end
  end
  
  def make_overdrive_action_result(battler)
    @skill = $data_skills[battler.current_action.skill_id]
    unless battler.current_action.forcing || battler.overdrive_can_use?(@skill.id)
      $game_temp.forcing_battler = nil
      @phase4_step = 1
      return
    end
    if $tons_version != nil && $tons_version >= 5.0
      battler.overdrive -= @skill.sp_cost * 10 if @repeat[0] <= 1
    else
      battler.overdrive -= @skill.sp_cost * 10
    end
    @status_window.refresh
    @help_window.set_text(@skill.name, 1)
    @animation1_id, @animation2_id = @skill.animation1_id, @skill.animation2_id
    @common_event_id = @skill.common_event_id
    set_target_battlers(@skill.scope)
    @target_battlers.each {|target| target.skill_effect(battler, @skill)}
  end
  
  alias update_phase4_step2_overdrive_later update_phase4_step2
  def update_phase4_step2
    update_phase4_step2_overdrive_later
    if @active_battler.current_action.kind == BlizzCFG::OVERDRIVE_KIND
      make_overdrive_action_result(@active_battler)
    end
  end
  
  alias update_phase3_basic_command_overdrive_later update_phase3_basic_command
  def update_phase3_basic_command
    restore_commands(@active_battler)
    return if update_overdrive_input(@active_battler)
    if !Input.press?(Input::LEFT) && !Input.press?(Input::RIGHT)
      update_phase3_basic_command_overdrive_later
    end
  end
  
  def restore_commands(battler)
    if @actor_command_window.index != 1 &&
        @actor_command_window.commands[1] == BlizzCFG::OVERDRIVE_COMMAND_NAME
      @actor_command_window.swap_commands
    end
  end
  
  def update_overdrive_input(battler)
    if @actor_command_window.index == 1 && Input.press?(Input::RIGHT)
      if @actor_command_window.commands[1] != BlizzCFG::OVERDRIVE_COMMAND_NAME
        $game_system.se_play($data_system.decision_se)
        @actor_command_window.swap_commands
      end
      if !Input.press?(Input::UP) && !Input.press?(Input::DOWN)
        @actor_command_window.update
      end
    elsif @actor_command_window.commands[1] == BlizzCFG::OVERDRIVE_COMMAND_NAME
      $game_system.se_play($data_system.cancel_se)
      @actor_command_window.swap_commands
    end
    if @actor_command_window.commands[1] == BlizzCFG::OVERDRIVE_COMMAND_NAME &&
        Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      battler.current_action.kind = BlizzCFG::OVERDRIVE_KIND
      start_overdrive_select
      return true
    end
    return false
  end
  
end