Easy Party Switcher 2.0b, Por Blizzard [RMXP]

18 de setembro de 2012
Easy Party Switcher 2.0b, Por Blizzard [RMXP]

Easy Party Switcher é um script para o RPG Maker XP, desenvolvido por Blizzard. Basicamente, ele permite a troca de heróis, no grupo, usando os próprios menus padrão deste maker.

Este “Party Switcher” é muito mais do que um script que muda o grupo comum, o autor destaca as seguintes funcionalidades:

  • define membros do grupo como “not _available” (“não disponíveis”, mostrados transparentes na reserva)
  • remove membros do grupo da lista de reserva (“disabled_for_party”)
  • define membros do grupo, que TEM que estar no grupo (mostrados com transparência no grupo atual, “must_be_in_party”)
  • define posições obrigatórias para membros do grupo
  • define tamanho do grupo obrigatório
  • opção para não limpar o grupo (para uso de multi-grupo) ou apenas remover todo membro (exceto 1) do grupo
  • fácil de trocar e usar membros do grupo
  • também suporta pequenos grupos (2 ou 3 membros) ou grandes grupos (5 ou mais)
  • usa facesets, opcionalmente

Código

Copie e cole o código abaixo, acima do “Main”:

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Easy Party Switcher by Blizzard
# Version 2.0b
# Date: 21.05.2006
# Date v1.1: 25.05.2006
# Date v1.2b: 27.05.2006
# Date v1.5b: 3.11.2006
# Date v1.51b: 29.11.2006
# Date v1.52b: 6.12.2006
# Date v1.7b: 23.2.2007
# Date v1.8b: 30.4.2007
# Date v2.0b: 7.8.2007
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Special Thanks to:
# Zeriab for pointing out a few glitches and shortening the code. =D
# 
# 
# IMPORTANT NOTE:
# 
# Be sure to set the MAX_PARTY to the maximum size of your party.
# There is already a preconfiguration of 4.
# 
# 
# Compatibility:
# 
# 98% compatible with SDK v1.x. 90% compatible with SDK 2.x. Can cause
# incompatibility issued with other Party Change Systems. WILL corrupt your old
# savegames. 
# 
# 
# Features:
# 
# - set party members for "not _available" (shown transparent in the reserve)
# - remove party members from the reserve list ("disabled_for_party")
# - set party members, who MUST be in the party (shown transparent in the
#   current party, "must_be_in_party")
# - set up forced positions for party members
# - set up forced party size
# - option either to wipe the party (for multi-party use) or only remove every
#   member (except 1) from the party.
# - easy to use and easy to switch party members
# - also supports small parties (2 or 3 members) and large parties (5 or more)
# - uses facesets optionally
# 
# v1.5b:
# - better, shorter and more efficient code (less memory use, less CPU use)
# - fixed potential bugs
# 
# v1.7b:
# - improved coding
# - facesets now optional
# - no extra bitmap files needed anymore
# - works now with Tons of Add-ons
# 
# v1.8b:
# - added "forced position"
# - added "forced party size"
# 
# v2.0b:
# - fixed the bug where you could empty the party... again...
# - fixed the bug that appeared when you pressed SHIFT
# - added option to allow an empty party
# - added "EXP for party members in reserve" option
# - made the forced_size for party work more convenient
# - improved coding
# - slightly decreased lag
# 
# 
# How to use:
# 
# To call this script, make a "Call script" command in an event.
# 
# 1. Syntax: $scene = Scene_PartySwitcher.new
#    No extra feature will be applied and you can switch the party as you wish.
# 
# 2. Syntax: $scene = Scene_PartySwitcher.new(XXX)
#    You can replace XXX for 1 to remove all party members except one (either
#    one, who must be in the party or a random one), or replace XXX with 2, to
#    cause a wipe party. Wiping a party will disable the of the current members
#    and a NEW party of the remaining members must be formed. If you replace it
#    with 3, the current party configuration will be stored for a later fast
#    switch-back.
# 
# 3. Syntax: $scene = Scene_PartySwitcher.new(XXX, 1)
#    You can use the XXX as described above or just set it to 0 to disable it.
#    Also the "1" in the syntax will reset any disabled_for_party and is made
#    to be used after multi-party use.
# 
# 4. Syntax: $scene = Scene_PartySwitcher.new(XXX, YYY, ZZZ)
#    You can replace ZZZ with 1 to replace the party with a stored one AND
#    store the current or replace it with 2 to replace the party with a stored
#    one, but without storing the current. USE THIS ONLY IF YOU ASSUME TO HAVE
#    A STORED PARTY READY! You can simply test if there is a store party by
#    putting this code into the conditional branch script:
# 
# $game_system.stored_party != nil
# 
# This syntax will not open the Party Switcher and it will override the
# commands XXX and YYY, so you can replace these with any number.
# 
# - Character faces go into the "Characters" folder and they have the same name
# as the character spritesets have with _face added
# 
# Example:
# 
# sprite - Marlen.png
# face   - Marlen_face.png
# 
# Other syntaxes:
# $game_actors[ID].not_available = true/false
# $game_actors[ID].disabled_for_party = true/false
# $game_actors[ID].must_be_in_party = true/false
# $game_actors[ID].forced_position = nil/0/1/2/...
# OR
# $game_party.actors[POS].not_available = true/false
# $game_party.actors[POS].disabled_for_party = true/false
# $game_party.actors[POS].must_be_in_party = true/false
# $game_party.actors[POS].forced_position = nil/0/1/2/...
# 
# ID - the actor's ID in the database
# POS - the actor's position in the party (STARTS FROM 0, not 1!)
# 
# not_available
# - will disable the possibility of an already unlocked character to be in the
#   current party
# 
# disabled_for_party
# - will cause the character NOT to appear in the party switch screen at all
# 
# must_be_in_party
# - will cause the character to be automatically moved into the current party
#   and he also cannot be put in the reserve
# 
# forced_position
# - will enforce the player to be at a specific position in the party, set this
#   value to nil to disable this feature, use it in combination with
#   must_be_in_party and $game_party.forced_size or you might experience bugs,
#   set to nil to disable
# 
# $game_party.forced_size = nil/0/1/2/...
# 
# Using this syntax will enforce a specific party size. The EPS won't exit
# until this size is filled up or there are no more in the reserve. EPS will
# automatically "correct" this number if there are not enough characters in the
# reserve to fill up a party of forced_size. Set this value to nil to disable
# the size requirement. Note that the actor DO NOT HAVE TO be set in normal
# order without any empty position like in version 1.x.
# 
# 
# Additional note:
# 
# For your own sake, do not apply the attribute "must_be_in_party" to a
# character at the same time with "not_available" or "disabled_for_party" as
# this WILL disrupt your party and party switch system. Use "forced_position"
# together with "must_be_in_party" to avoid bugs. Be careful when using
# "forced_position" with "$game_party.forced_size". Add actors at the very end
# to be sure the player can't put others after them if the "forced_size" is
# smaller than the maximum party size.
# 
# 
# If you find any bugs, please report them here:
# http://www.chaosproject.co.nr
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

# how many party members do you use
MAX_PARTY = 4
# set to true to use facesets instead of spritesets
FACESETS = true
# allows a party with 0 members
ALLOW_EMPTY_PARTY = false
# gives all other characters EXP (specify in %)
EXP_RESERVE = 50
# gives "not available" characters EXP (specify in %)
EXP_NOT_AVAILABLE = 0
# gives "disabled for party" characters EXP (specify in %)
EXP_DISABLED_FOR_PARTY = 0

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

# recognition variable for plug-ins
$easy_party_switcher = true

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

class Game_Actor < Game_Battler

  attr_accessor :must_be_in_party
  attr_accessor :disabled_for_party
  attr_accessor :not_available
  attr_accessor :forced_position
  
  alias setup_eps_later setup
  def setup(actor_id)
    setup_eps_later(actor_id)
    @must_be_in_party = false
    @disabled_for_party = false
    @not_available = false
  end
  
end

#==============================================================================
# Game_System
#==============================================================================

class Game_System

  attr_accessor :stored_party
  
end

#==============================================================================
# Game_Party
#==============================================================================

class Game_Party

  attr_accessor :actors
  attr_accessor :forced_size
  
  def any_forced_position
    for actor in @actors
      return true if actor != nil and actor.forced_position != nil
    end
    return false
  end
  
end

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

class Window_Base

  alias draw_actor_graphic_eps_later draw_actor_graphic
  def draw_actor_graphic(actor, x, y)
    if actor != nil and actor.character_name != ''
      if FACESETS and
          [Window_Current, Window_Reserve, Window_HelpStatus].include?(self.class)
        draw_actor_face_eps(actor, x, y)
      else
        if [Window_Current, Window_Reserve, Window_HelpStatus].include?(self.class)
          bitmap = RPG::Cache.character(actor.character_name, actor.character_hue)
          x += bitmap.width / 8 + 24
          y += bitmap.height / 4 + 16
        end
        draw_actor_graphic_eps_later(actor, x, y)
      end
    end
  end

  def draw_actor_face_eps(actor, x, y)
    if $tons_version == nil or $tons_version < 3.71 or not FACE_HUE
      hue = 0
    else
      hue = actor.character_hue
    end
    bitmap = RPG::Cache.character("#{actor.character_name}_face", hue)
    src_rect = Rect.new(0, 0, bitmap.width, bitmap.height)
    if actor.not_available or actor.must_be_in_party
      self.contents.blt(x, y, bitmap, src_rect, 128)
    else
      self.contents.blt(x, y, bitmap, src_rect)
    end
  end
  
end

#==============================================================================
# Window_BattleResult
#==============================================================================

class Window_BattleResult
  
  attr_reader :exp
  
end

#==============================================================================
# Window_Current
#==============================================================================

class Window_Current < Window_Selectable

  def initialize
    super(0, 0, 240 + 32, (MAX_PARTY > 4 ? 480 : MAX_PARTY * 120))
    self.contents = Bitmap.new(width - 32, 448 + (MAX_PARTY-4) * 120)
    @item_max = MAX_PARTY
    if $fontface != nil
      self.contents.font.name = $fontface
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
    end
    self.contents.font.size = 24
    refresh
    self.active = false
    self.index = -1
  end
  
  def refresh
    self.contents.clear
    for i in 0...$game_party.actors.size
      y = i * 120 - 4
      self.contents.font.color = normal_color
      if $game_party.actors[i] != nil
        draw_actor_graphic($game_party.actors[i], 4, y + 8)
        draw_actor_name($game_party.actors[i], 152, y)
        draw_actor_level($game_party.actors[i], 88, y)
        draw_actor_hp($game_party.actors[i], 88, y + 32)
        draw_actor_sp($game_party.actors[i], 88, y + 64)
      end
    end
  end

  def setactor(index_1, index_2)
    temp = $game_party.actors[index_1]
    $game_party.actors[index_1] = $game_party.actors[index_2]
    $game_party.actors[index_2] = temp
    refresh
  end

  def getactor(index)
    return $game_actors[$game_party.actors[index].id]
  end
  
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    y = (@index / @column_max) * 120 - self.oy
    self.cursor_rect.set(0, y, self.width - 32, 88)
  end

  def clone_cursor
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    y = (@index / @column_max) * 120
    src_rect = Rect.new(0, 0, self.width, 88)
    bitmap = Bitmap.new(self.width-32, 88)
    bitmap.fill_rect(0, 0, self.width-32, 88, Color.new(255, 255, 255, 192))
    bitmap.fill_rect(2, 2, self.width-36, 84, Color.new(255, 255, 255, 80))
    self.contents.blt(0, y, bitmap, src_rect, 192)
  end
  
  def top_row
    return self.oy / 116
  end

  def top_row=(row)
    row = row % row_max
    self.oy = row * 120
  end

  def page_row_max
    return (self.height / 120)
  end

end

#==============================================================================
# Window_Reserve
#==============================================================================

class Window_Reserve < Window_Selectable
  
  attr_reader :actors
  
  def initialize
    super(0, 0, 368, 320)
    setup
    @column_max = 3
    rows = @item_max / @column_max
    self.contents = Bitmap.new(width - 32, (rows >= 3 ? rows * 96 : height - 32))
    if $fontface != nil
      self.contents.font.name = $fontface
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
    end
    self.contents.font.size = 24
    self.active = false
    self.index = -1
    refresh
  end
  
  def setup
    @actors = []
    for i in 1...$data_actors.size
      unless $game_party.actors.include?($game_actors[i]) or
          $game_actors[i].disabled_for_party
        @actors.push($game_actors[i])
      end
    end
    @item_max = (@actors.size + $game_party.actors.size + 3) / 3 * 3
  end
  
  def refresh
    self.contents.clear
    for i in 0...@actors.size
      draw_actor_graphic(@actors[i], i%3*112 + 16, i/3*96 + 8)
    end
  end
  
  def getactor(index)
    return @actors[index]
  end
  
  def get_number
    count = 0
    for actor in @actors
      count += 1 unless actor == nil or actor.not_available
    end
    return count
  end
  
  def setactor(index_1, index_2)
    temp = @actors[index_1]
    @actors[index_1] = @actors[index_2]
    @actors[index_2] = temp
    refresh
  end

  def setparty(index_1, index_2)
    temp = @actors[index_1]
    @actors[index_1] = $game_party.actors[index_2]
    $game_party.actors[index_2] = temp
    refresh
  end

  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    x = (@index % @column_max) * 112 + 8
    y = (@index / @column_max) * 96 - self.oy
    self.cursor_rect.set(x, y, 96, 96)
  end

  def clone_cursor
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    x = (@index % @column_max) * 112 + 8
    y = (@index / @column_max) * 96
    src_rect = Rect.new(0, 0, 96, 96)
    bitmap = Bitmap.new(96, 96)
    bitmap.fill_rect(0, 0, 96, 96, Color.new(255, 255, 255, 192))
    bitmap.fill_rect(2, 2, 92, 92, Color.new(255, 255, 255, 80))
    self.contents.blt(x, y, bitmap, src_rect, 192)
  end
  
  def top_row
    return self.oy / 96
  end

  def top_row=(row)
    row = row % row_max
    self.oy = row * 96
  end

  def page_row_max
    return (self.height - 32) / 96
  end

end

#==============================================================================
# Window_HelpStatus
#==============================================================================

class Window_HelpStatus < Window_Base

  def initialize(gotactor)
    super(0, 0, 400 - 32, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    if $fontface != nil
      self.contents.font.name = $fontface
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
    end
    self.contents.font.size = 24
    refresh(gotactor)
    self.active = false
  end
  
  def refresh(actor)
    self.contents.clear
    if actor != nil
      x = y = 0
      self.contents.font.color = normal_color
      if actor.not_available
        self.contents.draw_text(x + 8, y, 160, 32, 'not available', 0)
      end
      draw_actor_graphic(actor, x, y + 40)
      draw_actor_name(actor, x + 160, y + 32)
      draw_actor_level(actor, x + 96, y + 32)
      draw_actor_hp(actor, x + 96, y + 64)
      draw_actor_sp(actor, x + 96, y + 96)
    end
  end

end

#==============================================================================
# Window_Warning
#==============================================================================

class Window_Warning < Window_Base

  def initialize(mode, members)
    super(0, 0, 320, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    if $fontface != nil
      self.contents.font.name = $fontface
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
    end
    self.contents.font.size = 24
    self.x = 320 - width/2
    self.y = 240 - height/2
    self.z = 9999
    self.contents.font.color = normal_color
    if mode
      self.contents.draw_text(0, 0, 288, 32, 'You need a party', 1)
      num = [$game_party.forced_size, members + $game_party.actors.nitems].min
      self.contents.draw_text(0, 32, 288, 32, "of #{num} members!", 1)
    else
      self.contents.draw_text(0, 0, 288, 32, 'You cannot remove', 1)
      self.contents.draw_text(0, 32, 288, 32, 'the last party member!', 1)
    end
  end

end

#==============================================================================
# Scene_PartySwitcher
#==============================================================================

class Scene_PartySwitcher
  
  def initialize(wipe_party = 0, reset = 0, store = 0)
    @wipe_party = wipe_party
    @store = store
    @reset = reset
    @current_window_temp = 0
    @reserve_window_temp = 0
    @scene_flag = false
    @temp_window = ''
  end
  
  def main
    if @store != 0
      swap_parties
      $scene = Scene_Map.new
      $game_player.refresh
      return
    end
    case @wipe_party
    when 1 then setup_forced_party
    when 2 then wipe_party
    when 3
      $game_system.stored_party = $game_party.actors
      wipe_party
    end
    if @reset == 1
      for i in 1...$data_actors.size
        $game_actors[i].not_available = false
      end
    end
    @current_window = Window_Current.new
    @current_window.index = 0
    @current_window.active = true
    @reserve_window = Window_Reserve.new
    @reserve_window.x = 240 + 32
    @reserve_window.y = 160
    @help_window = Window_HelpStatus.new(@reserve_window.getactor(0))
    @help_window.x = 240 + 32
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      break if $scene != self
    end
    Graphics.freeze
    @current_window.dispose
    @reserve_window.dispose
    @help_window.dispose
    $game_party.actors.compact!
    $game_player.refresh
  end
  
  def update
    check = @reserve_window.index
    if @reserve_window.active
      reserve_update
      @reserve_window.update
    end
    if check != @reserve_window.index
      if @reserve_window.active
        actor = @reserve_window.getactor(@reserve_window.index)
      elsif @current_window.active 
        actor = @reserve_window.getactor(@reserve_window_temp)
      end
      @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
    end
    current_update if @current_window.active
    if Input.trigger?(Input::B)
      if @scene_flag
        $game_system.se_play($data_system.cancel_se)
        @temp_window = ''
        @scene_flag = false
        if @reserve_window.active
          actor = @reserve_window.getactor(@reserve_window.index)
        elsif @current_window.active
          actor = @reserve_window.getactor(@reserve_window_temp)
        end
        @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
        @current_window.refresh
        @reserve_window.refresh
        return
      end
      if $game_party.forced_size != nil
        if $game_party.forced_size < $game_party.actors.nitems or
           ($game_party.forced_size > $game_party.actors.nitems and
            @reserve_window.get_number != 0)
          $game_system.se_play($data_system.buzzer_se)
          warning(true)
          return
        end
      end
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
      return
    end
    if Input.trigger?(Input::A)
      if $game_party.any_forced_position
        $game_system.se_play($data_system.buzzer_se)
      else
        $game_system.se_play($data_system.decision_se)
        $game_party.actors.compact! 
        @current_window.refresh
      end
    end
  end
    
  def current_update
    @current_window.update
    if Input.trigger?(Input::C)
      actor = @current_window.getactor(@current_window.index)
      if actor != nil and actor.forced_position != nil
        $game_system.se_play($data_system.buzzer_se)
      else
        if @scene_flag
          switch_members
        else
          $game_system.se_play($data_system.decision_se)
          @scene_flag = true
          @temp_actor_index = @current_window.index
          @temp_window = 'Current'
          @current_window.clone_cursor
        end
      end
      return
    end
    if Input.trigger?(Input::RIGHT)
      $game_system.se_play($data_system.cursor_se)
      @current_window.active = false
      @reserve_window.active = true
      @current_window_temp = @current_window.index
      actor = @reserve_window.getactor(@reserve_window_temp)
      @current_window.index = -1
      @reserve_window.index = @reserve_window_temp
      @help_window.refresh(actor) unless @scene_flag
      return
    end
  end
  
  def reserve_update
    if Input.trigger?(Input::C)
      unless @scene_flag
        $game_system.se_play($data_system.decision_se)
        @scene_flag = true
        @temp_actor_index = @reserve_window.index
        @temp_window = 'Reserve'
        @reserve_window.clone_cursor
      else
        switch_members
      end
      return
    end
    if (@reserve_window.index % 3) == 0
      if Input.repeat?(Input::LEFT)
        $game_system.se_play($data_system.cursor_se)
        @reserve_window.active = false
        @current_window.active = true
        @reserve_window_temp = @reserve_window.index
        @reserve_window.index = -1
        @current_window.index = @current_window_temp
      end
    end
  end
  
  def switch_members
    if @temp_window == 'Reserve' and @reserve_window.active
      @reserve_window.setactor(@temp_actor_index, @reserve_window.index)
      actor = @reserve_window.getactor(@reserve_window.index)
      @help_window.refresh(actor)
    end
    if @temp_window == 'Current' and @current_window.active
      @current_window.setactor(@temp_actor_index, @current_window.index)
    end
    if @temp_window == 'Reserve' and @current_window.active
      actor1 = @current_window.getactor(@current_window.index)
      actor2 = @reserve_window.getactor(@temp_actor_index)
      if call_warning?(@current_window.index, actor2)
        if actor1 != nil and actor1.must_be_in_party
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag = false
          @temp_window = ''
          actor = @reserve_window.getactor(@reserve_window_temp)
          @current_window.refresh
          @reserve_window.refresh
          @help_window.refresh(actor)
          return
        end
        if actor2 != nil and actor2.not_available
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag = false
          @temp_window = ''
          actor = @reserve_window.getactor(@reserve_window_temp)
          @current_window.refresh
          @reserve_window.refresh
          @help_window.refresh(actor)
          return
        end
        @reserve_window.setparty(@temp_actor_index, @current_window.index)
        @current_window.refresh
        actor = @reserve_window.getactor(@reserve_window_temp)
        @help_window.refresh(actor)
      else
        warning
      end
    end
    if @temp_window == 'Current' and @reserve_window.active
      actor1 = @current_window.getactor(@temp_actor_index)
      actor2 = @reserve_window.getactor(@reserve_window.index)
      if call_warning?(@temp_actor_index, actor2)
        if actor1 != nil and actor1.must_be_in_party
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag = false
          @temp_window = ''
          actor = @reserve_window.getactor(@reserve_window.index)
          @current_window.refresh
          @reserve_window.refresh
          @help_window.refresh(actor)
          return
        end
        if actor2 != nil and actor2.not_available
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag = false
          @temp_window = ''
          actor = @reserve_window.getactor(@reserve_window.index)
          @current_window.refresh
          @reserve_window.refresh
          @help_window.refresh(actor)
          return
        end
        @reserve_window.setparty(@reserve_window.index, @temp_actor_index)
        @current_window.refresh
        actor = @reserve_window.getactor(@reserve_window.index)
        @help_window.refresh(actor)
      else
        warning
      end
    end
    $game_system.se_play($data_system.decision_se)
    @scene_flag = false
    @temp_window = ""
  end
    
  def wipe_party
    for i in 0...$game_party.actors.size
      $game_party.actors[i].not_available = true if $game_party.actors[i] != nil
    end
    setup_forced_party(true)
    if $game_party.actors == []
      for i in 1...$data_actors.size
        unless $game_actors[i].not_available or $game_actors[i].disabled_for_party
          $game_party.actors[$game_party.actors.size] = $game_actors[i]
          return
        end
      end
    end
  end
  
  def setup_forced_party(flag = false)
    $game_party.actors = []
    party = []
    for i in 1...$data_actors.size
      actor = $game_actors[i]
      if actor != nil and actor.must_be_in_party and
           (not actor.disabled_for_party or flag) and not actor.not_available
        party[party.size] = actor
      end
    end
    for i in 0...party.size
      if actor.forced_position != nil
        $game_party.actors[party[i].forced_position] = party[i]
        party[i] = nil
      end
    end
    party.compact!
    for actor in party
      $game_party.actors.push(actor)
    end
  end  
  
  def swap_parties
    $game_party.actors.compact!
    temp_actors = $game_party.actors
    for actor in temp_actors
      actor.not_available = true
    end
    $game_system.stored_party.compact!
    for actor in $game_system.stored_party
      actor.not_available = false
    end
    $game_party.actors = $game_system.stored_party
    $game_system.stored_party = nil
    $game_system.stored_party = temp_actors if @store == 1
  end
  
  def call_warning?(index, actor2)
    return (ALLOW_EMPTY_PARTY or $game_party.actors[index] == nil or
        actor2 != nil or $game_party.actors.nitems > 1)
  end
  
  def warning(flag = false)
    $game_system.se_play($data_system.buzzer_se)
    @warning_window = Window_Warning.new(flag, @reserve_window.get_number)
    loop do
      Graphics.update
      Input.update
      if Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se) if flag
        @current_window.refresh
        @reserve_window.refresh
        @warning_window.dispose
        @warning_window = nil
        break
      end
    end
  end
  
end

#==============================================================================
# Scene_Battle
#==============================================================================
  
class Scene_Battle
  
  alias start_phase5_eps_later start_phase5
  def start_phase5
    start_phase5_eps_later
    for i in 1...$data_actors.size
      unless $game_party.actors.include?($game_actors[i])
        if $game_actors[i].not_available
          $game_actors[i].exp += @result_window.exp * EXP_NOT_AVAILABLE/100
        elsif $game_actors[i].disabled_for_party
          $game_actors[i].exp += @result_window.exp * EXP_DISABLED_FOR_PARTY/100
        else
          $game_actors[i].exp += @result_window.exp * EXP_RESERVE/100
        end
      end
    end
  end
  
end
site ou autor do arquivo Blizzard (RM) tamanho do arquivo 337KB licencaGrátis sistemas operacionais compativeisWindows 98/98SE/Me/2000/XP/Vista/7 Download

Deixe um comentário

  • Seja social e nos siga!

           
  • Páginas

  • Tags Especiais

  • Categorias

  • Parceiros

  • eXTReMe Tracker
    Copyright © 2001 - 2017 Gaming Room. Todos os Direitos Reservados - É expressamente proibida a reprodução total ou parcial deste site sem o consentimento dos autores.