这两个脚本的作用是什么？

893299399 · 发表于 2013-11-9 17:38:50

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有账号？注册会员

×

[pre lang="ruby" line="1"]#==============================================================================
# +++ MOG - Battle Cry (V1.0) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com
#==============================================================================
# Sistema de execução de multiplas vozes aleatórias durante a batalha.
# O sistema funciona tanto para inimigos como para os personagens.
#===============================================================================
module MOG_BATTLE_CRY

  # Não modifique essa parte.
  # ☢CAUTION!!☢ Don't Touch.^_^
  ACTOR_SKILL = []
  ACTOR_ITEM = []
  ACTOR_GENERAL_ACTION = []
  ACTOR_DAMAGE = []
  ACTOR_RECOVER = []
  ACTOR_DEFEATED = []
  ACTOR_BATTLE_START = []
  ACTOR_BATTLE_END = []
  ACTOR_BATTLE_ESCAPE = []
  ACTOR_TURN_ACTIVE = []
  ACTOR_LEVEL_UP = []
  ENEMY_SKILL = []
  ENEMY_GENERAL_ACTION = []
  ENEMY_DAMAGE = []
  ENEMY_RECOVER = []
  ENEMY_DEFEATED = []

  # ----------------------------------------------------------------------------
  # Definição do volume da voz.
  VOLUME = 130

  # Exemplo de configuração geral, o modo de configurar é igual para todas as
  # ações do battler.
  #
  # ACTOR_SKILL[ A ] = {  B=>["C","C","C"],
  #
  # A - ID do battler.
  # B - ID da skill. (Caso necessário)
  # C - Nome do arquivo de som.


  #----------------------------------------------------------------------------
  # BATTLE START
  #----------------------------------------------------------------------------
  ACTOR_BATTLE_START[1] = ["V_ACT1_START_1","V_ACT1_START_2"]
  ACTOR_BATTLE_START[2] = ["V_ACT2_START_1","V_ACT2_START_2","V_ACT2_START_3"]
  ACTOR_BATTLE_START[3] = ["V_ACT3_START_1","V_ACT3_START_2"]
  ACTOR_BATTLE_START[4] = ["V_ACT4_START_1","V_ACT4_START_2","V_ACT4_START_3"]

  #----------------------------------------------------------------------------
  # BATTLE END
  #----------------------------------------------------------------------------
  ACTOR_BATTLE_END[1] = ["V_ACT1_WIN_1","V_ACT1_WIN_2"]
  ACTOR_BATTLE_END[2] = ["V_ACT2_WIN_1","V_ACT2_WIN_2","V_ACT2_WIN_3"]
  ACTOR_BATTLE_END[3] = ["V_ACT3_WIN_1","V_ACT3_WIN_2","V_ACT3_WIN_3"]
  ACTOR_BATTLE_END[4] = ["V_ACT4_WIN_1","V_ACT4_WIN_2"]

  #----------------------------------------------------------------------------
  # BATTLE ESCAPE
  #----------------------------------------------------------------------------
  ACTOR_BATTLE_ESCAPE[1] = ["V_ACT1_SKILL_9"]
  ACTOR_BATTLE_ESCAPE[2] = ["V_ACT2_SKILL_4"]
  ACTOR_BATTLE_ESCAPE[3] = ["V_ACT3_SKILL_4"]
  ACTOR_BATTLE_ESCAPE[4] = ["V_ACT4_SKILL_7"]

  #----------------------------------------------------------------------------
  # ACTOR TURN ACTIVE
  #----------------------------------------------------------------------------
  # Funciona apenas com script MOG AT SYSTEM.
  ACTOR_TURN_ACTIVE[1] = ["V_ACT1_TURN_1","V_ACT1_TURN_2","V_ACT1_TURN_3"]
  ACTOR_TURN_ACTIVE[2] = ["V_ACT2_TURN_1","V_ACT2_TURN_2","V_ACT2_TURN_3"]
  ACTOR_TURN_ACTIVE[3] = ["V_ACT3_TURN_1","V_ACT3_TURN_2","V_ACT3_TURN_3"]
  ACTOR_TURN_ACTIVE[4] = ["V_ACT4_TURN_1","V_ACT4_TURN_2","V_ACT4_TURN_3"]

  #----------------------------------------------------------------------------
  # ACTOR LEVEL UP
  #----------------------------------------------------------------------------
  ACTOR_LEVEL_UP[1] = ["V_ACT1_TURN_1"]
  ACTOR_LEVEL_UP[2] = ["V_ACT2_TURN_1"]
  ACTOR_LEVEL_UP[3] = ["V_ACT3_TURN_1"]
  ACTOR_LEVEL_UP[4] = ["V_ACT4_TURN_1"]

  #----------------------------------------------------------------------------
  # ACTOR SKILL
  #----------------------------------------------------------------------------
  ACTOR_SKILL[1] = {
  1=>["V_ACT1_ATTACK_1","V_ACT1_ATTACK_2","V_ACT1_ATTACK_3"],
  2=>["V_ACT1_WIN_1","V_ACT1_WIN_2"]
  }

  ACTOR_SKILL[2] = {
  1=>["V_ACT2_ATTACK_1","V_ACT2_ATTACK_2","V_ACT2_ATTACK_3"],
  2=>["V_ACT2_WIN_1","V_ACT2_WIN_2","V_ACT2_WIN_3"],
  26=>["V_ACT2_SKILL_6","V_ACT2_SKILL_7","V_ACT2_SKILL_8"],
  29=>["V_ACT2_SKILL_6","V_ACT2_SKILL_7","V_ACT2_SKILL_8"],
  32=>["V_ACT2_SKILL_6","V_ACT2_SKILL_7","V_ACT2_SKILL_8"],
  33=>["V_ACT2_SKILL_6","V_ACT2_SKILL_7","V_ACT2_SKILL_8"],
  }

  ACTOR_SKILL[3] = {
  1=>["V_ACT3_ATTACK_1","V_ACT3_ATTACK_2","V_ACT3_ATTACK_3"],
  2=>["V_ACT3_SKILL_4"],
  26=>["V_ACT3_SKILL_3","V_ACT3_SKILL_6","V_ACT3_SKILL_7"],
  76=>["V_ACT3_SKILL_3","V_ACT3_SKILL_6","V_ACT3_SKILL_7"],
  77=>["V_ACT3_SKILL_3","V_ACT3_SKILL_6","V_ACT3_SKILL_7"],
  78=>["V_ACT3_SKILL_3","V_ACT3_SKILL_6","V_ACT3_SKILL_7"]
  }

  ACTOR_SKILL[4] = {
  1=>["V_ACT4_ATTACK_1","V_ACT4_ATTACK_2","V_ACT4_ATTACK_3"],
  2=>["V_ACT4_SKILL_3","V_ACT4_SKILL_8"],
  51=>["V_ACT4_SKILL_1","V_ACT4_SKILL_4","V_ACT4_SKILL_6","V_ACT4_SKILL_9"],
  53=>["V_ACT4_SKILL_1","V_ACT4_SKILL_4","V_ACT4_SKILL_6","V_ACT4_SKILL_9"],
  61=>["V_ACT4_SKILL_1","V_ACT4_SKILL_4","V_ACT4_SKILL_6","V_ACT4_SKILL_9"],
  66=>["V_ACT4_SKILL_1","V_ACT4_SKILL_4","V_ACT4_SKILL_6","V_ACT4_SKILL_9"],
  74=>["V_ACT4_SKILL_1","V_ACT4_SKILL_4","V_ACT4_SKILL_6","V_ACT4_SKILL_9"]
  }

  #----------------------------------------------------------------------------
  # ACTOR ITEM
  #----------------------------------------------------------------------------
  ACTOR_ITEM[1] = {
  1=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"], 2=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"],
  3=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"], 4=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"],
  5=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"], 6=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"],
  7=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"], 8=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"],
  17=>["V_ACT1_SKILL_6","V_ACT1_SKILL_7"]
  }

  ACTOR_ITEM[2] = {
  1=>["V_ACT2_RECOVER_2"],  2=>["V_ACT2_RECOVER_2"],  3=>["V_ACT2_RECOVER_2"],
  4=>["V_ACT2_RECOVER_2"],  5=>["V_ACT2_RECOVER_2"],  6=>["V_ACT2_RECOVER_2"],
  7=>["V_ACT2_RECOVER_2"],  8=>["V_ACT2_RECOVER_2"],  17=>["V_ACT2_RECOVER_2"]
  }

  ACTOR_ITEM[3] = {
  1=>["V_ACT3_WIN_2"],  2=>["V_ACT3_WIN_2"],  3=>["V_ACT3_WIN_2"],
  4=>["V_ACT3_WIN_2"],  5=>["V_ACT3_WIN_2"],  6=>["V_ACT3_WIN_2"],
  7=>["V_ACT3_WIN_2"],  8=>["V_ACT3_WIN_2"],  17=>["V_ACT3_WIN_2"]
  }

  ACTOR_ITEM[4] = {
  1=>["V_ACT4_START_3"],  2=>["V_ACT4_START_3"],  3=>["V_ACT4_START_3"],
  4=>["V_ACT4_START_3"],  5=>["V_ACT4_START_3"],  6=>["V_ACT4_START_3"],
  7=>["V_ACT4_START_3"],  8=>["V_ACT4_START_3"],  17=>["V_ACT4_START_3"]
  }

  #----------------------------------------------------------------------------
  # ACTOR GENERAL ACTION *( STANDARD / FOR ALL SKILLS / ITEMS)
  #----------------------------------------------------------------------------
  # Definição das vozes para habilidades não especificas. Essas vozes serão
  # ativadas em todas habilidades que não estejam definidas na função ACTOR SKILL.
  # Naturalmente se não desejar essa função basta não definir nada.
  ACTOR_GENERAL_ACTION[2] = ["V_ACT2_ATTACK_1","V_ACT2_ATTACK_2","V_ACT2_ATTACK_3"]

  #----------------------------------------------------------------------------
  # ACTOR DAMAGE
  #----------------------------------------------------------------------------
  ACTOR_DAMAGE[1] = ["V_ACT1_DAMAGE_1","V_ACT1_DAMAGE_2"]
  ACTOR_DAMAGE[2] = ["V_ACT2_DAMAGE_1","V_ACT2_DAMAGE_2","V_ACT2_DAMAGE_3"]
  ACTOR_DAMAGE[3] = ["V_ACT3_DAMAGE_1","V_ACT3_DAMAGE_2","V_ACT3_DAMAGE_3"]
  ACTOR_DAMAGE[4] = ["V_ACT4_DAMAGE_1","V_ACT4_DAMAGE_2","V_ACT4_DAMAGE_3"]

  #----------------------------------------------------------------------------
  # ACTOR RECOVER
  #----------------------------------------------------------------------------
  ACTOR_RECOVER[1] = ["V_ACT1_RECOVER_1","V_ACT1_RECOVER_2"]
  ACTOR_RECOVER[2] = ["V_ACT2_RECOVER_1","V_ACT2_RECOVER_2"]
  ACTOR_RECOVER[3] = ["V_ACT3_RECOVER_1","V_ACT3_RECOVER_2"]
  ACTOR_RECOVER[4] = ["V_ACT4_RECOVER_1","V_ACT4_RECOVER_2"]

  #----------------------------------------------------------------------------
  # ACTOR DEFEATED
  #----------------------------------------------------------------------------
  ACTOR_DEFEATED[1] = ["V_ACT1_DEFEAT_1"]
  ACTOR_DEFEATED[2] = ["V_ACT2_DEFEAT_1"]
  ACTOR_DEFEATED[3] = ["V_ACT3_DEFEAT_1"]
  ACTOR_DEFEATED[4] = ["V_ACT4_DEFEAT_1","V_ACT4_DEFEAT_2"]

  #----------------------------------------------------------------------------
  # ENEMY SKILL
  #----------------------------------------------------------------------------
  ENEMY_SKILL[7] = {
  135=>["V_ENE1_SKILL_3"]
  }
  ENEMY_SKILL[9] = {
  137=>["Cel_Attack_01","Cel_Attack_02","Cel_Attack_03","Cel_Attack_04"]
  }


  #----------------------------------------------------------------------------
  # ENEMY GENERAL SKILLS
  #----------------------------------------------------------------------------
  ENEMY_GENERAL_ACTION[7] = ["V_ENE1_ATTACK_1","V_ENE1_ATTACK_2","V_ENE1_ATTACK_3"]

  #----------------------------------------------------------------------------
  # ENEMY DAMAGE
  #----------------------------------------------------------------------------
  ENEMY_DAMAGE[7] = ["V_ENE1_DAMAGE_1","V_ENE1_DAMAGE_2","V_ENE1_DAMAGE_3"]
  ENEMY_DAMAGE[9] = ["Cel_Damage1","Cel_Damage2"]

  #----------------------------------------------------------------------------
  # ENEMY RECOVER
  #----------------------------------------------------------------------------
  ENEMY_RECOVER[7] = []

  #----------------------------------------------------------------------------
  # ENEMY DEFEATED
  #----------------------------------------------------------------------------
  ENEMY_DEFEATED[7] =  ["V_ENE1_DEFEAT_1"]

end

#===============================================================================
# ■ Battle Cry
#===============================================================================
module BATTLE_CRY

  include MOG_BATTLE_CRY

  #--------------------------------------------------------------------------
  # ● Execute Battle Cry
  #--------------------------------------------------------------------------
  def execute_battle_cry(type = 0, skill_id = nil, battler = nil)
   @type = type
   @skill_id = skill_id
   @battler = battler
   case @type
      when 0 # START #
         check_members_alive
         voice_list = ACTOR_BATTLE_START[@battler.id] rescue nil
      when 1 # END #
         check_members_alive
         voice_list = ACTOR_BATTLE_END[@battler.id] rescue nil
      when 2 # SKILL #
         if @battler.is_a?(Game_Actor)
            voice = ACTOR_SKILL[@battler.id] rescue nil
         else
            voice = ENEMY_SKILL[@battler.enemy_id] rescue nil
         end
         voice_list = voice[@skill_id] rescue nil
         if voice_list == nil # GENERAL ACTION
            if @battler.is_a?(Game_Actor)
               voice_list = ACTOR_GENERAL_ACTION[@battler.id] rescue nil
            else
               voice_list = ENEMY_GENERAL_ACTION[@battler.enemy_id] rescue nil
            end
         end
      when 3 # DAMAGE #
         if @battler.hp > 0
            if @battler.is_a?(Game_Actor)
               voice_list = ACTOR_DAMAGE[@battler.id] rescue nil
            else
               voice_list = ENEMY_DAMAGE[@battler.enemy_id] rescue nil
            end
         else # DEFEATED #
            if @battler.is_a?(Game_Actor)
               voice_list = ACTOR_DEFEATED[@battler.id] rescue nil
            else
               voice_list = ENEMY_DEFEATED[@battler.enemy_id] rescue nil
            end
         end
      when 4 # RECOVER #
            if @battler.is_a?(Game_Actor)
               voice_list = ACTOR_RECOVER[@battler.id] rescue nil
            else
               voice_list = ENEMY_RECOVER[@battler.enemy_id] rescue nil
            end
      when 5 # ITEM #
            voice = ACTOR_ITEM[@battler.id] rescue nil
            voice_list = voice[@skill_id] rescue nil
         if voice_list == nil # GENERAL SKILLS
            voice_list = ACTOR_GENERAL_ACTION[@battler.id] rescue nil
         end
      when 6 # START #
            check_members_alive
            voice_list = ACTOR_BATTLE_ESCAPE[@battler.id] rescue nil
      when 7 # TURN #
            voice_list = ACTOR_TURN_ACTIVE[@battler.id] rescue nil
   end
   play_battle_cry(voice_list)
   check_battle_addons
  end

  #--------------------------------------------------------------------------
  # ● Play Battle Cry
  #--------------------------------------------------------------------------
  def play_battle_cry(voice_list)
   return if voice_list == nil
   voice_id = voice_list[rand(voice_list.size)]
   Audio.se_play("Audio/SE/" + voice_id.to_s,VOLUME,100) rescue nil
  end

  #--------------------------------------------------------------------------
  # ● Check Members Alive
  #--------------------------------------------------------------------------
  def check_members_alive
   alive_members = []
   id = 0
   for i in $game_party.battle_members
      alive_members.push(i) if i.hp > 0
   end
   members_id = rand(alive_members.size)
   for i in alive_members
      if members_id == id
         @battler = i
         break
      end
      id += 1
   end
   @battler = alive_members[members_id]
  end

  #--------------------------------------------------------------------------
  # ● Check Battle Addons
  #--------------------------------------------------------------------------
  def check_battle_addons
   if $mog_rgss3_battle_hud != nil and MOG_BATTLE_HUD::BATTLER_FACE_ENABLE and
      @battler != nil and @battler.is_a?(Game_Actor)
      if @type == 0 or @type == 1 or @type == 6
         @battler.battler_face = [2,3,50]
      elsif @type == 7
         @battler.battler_face = [0,3,50]
      end
   end
  end

end

#==============================================================================
# ■ BattleManager
#==============================================================================
class << BattleManager
  include BATTLE_CRY

  #--------------------------------------------------------------------------
  # ● Battle Start
  #--------------------------------------------------------------------------
  alias mog_battle_cry_battle_start battle_start
  def battle_start
   mog_battle_cry_battle_start
#  execute_battle_cry(0, nil, nil)
  end

  #--------------------------------------------------------------------------
  # ● Process Victory
  #--------------------------------------------------------------------------
  alias mog_battle_cry_process_victory process_victory
  def process_victory
   execute_battle_cry(1, nil, nil)
   mog_battle_cry_process_victory
  end

  #--------------------------------------------------------------------------
  # ● Process Abort
  #--------------------------------------------------------------------------
  alias mog_battle_cry_process_abort process_abort
  def process_abort
   execute_battle_cry(6, nil, nil)
   mog_battle_cry_process_abort
  end

end

#==============================================================================
# ■ Game Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
  include BATTLE_CRY

  #--------------------------------------------------------------------------
  # ● Execute Damage
  #--------------------------------------------------------------------------
  alias mog_battle_cry_execute_damage execute_damage
  def execute_damage(user)
   mog_battle_cry_execute_damage(user)
   execute_battle_cry_damage
  end

  #--------------------------------------------------------------------------
  # ● Execute Battle Cry Damage
  #--------------------------------------------------------------------------
  def execute_battle_cry_damage
   if @result.hp_damage > 0
      execute_battle_cry(3, nil, self)
   elsif @result.hp_damage < 0
      execute_battle_cry(4, nil, self)
   else
      if @result.hp_damage == 0
         if @result.mp_damage > 0
            execute_battle_cry(3, nil, self)
         elsif @result.mp_damage < 0
            execute_battle_cry(4, nil, self)
         end
      end
   end
  end

  #--------------------------------------------------------------------------
  # ● Item Effect Recover HP
  #--------------------------------------------------------------------------
  alias mog_battle_cry_item_effect_recover_hp item_effect_recover_hp
  def item_effect_recover_hp(user, item, effect)
   chp = self.hp
   mog_battle_cry_item_effect_recover_hp(user, item, effect)
   if self.hp > chp
      execute_battle_cry(4, nil, self)
   elsif self.hp < chp
      execute_battle_cry(3, nil, self)
   end
  end

  #--------------------------------------------------------------------------
  # ● Item Effect Reover MP
  #--------------------------------------------------------------------------
  alias mog_battle_cry_item_effect_recover_mp item_effect_recover_mp
  def item_effect_recover_mp(user, item, effect)
   cmp = self.mp
   mog_battle_cry_item_effect_recover_mp(user, item, effect)
   if self.mp > cmp
      execute_battle_cry(4, nil, self)
   elsif self.mp < cmp
      execute_battle_cry(3, nil, self)
   end
  end

end

#==============================================================================
# ■ Game Action
#==============================================================================
class Scene_Battle < Scene_Base
include BATTLE_CRY

  #--------------------------------------------------------------------------
  # ● Show Animations
  #--------------------------------------------------------------------------
  alias mog_battle_cry_show_animation show_animation
  def show_animation(targets, animation_id)
   if @subject.is_a?(Game_Actor) and @subject.current_action.item.is_a?(RPG::Item)
      execute_battle_cry(5, @subject.current_action.item.id, @subject)
   else
      execute_battle_cry(2, @subject.current_action.item.id, @subject)
   end
   mog_battle_cry_show_animation(targets, animation_id)
  end

  if $mog_rgss3_at_system != nil
  #--------------------------------------------------------------------------
  # ● Update AT Actor
  #--------------------------------------------------------------------------
  alias mog_battle_cry_update_at_actor update_at_actor
  def update_at_actor(battler)
   mog_battle_cry_update_at_actor(battler)
   execute_battle_cry(7, nil, battler) if battler.is_a?(Game_Actor)
  end
  end

  #--------------------------------------------------------------------------
  # ● Battle Start
  #--------------------------------------------------------------------------
  alias mog_battle_cry_update_battle update
  def update
   mog_battle_cry_update_battle
   execute_battle_cry_start
  end

  #--------------------------------------------------------------------------
  # ● Execite Battle Cry Start
  #--------------------------------------------------------------------------
  def execute_battle_cry_start
   return if @battle_cry_start != nil
   @battle_cry_start = true
   execute_battle_cry(0, nil, nil)
  end
end

$mog_rgss3_battle_cry = true[/pre]
[pre lang="ruby" line="1"]#==============================================================================
# +++ MOG - Kekkai (Bounded Field) (v1.2) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com/
#==============================================================================
# Permite o inimigo invocar uma barreira mágica (Kekkai / Bounded Field)
# onde serão adicionadas regras no campo de batalha. O sistema inclúi
# efeitos animados simulando o Kekkai ativado.
#==============================================================================

#==============================================================================
# ● UTILIZAÇÃO
#==============================================================================
# Modo 1 (Event)
# Use o comando abaixo através do comando chamar script.
#
# kekkai(ID)
#
# ID do Kekkai
#
#==============================================================================
# Modo 2 (Skill)
# Coloque o comentário abaixo na caixa de notas de habilidades .
#
# <Kekkai = ID>
#
#==============================================================================
# Para cancelar o Kekkai use o comando abaixo.
#
# kekkai_clear
#
# ou
#
# kekkai(nil)
#
#==============================================================================

#==============================================================================
# ● As imagens devem ser gravadas na pasta Graphics/Pictures/
#==============================================================================
module MOG_KEKKAI

  BOUNDED_FIELD = [] # ☢CAUTION!!☢ Don't Touch.^_^

  #BOUNDED_FIELD[A] = [B,C,D]
  # A = FIELD ID.
  # B = Description (Kekkai Title).
  #
  # C = Effect Type.
  #    0 - Enemy Power UP
  #    1 - Enemy Defense UP
  #    2 - Enemy Invulnerable.
  #    3 - Party Damage Reverse.
  #    4 - Party always 1 HP or 0 HP.
  #    5 - Party always 0 MP.
  #    6 - Party Power Down.
  #    7 - Party Defense Down.
  #    8 - Seal Skill & Guard Command.
  #    9 - Seal All Commands. (Except Guard Command)
  #    10 - Slip HP Damage.
  #    11 - Slip MP Damage.
  #
  # D = Background File Name.
  # E = Background Animation Type.
  #    0 - Scrolling
  #    1 - Wave
  # F = Scroll Speed X / Wave Power. (0 - 10)
  # G = Scroll Speed Y / Wave Speed. (0 - 10)
  # H = Opacity. (0,255)
  # I = Blend Type. (0- Normal / 1 - Add / 2 - Substract)

  BOUNDED_FIELD[1] = ["Curse  of  Dreams  and  Reality.", #Kekkai Name
                     3,       # Effect Type
                     "Background_1",  # Picture file Name
                     1,       # Animation Type
                     4,       # Scroll Speed X
                     4,       # Scroll Speed Y
                     150,       # Opacity
                     0          # Blend Type
                     ]
  BOUNDED_FIELD[2] = ["Balance of Motion and Stillness.",5, "Kekkai1", 0,1,1,255,0]
  BOUNDED_FIELD[3] = ["Mesh of Light and Darkness.",9, "Background_1", 1,4,10,250,2]
  BOUNDED_FIELD[4] = ["Boundary of Humans and Youkai",2, "Background_5", 1,4,4,155,0]
  BOUNDED_FIELD[5] = ["Boundary of Life and Death.",4, "Background_8", 0,0,0,255,0]
  BOUNDED_FIELD[6] = ["Boundary of Life and Death.",4, "Background_8", 1,1,1,255,0]

  #Definição do poder de ataque do campo.
  ATTACK_PERC = 100

  #Definição do poder de defesa do campo.
  DEFENSE_PERC = 100

  #Porcentagem de dano no efeito Slip.
  SLIP_DAMAGE_PERC = 20

  #Posição do texto (Title). (x,y)
  TEXT_POSITION = [310,0]

  #Ativar o efeito de zoom no texto.
  TEXT_ZOOM_EFFECT = true

  #Definição da cor da fonte.
  FONT_COLOR = Color.new(255,255,255)

  #Apresentar os efeitos em danos. (*É preciso ter o script MOG_Damage_Popup)
  EFFECT_POPUP = true
  EFFECT_POPUP_WORD = "Kekkai Effect"
  EFFECT_POPUP_INVUNERABLE_WORD = "Invulnerable"
  EFFECT_POPUP_REVERSE_DAMAGE_WORD = "Reverse Effect"
end
#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 1.2 - Correção na compatibilidade com o script Advanced Battle Hud.
#       No efeito Drain.
# v 1.1 - Melhoria na codificação.
#==============================================================================

#==============================================================================
# ■ Game Temp
#==============================================================================
class Game_Temp

  attr_accessor :kekkai
  attr_accessor :battle_end

  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  alias mog_bounded_field_initialize initialize
  def initialize
   @kekkai = [false,nil,nil]
   @battle_end = false
   mog_bounded_field_initialize
  end

end

#==============================================================================
# ■ Game Interpreter
#==============================================================================
class Game_Interpreter

  #--------------------------------------------------------------------------
  # ● Bounded Field
  #--------------------------------------------------------------------------
  def kekkai(id = nil)
   id = nil if id < 1
   $game_temp.kekkai = [true,id]
  end

  #--------------------------------------------------------------------------
  # ● Clear  Kekkai
  #--------------------------------------------------------------------------
  def kekkai_clear
   $game_temp.kekkai = [true,nil]
  end

  #--------------------------------------------------------------------------
  # ● Clear Bounded Field
  #--------------------------------------------------------------------------
  def clear_bounded_field
   $game_temp.kekkai = [true,nil]
  end

end

#==============================================================================
# ■ Bounded Field
#==============================================================================
class Bounded_Field

  include MOG_KEKKAI

  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
   $game_temp.kekkai = [false,nil]
   $game_temp.battle_end = false
   @effect = ["",0,"",0,0,0,0,0]
   @phase = 0
   create_kekkai_text(viewport)
  end

  #--------------------------------------------------------------------------
  # ● Create Kekkai Layer
  #--------------------------------------------------------------------------
  def create_kekkai_layer
   if @effect[3] == 0
      @kekkai_1 = Plane.new
      @kekkai_1.bitmap = Cache.picture(@effect[2].to_s)
   else
      range = (@effect[4] + 1) * 10
      range = 500 if range > 500
      speed = (@effect[5] + 1) * 100
      speed = 1000 if speed > 1000
      @kekkai_image = Cache.picture(@effect[2].to_s)
      @kekkai_1 = Sprite.new
      @kekkai_1.x = -range
      @kekkai_1.wave_amp = range
      @kekkai_1.wave_length = Graphics.width
      @kekkai_1.wave_speed = speed
      @kekkai_1.bitmap = Bitmap.new(Graphics.width + (range * 2),Graphics.height)
      @kekkai_1.bitmap.stretch_blt(@kekkai_1.bitmap.rect, @kekkai_image, @kekkai_image.rect)
   end
  end

  #--------------------------------------------------------------------------
  # ● Refresh Kekkai Layer
  #--------------------------------------------------------------------------
  def refresh_kekkai_layer
   dispose_kekkai_layer
   create_kekkai_layer
   @kekkai_1.viewport = @kekkai_text.viewport rescue nil
   @kekkai_1.z = 9
   @kekkai_1.opacity = 0
   @kekkai_1.blend_type = @effect[7]
   @kekkai_1.visible = true
  end

  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------
  def dispose
   dispose_kekkai_layer
   dispose_kekkai_text
   $game_temp.kekkai = [false,nil]
  end

  #--------------------------------------------------------------------------
  # ● Dispose Kekkai Layer
  #--------------------------------------------------------------------------
  def dispose_kekkai_layer
   return if @kekkai_1 == nil
   if @kekkai_1.bitmap != nil
      @kekkai_1.bitmap.dispose
      @kekkai_1.bitmap = nil
   end
   @kekkai_1.dispose
   @kekkai_1 = nil
   if @kekkai_image != nil
      @kekkai_image.dispose
      @kekkai_image = nil
   end
  end

  #--------------------------------------------------------------------------
  # ● Dispose kekkai Text Bitmap
  #--------------------------------------------------------------------------
  def dispose_kekkai_text_bitmap
   return if @kekkai_text == nil
   return if @kekkai_text.bitmap == nil
   @kekkai_text.bitmap.dispose
   @kekkai_text.bitmap = nil
  end

  #--------------------------------------------------------------------------
  # ● Dispose Kekkai Text
  #--------------------------------------------------------------------------
  def dispose_kekkai_text
   return if @kekkai_text == nil
   dispose_kekkai_text_bitmap
   @kekkai_text.dispose
   @kekkai_text = nil
  end

  #--------------------------------------------------------------------------
  # ● Create Kekkai Text
  #--------------------------------------------------------------------------
  def create_kekkai_text(viewport)
   @kekkai_text_duration = 0
   @kekkai_text = Sprite.new
   @kekkai_text.viewport = viewport
   @kekkai_text.z = 11
   @kekkai_text.ox = 120
   @kekkai_text.oy = 16
   @kekkai_text.x = @kekkai_text.ox + TEXT_POSITION[0]
   @kekkai_text.y = @kekkai_text.oy + TEXT_POSITION[1]
   @kekkai_text.visible = false
   refresh_kekkai_text
  end

  #--------------------------------------------------------------------------
  # ● Refresh Kekkai Text
  #--------------------------------------------------------------------------
  def refresh_kekkai_text
   dispose_kekkai_text_bitmap
   @kekkai_text_duration = 0
   @kekkai_text.bitmap = Bitmap.new(240,32)
   text = @effect[0]
   @kekkai_text.bitmap.font.size = 22
   @kekkai_text.bitmap.font.name = "Georgia"
   @kekkai_text.bitmap.font.bold = true
   @kekkai_text.bitmap.font.color = Color.new(0,0,0)
   @kekkai_text.bitmap.draw_text(0,0,240,32,text.to_s, 1)
   @kekkai_text.bitmap.font.color = FONT_COLOR
   @kekkai_text.bitmap.draw_text(2,2,240,32,text.to_s, 1)
   @kekkai_text.zoom_x = 1.00
   @kekkai_text.zoom_y = 1.00
   @kekkai_text.opacity = 0
   @kekkai_text.visible = true
  end


  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def update
   refresh_kekkai if can_refresh_kekkai?
   update_kekkai if can_update_kekkai?
  end

  #--------------------------------------------------------------------------
  # ● Can Refresh Kekkain?
  #--------------------------------------------------------------------------
  def can_refresh_kekkai?
   return false if !$game_temp.kekkai[0]
   return true
  end

  #--------------------------------------------------------------------------
  # ● Can Update Kekkai?
  #--------------------------------------------------------------------------
  def can_update_kekkai?
   return false if @phase == 0
   return true
  end

  #--------------------------------------------------------------------------
  # ● Refresh Kekkai
  #--------------------------------------------------------------------------
  def refresh_kekkai
   $game_temp.kekkai[0] = false
   @effect = BOUNDED_FIELD[$game_temp.kekkai[1]] rescue nil
   if @effect != nil
      refresh_party_effects
      refresh_kekkai_layer
      refresh_kekkai_text
      @phase = 1
   else
      @phase = 2
   end
  end

  #--------------------------------------------------------------------------
  # ● Refresh Party Effects
  #--------------------------------------------------------------------------
  def refresh_party_effects
   if @effect[1] == 4 or @effect[1] == 5
      index = 0
      for i in $game_party.members
         i.hp = 1 if i.hp != 0 and @effect[1] == 4
         i.mp = 0 if @effect[1] == 5
         if $mog_rgss3_battle_hud != nil
            i.battler_face = [3,0,40]
         end
         if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
            i.damage.push([MOG_KEKKAI::EFFECT_POPUP_WORD,"Kekkai Effect"])
         end
         index += 1
         break if index >= $game_party.max_battle_members
      end
   end
  end

  #--------------------------------------------------------------------------
  # ● Update Kekkai
  #--------------------------------------------------------------------------
  def update_kekkai
   update_kekkai_layer
   update_kekkai_text
   if !$game_temp.battle_end
      if @phase == 1
         if  @kekkai_1.opacity < @effect[6]
               @kekkai_1.opacity += 5
               @kekkai_1.opacity = @effect[6] if @kekkai_1.opacity > @effect[6]
         end
         @kekkai_text.opacity += 5
      elsif @phase == 2
         update_kekkai_clear
      end
   else
      update_fade_sprite
   end
  end

  #--------------------------------------------------------------------------
  # ● Update Kekkai Layer
  #--------------------------------------------------------------------------
  def update_kekkai_layer
   return if @kekkai_1 == nil
   return if @effect == nil
   if @effect[3] == 0
      @kekkai_1.ox += @effect[4]
      @kekkai_1.oy += @effect[5]
   else
      @kekkai_1.update
   end
  end

  #--------------------------------------------------------------------------
  # ● Update Kekkai Text
  #--------------------------------------------------------------------------
  def update_kekkai_text
   return if @kekkai_text == nil
   return if !@kekkai_text.visible
   return if !TEXT_ZOOM_EFFECT
   @kekkai_text_duration += 1
   case @kekkai_text_duration
      when 1..20
         @kekkai_text.zoom_x += 0.005
         @kekkai_text.zoom_y += 0.005
      when 21..40
         @kekkai_text.zoom_x -= 0.005
         @kekkai_text.zoom_y -= 0.005
      else
         @kekkai_text.zoom_x = 1.00
         @kekkai_text.zoom_y = 1.00
         @kekkai_text_duration = 0
   end
  end

  #--------------------------------------------------------------------------
  # ● Update Kekkai Clear
  #--------------------------------------------------------------------------
  def update_kekkai_clear
   return if @phase == 0
   return if @kekkai_1 == nil
   @kekkai_1.opacity -= 5
   @kekkai_text.opacity -= 5
   if @kekkai_1.opacity == 0
      dispose_kekkai_layer
      dispose_kekkai_text_bitmap
      @kekkai_text.visible = false
      @phase = 0
   end
  end

  #--------------------------------------------------------------------------
  # ● Update Fade Sprite
  #--------------------------------------------------------------------------
  def update_fade_sprite
   if @kekkai_1 != nil
      @kekkai_1.opacity -= 5
   end
   if @kekkai_text != nil
      @kekkai_text.opacity -= 5
   end
  end

end

#==============================================================================
# ■ Spriteset_Battle
#==============================================================================
class Spriteset_Battle

  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  alias mog_bounded_field_initialize initialize
  def initialize
   mog_bounded_field_initialize
   create_bounded_field
  end

  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------
  alias mog_bounded_field_dispose dispose
  def dispose
   dispose_bounded_field
   mog_bounded_field_dispose
  end

  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  alias mog_bounded_field_update update
  def update
   mog_bounded_field_update
   update_bounded_field
  end

  #--------------------------------------------------------------------------
  # ● Create Bounded Field
  #--------------------------------------------------------------------------
  def create_bounded_field
   @bounded_field = Bounded_Field.new(@viewport1)
  end

  #--------------------------------------------------------------------------
  # ● Dispose Bounded Field
  #--------------------------------------------------------------------------
  def dispose_bounded_field
   return if @bounded_field == nil
   @bounded_field.dispose
  end

  #--------------------------------------------------------------------------
  # ● Update Bounded Field
  #--------------------------------------------------------------------------
  def update_bounded_field
   return if @bounded_field == nil
   @bounded_field.update
  end

end

#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase

  #--------------------------------------------------------------------------
  # ● Bounded Effect
  #--------------------------------------------------------------------------
  def bounded_effect
   MOG_KEKKAI::BOUNDED_FIELD[$game_temp.kekkai[1]] rescue nil
  end

  #--------------------------------------------------------------------------
  # ● Execute Damage
  #--------------------------------------------------------------------------
  alias mog_bounded_field_execute_damage execute_damage
  def execute_damage(user)
   execute_bounded_field_effects_before(user,bounded_effect) if bounded_effect != nil
   mog_bounded_field_execute_damage(user)
   execute_bounded_field_effects_after(user,bounded_effect) if bounded_effect != nil
  end

  #--------------------------------------------------------------------------
  # ● Item Apply
  #--------------------------------------------------------------------------
  alias mog_bounded_field_item_apply item_apply
  def item_apply(user, item)
   return if bounded_nil_effect_enemy?(user)
   mog_bounded_field_item_apply(user, item)
  end

  #--------------------------------------------------------------------------
  # ● Bounded Nil Effect Enemy?
  #--------------------------------------------------------------------------
  def bounded_nil_effect_enemy?(user)
   return false if bounded_effect == nil
   return false if self.is_a?(Game_Actor)
   return false if user.is_a?(Game_Enemy)
   return false if bounded_effect[1] != 2
   if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
      self.damage.push([MOG_KEKKAI::EFFECT_POPUP_INVUNERABLE_WORD,"Invunerable"]) if bounded_effect[1] == 2
   end
   @result.clear
   return true
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded Field Effects Before
  #--------------------------------------------------------------------------
  def execute_bounded_field_effects_before(user,bounded_effect)
   case bounded_effect[1]
      when 0; bounded_power_effect(user)
      when 1; bounded_defense_effect(user)
      when 2; bounded_invunerable_effect(user)
      when 3; bounded_reverse_damage_effect(user)
      when 4; bounded_nil_drain_hp(user)
      when 5; bounded_nil_drain_mp(user)
      when 6; bounded_power_effect_actor(user)
      when 7; bounded_defense_effect_actor(user)
   end
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded Field Effects After
  #--------------------------------------------------------------------------
  def execute_bounded_field_effects_after(user,bounded_effect)
   case bounded_effect[1]
         when 4; bounded_nil_actor_recover_hp(user)
         when 5; bounded_nil_actor_recover_mp(user)
   end
  end

  #--------------------------------------------------------------------------
  # ● Bounded Power Effect
  #--------------------------------------------------------------------------
  def bounded_power_effect(user)
   return if self.is_a?(Game_Enemy)
   return if user.is_a?(Game_Actor)
   dam = @result.hp_damage * MOG_KEKKAI::ATTACK_PERC / 100
   dam = 0 if dam < 0
   @result.hp_damage += dam
  end

  #--------------------------------------------------------------------------
  # ● Bounded Power Effect User
  #--------------------------------------------------------------------------
  def bounded_power_effect_actor(user)
   return if user.is_a?(Game_Enemy)
   return if @result.hp_damage < 0
   dam = @result.hp_damage * MOG_KEKKAI::ATTACK_PERC / 100
   dam = 0 if dam < 0
   @result.hp_damage -= dam
   @result.hp_damage = 0 if @result.hp_damage < 0
  end

  #--------------------------------------------------------------------------
  # ● Bounded Defense Effect
  #--------------------------------------------------------------------------
  def bounded_defense_effect(user)
   return if self.is_a?(Game_Actor)
   return if user.is_a?(Game_Enemy)
   dam = @result.hp_damage * MOG_KEKKAI::DEFENSE_PERC / 100
   dam2 = @result.hp_damage - dam
   dam2 = 0 if dam2 < 0
   @result.hp_damage = dam2
  end

  #--------------------------------------------------------------------------
  # ● Bounded Defense Effect Actor
  #--------------------------------------------------------------------------
  def bounded_defense_effect_actor(user)
   return if self.is_a?(Game_Enemy)
   dam = @result.hp_damage * MOG_KEKKAI::DEFENSE_PERC / 100
   dam2 = @result.hp_damage + dam
   dam2 = 0 if dam2 < 0
   @result.hp_damage = dam2
  end

  #--------------------------------------------------------------------------
  # ● Bounded Invunerable Effect
  #--------------------------------------------------------------------------
  def bounded_invunerable_effect(user)
   return if self.is_a?(Game_Actor)
   return if user.is_a?(Game_Enemy)
   @result.hp_damage = 0
  end

  #--------------------------------------------------------------------------
  # ● Bounded Reverse Damage Effect
  #--------------------------------------------------------------------------
  def bounded_reverse_damage_effect(user)
   return if @result.hp_damage == 0
   return if user.is_a?(Game_Enemy)
   if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
      self.damage.push([MOG_KEKKAI::EFFECT_POPUP_REVERSE_DAMAGE_WORD,"Reverse Effect"])
   end
   @result.hp_damage = -@result.hp_damage
   if @result.hp_drain != nil and @result.hp_drain != 0
      @result.hp_drain = -@result.hp_drain
      if $mog_rgss3_battle_hud != nil
         user.battler_face = [3,0,40]
      end
   end
  end

  #--------------------------------------------------------------------------
  # ● Bounded Nil Drain HP
  #--------------------------------------------------------------------------
  def bounded_nil_drain_hp(user)
   return if self.is_a?(Game_Actor)
   @result.hp_drain = 0
  end

  #--------------------------------------------------------------------------
  # ● Bounded Nil Actor Recover HP
  #--------------------------------------------------------------------------
  def bounded_nil_actor_recover_hp(user)
   return if self.is_a?(Game_Enemy)
   @result.hp_drain = 0
   self.hp = 1 if self.hp > 1
  end

  #--------------------------------------------------------------------------
  # ● Bounded Nil Drain MP
  #--------------------------------------------------------------------------
  def bounded_nil_drain_mp(user)
   return if self.is_a?(Game_Actor)
   @result.mp_drain = 0
  end

  #--------------------------------------------------------------------------
  # ● Bounded Nil Actor Recover MP
  #--------------------------------------------------------------------------
  def bounded_nil_actor_recover_mp(user)
   return if self.is_a?(Game_Enemy)
   self.mp = 0
  end

  #--------------------------------------------------------------------------
  # ● Item Effect Recover HP
  #--------------------------------------------------------------------------
  alias mog_bounded_field_item_effect_recover_hp item_effect_recover_hp
  def item_effect_recover_hp(user, item, effect)
   if bounded_effect != nil and bounded_effect[1] == 3
      execute_bounded_reverse_item_hp(user, item, effect)
      return
   end
   mog_bounded_field_item_effect_recover_hp(user, item, effect)
   if bounded_effect != nil and self.is_a?(Game_Actor)
      execute_bounded_seal_hp
   end
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded Reverse Item HP
  #--------------------------------------------------------------------------
  def execute_bounded_reverse_item_hp(user, item, effect)
   if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
      self.damage.push(["Reverse Effect","Reverse Effect"])
   end
   value = (mhp * effect.value1 + effect.value2) * rec
   value *= user.pha if item.is_a?(RPG::Item)
   value = -value.to_i
   @result.hp_damage -= value
   @result.success = true
   self.hp += value
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded seal HP
  #--------------------------------------------------------------------------
  def execute_bounded_seal_hp
   return if bounded_effect[1] != 4
   self.hp = 1 if self.hp > 0
  end

  #--------------------------------------------------------------------------
  # ● Item Effect Recover MP
  #--------------------------------------------------------------------------
  alias mog_bounded_field_item_effect_recover_mp item_effect_recover_mp
  def item_effect_recover_mp(user, item, effect)
   mog_bounded_field_item_effect_recover_mp(user, item, effect)
   if bounded_effect != nil and self.is_a?(Game_Actor)
      execute_bounded_seal_mp
   end
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded seal MP
  #--------------------------------------------------------------------------
  def execute_bounded_seal_mp
   return if bounded_effect[1] != 5
   self.mp = 0 if self.mp > 0
  end

  #--------------------------------------------------------------------------
  # ● Regenerate HP
  #--------------------------------------------------------------------------
  alias mog_bounded_field_regenerate_hp regenerate_hp
  def regenerate_hp
   mog_bounded_field_regenerate_hp
   if bounded_effect != nil and self.is_a?(Game_Actor)
      execute_bounded_slip_hp
      execute_bounded_seal_hp
   end
  end

  #--------------------------------------------------------------------------
  # ● Regenerate mp
  #--------------------------------------------------------------------------
  alias mog_bounded_field_regenerate_mp regenerate_mp
  def regenerate_mp
   mog_bounded_field_regenerate_mp
   if bounded_effect != nil and self.is_a?(Game_Actor)
      execute_bounded_slip_mp
      execute_bounded_seal_mp
   end
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded Slip HP
  #--------------------------------------------------------------------------
  def execute_bounded_slip_hp
   return if bounded_effect[1] != 10
   return if self.hp <= 1
   dmg = self.mhp * MOG_KEKKAI::SLIP_DAMAGE_PERC  / 100
   dmg = 1 if dmg < 1
   dmg = self.hp - 1 if dmg > self.hp
   self.hp -= dmg if self.hp > 0
   if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
      self.damage.push([dmg,"HP"])
      self.damage.push([MOG_KEKKAI::EFFECT_POPUP_WORD,"Kekkai Effect"])
   end
  end

  #--------------------------------------------------------------------------
  # ● Execute Bounded Slip MP
  #--------------------------------------------------------------------------
  def execute_bounded_slip_mp
   return if bounded_effect[1] != 11
   return if self.mp == 0
   dmg = self.mmp * MOG_KEKKAI::SLIP_DAMAGE_PERC  / 100
   self.mp -= dmg
   if $mog_rgss3_damage_pop != nil and MOG_KEKKAI::EFFECT_POPUP
      self.damage.push([dmg,"MP"])
      self.damage.push([MOG_KEKKAI::EFFECT_POPUP_WORD,"Kekkai Effect"])
   end
  end

end

#==============================================================================
# ■ Game_Interpreter
#==============================================================================
class Game_Interpreter

  #--------------------------------------------------------------------------
  # ● Bounded Effect
  #--------------------------------------------------------------------------
  def bounded_effect
   MOG_KEKKAI::BOUNDED_FIELD[$game_temp.kekkai[1]] rescue nil
  end

  #--------------------------------------------------------------------------
  # ● Kekkai Effect
  #--------------------------------------------------------------------------
  def kekkai_effect
   return if !SceneManager.scene_is?(Scene_Battle)
   return if bounded_effect == nil
   index = 0
   for i in $game_party.members
      break if index >= $game_party.max_battle_members
      i.hp = 1 if bounded_effect[1] == 4 and i.hp > 1
      i.mp = 0 if bounded_effect[1] == 5
      index += 1
   end
  end

  #--------------------------------------------------------------------------
  # ● Command 311
  #--------------------------------------------------------------------------
  alias mog_kekkai_command_311 command_311
  def command_311
   mog_kekkai_command_311
   kekkai_effect
  end

  #--------------------------------------------------------------------------
  # ● Command 312
  #--------------------------------------------------------------------------
  alias mog_kekkai_command_312 command_312
  def command_312
   mog_kekkai_command_312
   kekkai_effect
  end

  #--------------------------------------------------------------------------
  # ● Command 314
  #--------------------------------------------------------------------------
  alias mog_kekkai_command_314 command_314
  def command_314
   mog_kekkai_command_314
   kekkai_effect
  end

end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base

  #--------------------------------------------------------------------------
  # ● Use Item
  #--------------------------------------------------------------------------
  alias mog_kekkai_use_item use_item
  def use_item
   check_kekkai_effect
   mog_kekkai_use_item
  end

  #--------------------------------------------------------------------------
  # ● Check Kekkai Effect
  #--------------------------------------------------------------------------
  def check_kekkai_effect
   return if @subject.is_a?(Game_Actor)
   skill = @subject.current_action.item
   if skill.note =~ /<Kekkai = (\d+)>/i
      id = $1.to_i
      id = nil if id < 1
      $game_temp.kekkai = [true,id]
   end
  end

end

#==============================================================================
# ■ BattleManager
#==============================================================================
class << BattleManager

  #--------------------------------------------------------------------------
  # ● Init Members
  #--------------------------------------------------------------------------
  alias mog_kekkai_init_members init_members
  def init_members
   $game_temp.battle_end = false
   mog_kekkai_init_members
  end

  #--------------------------------------------------------------------------
  # ● Process Victory
  #--------------------------------------------------------------------------
  alias mog_kekkai_process_victory process_victory
  def process_victory
   $game_temp.battle_end = true
   mog_kekkai_process_victory
  end

  #--------------------------------------------------------------------------
  # ● Process Abort
  #--------------------------------------------------------------------------
  alias mog_kekkai_process_abort process_abort
  def process_abort
   $game_temp.battle_end = true
   mog_kekkai_process_abort
  end

  #--------------------------------------------------------------------------
  # ● Process Defeat
  #--------------------------------------------------------------------------
  alias mog_kekkai_process_defeat process_defeat
  def process_defeat
   $game_temp.battle_end = true
   mog_kekkai_process_defeat
  end

end

#==============================================================================
# ■ Window Base
#==============================================================================
class Window_Base < Window

  #--------------------------------------------------------------------------
  # ● Bounded Effect
  #--------------------------------------------------------------------------
  def bounded_effect
   MOG_KEKKAI::BOUNDED_FIELD[$game_temp.kekkai[1]] rescue nil
  end

end

#==============================================================================
# ■ Window ActorCommand
#==============================================================================
class Window_ActorCommand < Window_Command

  #--------------------------------------------------------------------------
  # ● Make Command List
  #--------------------------------------------------------------------------
  alias mog_kekkai_make_command_list make_command_list
  def make_command_list
   return if kekkai_enabled?
   mog_kekkai_make_command_list
  end

  #--------------------------------------------------------------------------
  # ● Kekkai Enabled?
  #--------------------------------------------------------------------------
  def kekkai_enabled?
   if bounded_effect != nil and (bounded_effect[1] == 8 or bounded_effect[1] == 9)
      if @actor != nil
         if bounded_effect[1] == 8
            add_attack_command
            add_item_command
         else
            add_guard_command
         end
      end
      return true
   end
   return false
  end

end

$mog_rgss3_kekkai = true[/pre]
这两个脚本的作用是什么，使用方法是什么？

tseyik · 发表于 2013-11-9 18:03:08

第一個是指定在戦鬥中的音响可以随機播放(在指定数個音响文件随機使同其中一個)

893299399 · 发表于 2013-11-9 18:22:04

tseyik 发表于 2013-11-9 18:03
第一個是指定在戦鬥中的音响可以随機播放(在指定数個音响文件随機使同其中一個) ...

那第二个是什么作用？

[已经过期] 这两个脚本的作用是什么？

加入我们，或者，欢迎回来。