[RMXP] Battle Arena 1.0

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Battle Arena
# Author: ForeverZer0
# Date: 4.28.2010
# Version: 1.0
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#
# Explanation:
#
#   Relatively simple idea. Let's the player bet an item, weapon, or armor and
#   then fight against an enemy to receive a different item in return. Very
#   much like the system used in Final Fantasy VI for the SNES. If they win,
#   they get to keep their own item and get the enemy's item, if they lose, they
#   will lose the item they bet.
#
# Feature:
#
#   - Can easily configure to most battle systems
#   - Fully configurable results for any item, weapon, or armor
#   - Allows for 'one-time' rewards for specific bets
#   - Simple to install. After configuration, uses only two script
#     calls in game
#   - All wins/losses are logged in variables for easy access
#
# Instructions:
#
#   - Place script below default scripts and above main
#   - Instructions for each configuration are below
#   - Use these script calls:
#
#  --> $scene = Scene_BattleArena.new
#
#      - calls the 'registration' scene
#
#  --> $game_temp.arena_battle_call(MAP_ID, X, Y)
#
#      - after registering, use this where the actual battle will occur
#      - the values in ( ) will be where the player is transfered to after
#        battle. If you do not want them to move, just don't include the ( )
#
#  --> $game_temp.arena_battle = false
#
#      - place this at every exit to your 'arena', otherwise it will cause
#        errors if the player leaves after registering, but before fighting
#
# Author's Notes:
#
#   - Make sure the player cannot save in between registering and fighting.
#     Anytime before or after is fine, but if they register then save and quit,
#     once the game is loaded the 'registraion' will have been lost.
#   - This system only uses one aliased method of the actual battle system. It
#     is basically just a redirect to the Arena Result screen if the flag was
#     present, so you can easily use any battle system you wish.
#   - The only problem you may have is if your battle system is not triggered
#     by the "$game_temp.battle_calling" flag, which most non-ABSs use.
#   - If your game freezes with the "$game_temp.arena_battle = false" script
#     call, it is not a problem with this script. You need to fix your
#     Interpreter command_355. Just look around where you found this script for
#     a fix for it, which you will likely want even if you don't use this system.
#
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

module Zer0_CFG
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                         BEGIN CONFIGURATION
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

  WIN_VARIABLE = 1
  LOSS_VARIABLE = 2

  # These are the IDs of the variables that the will keep track of your wins
  # and losses.

  NO_BET_ITEMS = []
  NO_BET_WEAPONS = []
  NO_BET_ARMORS = []

  # Include IDs of any items/weapon/armors that the player cannot bet.
  # Any item that is "NO_BET" will not even show up as a choice in the window.

  ONLY_ONCE_ITEMS = []
  ONLY_ONCE_WEAPONS = []
  ONLY_ONCE_ARMORS = []

  # Include IDs of items/weapons/armors that the player will receive the reward
  # for only once. After that, if they re-bet the same item again it will only
  # return the DEFAULT_REWARD as the prize.

#-------------------------------------------------------------------------------
#                         BEGIN BATTLE ARENA DATABASE
#-------------------------------------------------------------------------------
#
#   There are 3 sections that will need configured; one each for Items, Weapons,
#   and Armors. Set each section up like this:
#
#         when ID then return [TROOP, REWARD_TYPE, REWARD_ID]
#
#   ID       - The database ID of the Item, Weapon, or Armor that is being bet.
#   TROOP    - The database ID of the troop that will be fought.
#
#   REWARD_TYPE - The 'type' of the reward that will be given if victorious
#                 0 = Item
#                 1 = Weapon
#                 2 = Armor
#   REWARD_ID   - The ID in the database of the item (depending on type) that
#                 will be received.
#
#   Here's an example:
#
#     when 5 then return [4, 2, 34]  (let's pretend it is in the Item Database)
#
#     This would mean that if the player chose to wager Item with ID(5), they
#     would have to fight Troop with ID(4), and if they won would receive
#     Armor with ID(34). It is an armor because the TYPE is 2.
#
#-------------------------------------------------------------------------------

  DEFAULT_REWARD = [1, 0, 1]
  # This will be the configuration for any item/weapon/armor not defined.

  def self.wagers(item)
    if item.is_a?(RPG::Item)
      return DEFAULT_REWARD if $game_system.arena_one_time[0].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * Begin Item Wager Database
#-------------------------------------------------------------------------------

      when 1 then return [1, 0, 2]
      when 2 then return [3, 0, 3]
      when 3 then return [5, 0, 4]
      when 4 then return [8, 1, 1]
      when 5 then return [9, 2, 1]

#-------------------------------------------------------------------------------
# * End Item Wager Database
#-------------------------------------------------------------------------------
      end
    elsif item.is_a?(RPG::Weapon)
      return DEFAULT_REWARD if $game_system.arena_one_time[1].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * Begin Weapon Wager Database
#-------------------------------------------------------------------------------

      when 1 then return [1, 2, 1]
      when 2 then return [12, 1, 3]
      when 3 then return [20, 1, 5]
      when 4 then return [15, 2, 4]
      when 5 then return [25, 0, 10]

#-------------------------------------------------------------------------------
# * End Weapon Wager Database
#-------------------------------------------------------------------------------
      end
    elsif item.is_a?(RPG::Armor)
      return DEFAULT_REWARD if $game_system.arena_one_time[2].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * Begin Armor Wager Database
#-------------------------------------------------------------------------------

      when 1 then return [1, 1, 1]
      when 2 then return [5, 2, 3]
      when 3 then return [13, 2, 5]
      when 4 then return [10, 1, 5]
      when 5 then return [21, 2, 10]

#-------------------------------------------------------------------------------
# * End Armor Wager Database
#-------------------------------------------------------------------------------

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                           END CONFIGURATION
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
      end
    end
    return DEFAULT_REWARD
  end
end

#-------------------------------------------------------------------------------
# ** Game_System
#-------------------------------------------------------------------------------

class Game_System

  attr_accessor :arena_one_time   # Retains data on all the ONCE_ONLY bets

  alias zer0_arena_once_only_init initialize
  def initialize
    zer0_arena_once_only_init
    @arena_one_time = [[],[],[]]
  end
end

#-------------------------------------------------------------------------------
# ** Game_Temp
#-------------------------------------------------------------------------------

class Game_Temp

  attr_accessor :arena_data      # Holds info for bet, reward, battler, etc
  attr_accessor :arena_battle    # Arena Battle flag
  attr_accessor :party_memory    # Memorizes party pre-battle to return after

  alias zer0_battle_arena_temp_init initialize
  def initialize
    zer0_battle_arena_temp_init
    @arena_data = []
    @party_memory = []
    @arena_battle = false
  end

  def arena_battle_call(map_id=$game_map.map_id, x=$game_player.x , y=$game_player.y)
    @party_memory.clear
    $game_party.actors.each {|actor| @party_memory.push(actor.id)}
    $game_party.actors.clear
    $game_party.add_actor(@arena_data[2])
    @battle_calling = true
    @battle_can_escape = false
    @battle_can_lose = true
    @battle_proc = nil
    @player_new_map_id = map_id
    @player_new_x = x
    @player_new_y = y
    @player_new_direction = 2
    Graphics.freeze
    @player_transferring = true
  end
end

#-------------------------------------------------------------------------------
# ** Scene_BattleArena
#-------------------------------------------------------------------------------

class Scene_BattleArena

  def main
    @help_window = Window_Help.new
    @item_window = Window_ItemBet.new
    @item_window.help_window = @help_window
    @status_window = Window_ArenaStatus.new
    @header1 = Window_Base.new(320, 64, 320, 64)
    @header1.contents = Bitmap.new(288, 32)
    @header1.contents.draw_text(0, 0, 288, 32, 'Which item will you wager?', 1)
    @header2 = Window_Base.new(176, 128, 288, 64)
    @header2.contents = Bitmap.new(256, 32)
    @header2.contents.draw_text(0, 0, 256, 32, 'Who will battle?', 1)
    @header2.z = 5000
    @actor_window = Window_BattlerSelect.new
    @actor_window.active = @actor_window.visible = @header2.visible = false
    Graphics.transition
    loop {Graphics.update; Input.update; update; break if $scene != self}
    [@help_window, @item_window, @status_window, @header1, @header2,
     @actor_window].each {|window| window.dispose}
  end

  def update
    [@help_window, @status_window, @item_window,
      @actor_window].each {|window| window.update}
    if @item_window.active
       @status_window.data = @item_window.item
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        $scene = Scene_Map.new
      elsif Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        @data = Zer0_CFG.wagers(@item_window.item)
        @actor_window.active = @actor_window.visible = @header2.visible = true
        @item_window.active = false
        return
      end
    elsif @actor_window.active
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        @actor_window.active = @actor_window.visible = @header2.visible = false
        @item_window.active = true
        return
      elsif Input.trigger?(Input::C)
        if $game_party.actors[@actor_window.index].dead?
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        if $data_troops[@data[0]] != nil
          $game_temp.battle_troop_id = @data[0]
          $game_temp.arena_data[2] = $game_party.actors[@actor_window.index].id
          $game_temp.arena_data[0] = @item_window.item
          $game_temp.arena_data[1] = case @data[1]
          when 0 then $data_items[@data[2]]
          when 1 then $data_weapons[@data[2]]
          when 2 then $data_armors[@data[2]]
          end
          $game_temp.arena_battle = true
          $scene = Scene_Map.new
        end
      end
    end
  end
end

#-------------------------------------------------------------------------------
# ** Scene_ArenaResult
#-------------------------------------------------------------------------------

class Scene_ArenaResult

  def initialize(battle_result)
    @result = battle_result
  end

  def main
    @map = Spriteset_Map.new
    $game_party.actors[0].hp = 1 if @result != 0
    $game_party.actors.clear
    $game_temp.party_memory.each_index {|i|
      $game_party.add_actor($game_temp.party_memory[i])}
    @message_window = Window_Message.new
    Graphics.transition
    bet_item = $game_temp.arena_data[0]
    case bet_item
    when RPG::Item
      if Zer0_CFG::ONLY_ONCE_ITEMS.include?(bet_item.id)
        unless $game_system.arena_one_time[0].include?(bet_item.id)
          $game_system.arena_one_time[0].push(bet_item.id)
        end
      end
    when RPG::Weapon
      if Zer0_CFG::ONLY_ONCE_WEAPONS.include?(bet_item.id)
        unless $game_system.arena_one_time[1].include?(bet_item.id)
          $game_system.arena_one_time[1].push(bet_item.id)
        end
      end
    when RPG::Armor
      if Zer0_CFG::ONLY_ONCE_ARMORS.include?(bet_item.id)
        unless $game_system.arena_one_time[2].include?(bet_item.id)
        $game_system.arena_one_time[2].push(bet_item.id)
        end
      end
    end
    if @result == 0
      Audio.se_play('Audio/SE/060-Cheer01', 80, 100)
      $game_variables[Zer0_CFG::WIN_VARIABLE] += 1
      reward = $game_temp.arena_data[1].name
      id = $game_temp.arena_data[1].id
      case $game_temp.arena_data[1]
      when RPG::Item then $game_party.gain_item(id, 1)
      when RPG::Weapon then $game_party.gain_weapon(id, 1)
      when RPG::Armor then $game_party.gain_armor(id, 1)
      end
      text = "Congratulations!\n" + 'You have won a ' + reward + '!'
    else
      $game_variables[Zer0_CFG::LOSS_VARIABLE] += 1
      id = $game_temp.arena_data[0].id
      case $game_temp.arena_data[0]
      when RPG::Item then $game_party.lose_item(id, 1)
      when RPG::Weapon then $game_party.lose_weapon(id, 1)
      when RPG::Armor then $game_party.lose_armor(id, 1)
      end
      text = 'Lost...'
    end
    $game_temp.message_text = text
    loop {Graphics.update; Input.update; update; break if $scene != self}
    $game_temp.arena_battle = false
    $game_temp.arena_data.clear
    $scene = Scene_Map.new
    [@map, @message_window].each {|sprite| sprite.dispose}
  end

  def update
    [@map, @message_window].each {|sprite| sprite.update}
    if Input.trigger?(Input::C)
      $scene = Scene_Map.new
    end
  end
end

#-------------------------------------------------------------------------------
# ** Scene_Battle
#-------------------------------------------------------------------------------

class Scene_Battle

  alias zer0_battle_arena_result battle_end
  def battle_end(result)
    # This will just redirect the scene to the Arena Result screen instead
    # of Scene_Map if the arena flag is present
    zer0_battle_arena_result(result)
    if $game_temp.arena_battle
      $scene = Scene_ArenaResult.new(result)
    end
  end
end

#-------------------------------------------------------------------------------
# ** Window_ArenaStatus
#-------------------------------------------------------------------------------

class Window_ArenaStatus < Window_Base

  def initialize
    super(320, 128, 320, 352)
    self.contents = Bitmap.new(width - 32, height - 32)
    @data = nil
    refresh
  end

  def refresh
    self.contents.clear
    return if @data == nil
    @data = Zer0_CFG.wagers(@data)
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 288, 32, 'Enemies:')
    self.contents.draw_text(4, 256, 288, 32, 'Reward:')
    self.contents.font.color = normal_color
    member = $data_troops[@data[0]].members
    names = []
    member.each_index {|i| names[i] = $data_enemies[member[i].enemy_id].name
      y = (i * 32) + 32
      self.contents.draw_text(4, y, 288, 32, names[i]) if y < 256}
    case @data[1]
    when 0
      reward = $data_items[@data[2]].name
      icon = $data_items[@data[2]].icon_name
    when 1
      reward = $data_weapons[@data[2]].name
      icon = $data_weapons[@data[2]].icon_name
    when 2
      reward = $data_armors[@data[2]].name
      icon = $data_armors[@data[2]].icon_name
    end
    self.contents.draw_text(32, 288, 288, 32, reward)
    rect = Rect.new(x, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.blt(4, 292, RPG::Cache.icon(icon), Rect.new(0, 0, 24, 24))
  end

  def data=(data)
    if @data != data
      @data = data
      refresh
    end
  end
end

#-------------------------------------------------------------------------------
# ** Window_ItemBet
#-------------------------------------------------------------------------------

class Window_ItemBet < Window_Selectable

  def initialize
    super(0, 64, 320, 416)
    @column_max, self.index = 1, 0
    refresh
  end

  def item
    return @data[self.index]
  end

  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    (1...$data_items.size).each {|i|
      if $game_party.item_number(i) > 0
        unless Zer0_CFG::NO_BET_ITEMS.include?(i)
          @data.push($data_items[i])
        end
      end
    }
    (1...$data_weapons.size).each {|i|
      if $game_party.weapon_number(i) > 0
        unless Zer0_CFG::NO_BET_WEAPONS.include?(i)
          @data.push($data_weapons[i])
        end
      end
    }
    (1...$data_armors.size).each {|i|
      if $game_party.armor_number(i) > 0
        unless Zer0_CFG::NO_BET_ARMORS.include?(i)
          @data.push($data_armors[i])
        end
      end
    }
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      (0...@item_max).each {|i| draw_item(i)}
    end
  end

  def draw_item(index)
    item = @data[index]
    number = case item
    when RPG::Item then $game_party.item_number(item.id)
    when RPG::Weapon then $game_party.weapon_number(item.id)
    when RPG::Armor then $game_party.armor_number(item.id)
    end
    x = 4
    y = index * 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(item.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, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ':', 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end

  def update_help
    @help_window.set_text(self.item == nil ? '' : self.item.description)
  end
end

#-------------------------------------------------------------------------------
# ** Window_BattlerSelect
#-------------------------------------------------------------------------------

class Window_BattlerSelect < Window_Selectable

  def initialize
    w = ($game_party.actors.size * 64) + 32
    x = (640 - w) / 2
    super(x, 192, w, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    @row_max, self.index, self.z = 1, 0, 5000
    @item_max = @column_max = $game_party.actors.size
    refresh
  end

  def refresh
    $game_party.actors.each_index {|i|
    x = 32 + i * 64
    self.draw_actor_graphic($game_party.actors[i], x, 64)}
  end

  def update_cursor_rect
    cursor_width = 48
    x = @index * 64 + 8
    y = @index / @column_max * 32 - self.oy
    self.cursor_rect.set(x, y, cursor_width, 64)
  end
end