Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
- # 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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement