AccueilAccueil  PortailPortail  RechercherRechercher  Dernières imagesDernières images  S'enregistrerS'enregistrer  ConnexionConnexion  



-35%
Le deal à ne pas rater :
-34% TV OLED Philips 17” (194cm) Ambilight, 120Hz, G-Sync, ...
1990 € 3049 €
Voir le deal

Partagez
 

 [VXAce] Problème de compatibilité

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
masato94
Poulet trizo Lv.3
Poulet trizo Lv.3
masato94


Masculin Age : 31
Inscrit le : 02/08/2010
Messages : 34

[VXAce] Problème de compatibilité Empty
MessageSujet: [VXAce] Problème de compatibilité   [VXAce] Problème de compatibilité Icon_minitimeVen 3 Mai 2013 - 15:49

Bonjour tout le monde, voilà comme indiqué dans le titre j'aimerais permettre la compatibilité de deux scripts, un système de combat SBS classique avec un script qui change l'apparence du menu (HUD)
, le système de combat est de Victor Sant : http://victorscripts.wordpress.com/rpg-maker-vx-ace/battle-scripts/animated-battle/
et le script d'HUD quant à lui est de Moghunter :
Code:
#==============================================================================
# +++ MOG - Advanced Battle Hud (v2.2) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com/
#==============================================================================
# Sistema de hud avançado de batalha.
#==============================================================================

#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 2.2 - Correção na prioridade da face.
# v 2.1 - Corrigido o Bug de não apresentar a animação de reviver.
# v 2.0 - Sprite de Face independente do sprite do battler, agora é possível
#         usar sprites do battlers sem apagar a imagem da face.
#       - Script do cursor independente do script da Hud.
# v 1.6 - Corrigido o erro quando o MP ou TP maximo é iguál a zero.
# v 1.5 - Corrigido a animação da face quando uma skill tem a função charge.
# v 1.4 - Corrigido o erro de crash randômico. (relativo a dispose de imagem.)
# v 1.3 - Script 100% independente do sistema de AT System.
#       - Correção da posição inicial da janela de Fuga.
#       - Correção da posição do cursor nos aliados quando a face está
#         desabilitada.
# v 1.2 - Corrigido a prioridade das condições.
# v 1.1 - Corrigido o glitch inicial da prioridade da face.
# v 1.0 - Primeiro lançamento.
#==============================================================================

#==============================================================================
# ■ - FACE ANIMADAS DOS PERSONAGENS - (Opcional)
#==============================================================================
# 1 - Grave as imagens das faces dos personagens na pasta.
#
# GRAPHICS/BATTLERS/
#
# 2 - Nomeie a imagem com o mesmo nome do personagem. (EG - Hertor.png)
# 3 - A largura da imagem deverá ser dividido por 5. (A escolha do tamanho
#     da face é livre desde que a lagura dividido pela altura seja igual a 5 )
#
#==============================================================================

#==============================================================================
# ■ BATTLE HUD SETTING
#==============================================================================
module MOG_BATTLE_HUD
  # Ativar Battlers dos personagens em faces, deixe desativado em caso de haver
  # outros scripts que usam battlers dos personagens em seu projeto.
  BATTLER_FACE_ENABLE = true
  #Definição geral da posição da HUD.
  HUD_POSITION = [5,315]
  #Definição da posição da face
  FACE_POSITION = [60,30]
  #Definição da posição do numero de HP.
  HP_NUMBER_POSITION = [85,28]
  #Definição da posição do medidor de HP.
  HP_METER_POSITION = [27,37]
  #Definição da posição do numero de MP.
  MP_NUMBER_POSITION = [101,46]
  #Definição da posição do medidor de MP.
  MP_METER_POSITION = [43,55]  
  #Definição da posição do numero de TP.
  TP_NUMBER_POSITION = [85,64]
  #Definição da posição do medidor de TP.
  TP_METER_POSITION = [27,73]  
 #Definição da posição das condições
  STATES_POSITION = [5,1]
  #Definição da posição do comando de batalha.
  COMMAND_POSITION = [0,-145]  
  #Definição da posição do espaço da HUD entre os membros do grupo.
  MEMBERS_SPACE = [136,0]
  #Definição da prioridade da HUD.
  BATTLE_HUD_Z = 0
  #Definição da velocidade de animação dos medidores.
  METER_FLOW_SPEED = 2
  #Ativa o layout mais limpo nas janelas de item e skill.
 ITEM_SKILL_WINDOWS_CLEAN_STYLE = true
  #Definição da opacidade das janelas.
  ITEM_SKILL_WINDOW_OPACITY = 0
end



#==============================================================================
# ■ Battle_Hud
#==============================================================================
class Battle_Hud
  include MOG_BATTLE_HUD
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------    
  def initialize(actor)
      dispose
      @actor = actor
      @x = HUD_POSITION[0] + (MEMBERS_SPACE[0] * @actor.index)
      @y = HUD_POSITION[1] + (MEMBERS_SPACE[1] * @actor.index)
      pre_cache
      create_layout
      create_hp_number
      create_hp_meter
      create_mp_number
      create_mp_meter
      create_tp_number
      create_tp_meter
      create_states
  end
  
  #--------------------------------------------------------------------------
  # ● Pre Cache
  #--------------------------------------------------------------------------      
  def pre_cache
      @number = Cache.system("Battle_Hud_Number")
      @number_cw = @number.width / 10
      @number_ch = @number.height / 4
      @meter = Cache.system("Battle_Hud_Meter")
      @meter_cw = @meter.width / 3
      @meter_ch = @meter.height / 3
      @icon = Cache.system("Iconset")
  end
  
  #--------------------------------------------------------------------------
  # ● Create Layout
  #--------------------------------------------------------------------------      
  def create_layout
      @layout = Sprite.new
      @layout.bitmap = Cache.system("Battle_Hud_Layout")
      @layout.z = BATTLE_HUD_Z
      @layout.x = @x
      @layout.y = @y
  end
  
  #--------------------------------------------------------------------------
  # ● Create HP Number
  #--------------------------------------------------------------------------        
  def create_hp_number
      @hp = @actor.hp
      @hp_old = @actor.hp
      @hp_ref = @hp_old
      @hp_refresh = false
      @hp_number = Sprite.new
      @hp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
      @hp_number.z = BATTLE_HUD_Z + 2
      @hp_number.x = @x + HP_NUMBER_POSITION[0]
      @hp_number.y = @y + HP_NUMBER_POSITION[1]
      refresh_hp_number
  end
  
  #--------------------------------------------------------------------------
  # ● Create HP Meter
  #--------------------------------------------------------------------------      
  def create_hp_meter
      @hp_meter = Sprite.new
      @hp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
      @hp_meter.z =  BATTLE_HUD_Z + 1
      @hp_meter.x = @x + HP_METER_POSITION[0]
      @hp_meter.y = @y + HP_METER_POSITION[1]
     @hp_flow = rand(@meter_cw * 2)
      @hp_width_old = @meter_cw * @actor.hp / @actor.mhp
     hp_flow_update
  end  
  
  #--------------------------------------------------------------------------
  # ● Hp Flow Update
  #--------------------------------------------------------------------------
  def hp_flow_update
      @hp_meter.bitmap.clear
      hp_width = @meter_cw * @actor.hp / @actor.mhp
      hp_src_rect = Rect.new(@hp_flow, 0,hp_width, @meter_ch)
      @hp_meter.bitmap.blt(0,0, @meter, hp_src_rect)
      @hp_flow += METER_FLOW_SPEED
      @hp_flow = 0 if @hp_flow >=  @meter_cw * 2      
  end
    
  #--------------------------------------------------------------------------
  # ● Execute Damage Flow
  #--------------------------------------------------------------------------
 def execute_damage_flow(hp_width)
     n = (@hp_width_old - hp_width).abs * 3 / 100
     damage_flow = [[n, 2].min,0.5].max
     @hp_width_old -= damage_flow        
    @hp_width_old = hp_width if @hp_width_old < hp_width
    src_rect_old = Rect.new(@hp_flow, @meter_ch * 3,@hp_width_old, @meter_ch)
     @hp_meter.bitmap.blt(0,0, @meter, src_rect_old)      
 end  
 
 #--------------------------------------------------------------------------
  # ● Update HP Number
  #--------------------------------------------------------------------------      
  def update_hp_number
      @hp_refresh = true
      n =  2 * (@actor.hp - @hp_old).abs / 100
      hp_ref = [[n, 100].min,1].max
      if @hp_old < @actor.hp
          @hp += hp_ref    
         if @hp >= @actor.hp
             @hp_old = @actor.hp
            @hp = @actor.hp  
            @hp_ref = 0
          end              
        elsif @hp_old > @actor.hp  
          @hp -= hp_ref                
           if @hp <= @actor.hp
              @hp_old = @actor.hp
             @hp = @actor.hp  
             @hp_ref = 0
           end            
        end      
    
  end  
  
  #--------------------------------------------------------------------------
  # ● Refresh HP Number
  #--------------------------------------------------------------------------      
  def refresh_hp_number
      @hp_number.bitmap.clear
      number_value = @hp.abs.to_s.split(//)
      hp_color = @hp < @actor.mhp * 30 / 100 ? @number_ch : 0
      center_x = 0
      for r in 0..number_value.size - 1        
        number_value_abs = number_value[r].to_i
        src_rect = Rect.new(@number_cw * number_value_abs, hp_color, @number_cw, @number_ch)
         @hp_number.bitmap.blt((@number_cw + 1) *  r, 0, @number, src_rect)
        center_x += 1
      end
      @hp_number.x = @x + HP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
      @hp_refresh = false if @hp == @actor.hp      
  end  
  
  #--------------------------------------------------------------------------
  # ● Create MP Number
  #--------------------------------------------------------------------------        
  def create_mp_number
      @mp = @actor.mp
      @mp_old = @actor.mp
      @mp_ref = @mp_old
      @mp_refresh = false
      @mp_number = Sprite.new
      @mp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
      @mp_number.z = BATTLE_HUD_Z + 2
      @mp_number.x = @x + MP_NUMBER_POSITION[0]
      @mp_number.y = @y + MP_NUMBER_POSITION[1]
      refresh_mp_number
  end
  
  #--------------------------------------------------------------------------
  # ● Create MP Meter
  #--------------------------------------------------------------------------      
  def create_mp_meter
      @mp_meter = Sprite.new
      @mp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
      @mp_meter.z =  BATTLE_HUD_Z + 1
      @mp_meter.x = @x + MP_METER_POSITION[0]
      @mp_meter.y = @y + MP_METER_POSITION[1]
     @mp_flow = rand(@meter_cw * 2)
      @mp_width_old = @meter_cw * @actor.mp / @actor.mmp rescue 0
      mp_flow_update
  end  
  
  #--------------------------------------------------------------------------
  # ● Mp Flow Update
  #--------------------------------------------------------------------------
  def mp_flow_update
      return if @actor.mmp == 0
      @mp_meter.bitmap.clear
      mp_width = @meter_cw * @actor.mp / @actor.mmp rescue 0
      src_rect = Rect.new(@mp_flow, @meter_ch,mp_width, @meter_ch)
      @mp_meter.bitmap.blt(0,0, @meter, src_rect)
      @mp_flow += METER_FLOW_SPEED
      @mp_flow = 0 if @mp_flow >=  @meter_cw * 2      
    end
    
  #--------------------------------------------------------------------------
  # ● Update MP Number
  #--------------------------------------------------------------------------      
  def update_mp_number
      @mp_refresh = true
      n =  2 * (@actor.mp - @mp_old).abs / 100
      mp_ref = [[n, 100].min,1].max
      if @mp_old < @actor.mp
          @mp += mp_ref    
         if @mp >= @actor.mp
             @mp_old = @actor.mp
            @mp = @actor.mp  
            @mp_ref = 0
          end              
        elsif @mp_old > @actor.mp  
          @mp -= mp_ref                
           if @mp <= @actor.mp
              @mp_old = @actor.mp
             @mp = @actor.mp  
             @mp_ref = 0
           end            
        end          
  end  
  
  #--------------------------------------------------------------------------
  # ● Refresh MP Number
  #--------------------------------------------------------------------------      
  def refresh_mp_number
      @mp_number.bitmap.clear
      number_value = @mp.abs.to_s.split(//)
      center_x = 0
      for r in 0..number_value.size - 1        
        number_value_abs = number_value[r].to_i
        src_rect = Rect.new(@number_cw * number_value_abs, @number_ch * 2, @number_cw, @number_ch)
         @mp_number.bitmap.blt((@number_cw + 1) *  r, 0, @number, src_rect)
        center_x += 1
      end
      @mp_number.x = @x + MP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
      @mp_refresh = false if @mp == @actor.mp      
  end  
  
  #--------------------------------------------------------------------------
  # ● Create TP Number
  #--------------------------------------------------------------------------        
  def create_tp_number
      @tp = @actor.tp
      @tp_old = @actor.tp
      @tp_ref = @tp_old
      @tp_refresh = false
      @tp_number = Sprite.new
      @tp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
      @tp_number.z = BATTLE_HUD_Z + 2
      @tp_number.x = @x + TP_NUMBER_POSITION[0]
      @tp_number.y = @y + TP_NUMBER_POSITION[1]
      refresh_tp_number
  end
  
  #--------------------------------------------------------------------------
  # ● Create TP Meter
  #--------------------------------------------------------------------------      
  def create_tp_meter
      @tp_meter = Sprite.new
      @tp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
      @tp_meter.z =  BATTLE_HUD_Z + 1
      @tp_meter.x = @x + TP_METER_POSITION[0]
      @tp_meter.y = @y + TP_METER_POSITION[1]
     @tp_flow = rand(@meter_cw * 2)
      @tp_width_old = @meter_cw * @actor.tp / @actor.max_tp rescue 0
     tp_flow_update
  end  
  
  #--------------------------------------------------------------------------
  # ● TP Flow Update
  #--------------------------------------------------------------------------
  def tp_flow_update
      return if @actor.max_tp == 0
      @tp_meter.bitmap.clear
      tp_width = @meter_cw * @actor.tp / @actor.max_tp rescue 0
      src_rect = Rect.new(@tp_flow, @meter_ch * 2,tp_width, @meter_ch)
      @tp_meter.bitmap.blt(0,0, @meter, src_rect)
      @tp_flow += METER_FLOW_SPEED
      @tp_flow = 0 if @tp_flow >=  @meter_cw * 2      
  end
    
  #--------------------------------------------------------------------------
  # ● Update TP Number
  #--------------------------------------------------------------------------      
  def update_tp_number
      @tp_refresh = true
      n =  2 * (@actor.tp - @tp_old).abs / 100
      tp_ref = [[n, 100].min,1].max
      if @tp_old < @actor.tp
          @tp += tp_ref    
         if @tp >= @actor.tp
             @tp_old = @actor.tp
            @tp = @actor.tp  
            @tp_ref = 0
          end              
        elsif @tp_old > @actor.tp  
          @tp -= tp_ref                
           if @tp <= @actor.tp
              @tp_old = @actor.tp
             @tp = @actor.tp  
             @tp_ref = 0
           end          
        end            
  end      
    
  #--------------------------------------------------------------------------
  # ● Refresh TP Number
  #--------------------------------------------------------------------------      
  def refresh_tp_number
      @tp_number.bitmap.clear
      number_value = @tp.truncate.to_s.split(//)
      center_x = 0
      for r in 0..number_value.size - 1        
         number_value_abs = number_value[r].to_i
        src_rect = Rect.new(@number_cw * number_value_abs, @number_ch * 3, @number_cw, @number_ch)
         @tp_number.bitmap.blt((@number_cw + 1) *  r, 0, @number, src_rect)
        center_x += 1
      end
      @tp_number.x = @x + TP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
      @tp_refresh = false if @tp == @actor.tp
  end    
  
  #--------------------------------------------------------------------------
  # ● Create_States
  #--------------------------------------------------------------------------      
  def create_states
      refresh_states
      @status = Sprite.new
      @status.bitmap = Bitmap.new(24,24)
      @status.x = @x + STATES_POSITION[0]
      @status.y = @y + STATES_POSITION[1]      
      @status_flow = -24
      @states_speed = 50
      @status.z = BATTLE_HUD_Z + 2
      @old_states = @actor.states
      flow_states
  end  
  
  #--------------------------------------------------------------------------
  # ● Flow_Status
  #--------------------------------------------------------------------------          
  def flow_states
      return if @actor.states.size == 0 and !@status.visible
      @states_speed = 0
      @status.bitmap.clear
      src_rect = Rect.new(@status_flow,0, 24,24)
      @status.bitmap.blt(0,0, @actor_status, src_rect)
      @status.visible = @actor.states.size == 0 ? false : true
      @status_flow += 1
      @status_flow = -24 if @status_flow >= @states_size - 24
  end    
  
  #--------------------------------------------------------------------------
  # ● Refresh States
  #--------------------------------------------------------------------------        
  def refresh_states
      refresh_icon if @icon == nil or @icon.disposed?
      @old_states = @actor.states
      if @actor_status != nil
         @actor_status.dispose
         @actor_status = nil
      end
      @states_size = @actor.states.size > 0 ? (48 * @actor.states.size) : 24
     @actor_status = Bitmap.new(@states_size,24)
      index = 0
      for i in  @actor.states
         rect = Rect.new(i.icon_index % 16 * 24, i.icon_index / 16 * 24, 24, 24)
         @actor_status.blt(48 * index , 0, @icon, rect)
         index += 1
      end
  end  
  
  #--------------------------------------------------------------------------
  # ● Refresh Icon
  #--------------------------------------------------------------------------      
  def refresh_icon      
      if @icon != nil
         if !@icon.disposed?
             @icon.dispose
         end
         @icon = nil
      end  
      @icon = Cache.system("Iconset")
  end
  
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------    
  def dispose
      return if @meter == nil
      @meter.dispose
      @meter = nil
      @number.dispose
      if @icon != nil
         if !@icon.disposed?
             @icon.dispose
         end
         @icon = nil
      end    
     @layout.bitmap.dispose
      @layout.dispose
      @hp_number.bitmap.dispose
      @hp_number.dispose
      @hp_meter.bitmap.dispose
      @hp_meter.dispose
      @mp_number.bitmap.dispose
      @mp_number.dispose
      @mp_meter.bitmap.dispose
      @mp_meter.dispose      
      @tp_number.bitmap.dispose
      @tp_number.dispose
      @tp_meter.bitmap.dispose
      @tp_meter.dispose
      @status.bitmap.dispose
      @status.dispose
      if @actor_status != nil
         @actor_status.dispose
         @actor_status = nil
      end        
  end
  
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------    
  def update
      return if @meter == nil
      update_hp_number if @hp_old != @actor.hp
      refresh_hp_number if @hp_refresh
      update_mp_number if @mp_old != @actor.mp
      refresh_mp_number if @mp_refresh
      update_tp_number if @tp_old != @actor.tp
      refresh_tp_number if @tp_refresh
      refresh_states if @old_states != @actor.states
      hp_flow_update
      tp_flow_update
      mp_flow_update
      flow_states
  end
  
end

#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
  
  attr_accessor :battler_hud
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------    
  alias mog_adv_battle_hud_initialize initialize
  def initialize      
     @battler_hud = false
      mog_adv_battle_hud_initialize
  end  
  
end

#==============================================================================
# ■ Spriteset Battle
#==============================================================================
class Spriteset_Battle
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------  
  alias mog_battle_hud_initialize initialize
  def initialize
      mog_battle_hud_initialize
      create_battle_hud      
  end
  
  #--------------------------------------------------------------------------
  # ● Create Battle Hud
  #--------------------------------------------------------------------------    
  def create_battle_hud
      dispose_battle_hud
      @battle_hud = []      
      for i in $game_party.members
          @battle_hud.push(Battle_Hud.new(i))
      end
  end
  
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------      
  alias mog_battle_hud_dispose dispose
  def dispose
      mog_battle_hud_dispose
      dispose_battle_hud
  end  
  
  #--------------------------------------------------------------------------
  # ● Dispose Battle Hud
  #--------------------------------------------------------------------------        
  def dispose_battle_hud
      return if @battle_hud == nil
      @battle_hud.each {|sprite| sprite.dispose }
      @battle_hud.clear
      @battle_hud = nil
  end
  
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------        
  alias mog_battle_hud_update update
  def update
      mog_battle_hud_update
      update_battle_hud
  end
  
  #--------------------------------------------------------------------------
  # ● Update Battle Hud
  #--------------------------------------------------------------------------          
  def update_battle_hud
      return if @battle_hud == nil
      @battle_hud.each {|sprite| sprite.update }
  end
    
end

#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  include MOG_BATTLE_HUD
  
  attr_accessor :hud_x
   attr_accessor :hud_y

  #--------------------------------------------------------------------------
  # ● HUD X
  #--------------------------------------------------------------------------    
 def hud_x
      return HUD_POSITION[0] + (MEMBERS_SPACE[0] * index)
  end
  
  #--------------------------------------------------------------------------
  # ● HUD Y
  #--------------------------------------------------------------------------    
  def hud_y
      return HUD_POSITION[1] + (MEMBERS_SPACE[1] * index)
  end
    
end  

#==============================================================================
# ■ Scene Battle
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # ● Create Party Command Window
  #--------------------------------------------------------------------------    
  alias mog_battle_hud_create_party_command_window create_party_command_window
  def create_party_command_window
      mog_battle_hud_create_party_command_window
      set_party_window_position
 end  
  
  #--------------------------------------------------------------------------
  # ● Set Party Window Position
  #--------------------------------------------------------------------------      
  def set_party_window_position
      @party_command_window.viewport = nil  
      return if $mog_rgss3_at_system != nil
      a_index = []
      for actor in $game_party.alive_members
          a_index = [actor.hud_x, actor.hud_y]
          break
      end
      return if a_index.empty?
     @party_command_window.x = MOG_BATTLE_HUD::COMMAND_POSITION[0] + a_index[0]
      @party_command_window.y = MOG_BATTLE_HUD::COMMAND_POSITION[1] + a_index[1]      
  end  
  
  #--------------------------------------------------------------------------
  # ● Set Party Window Position
  #--------------------------------------------------------------------------        
  alias mog_battle_hud_start_party_command_selection start_party_command_selection
  def start_party_command_selection
      set_party_window_position
     mog_battle_hud_start_party_command_selection
  end  
  
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------  
  alias mog_battle_hud_update_basic update_basic
  def update_basic
      mog_battle_hud_update_basic
      update_command_window_visible
  end  
  
  #--------------------------------------------------------------------------
  # ● Update Command Window Visible
  #--------------------------------------------------------------------------    
  def update_command_window_visible
      @status_window.visible = @status_window.active ? true : false
      @actor_command_window.visible = @actor_command_window.active ? true : false
      @skill_window.visible = @skill_window.active ? true : false
      @item_window.visible = @item_window.active ? true : false      
  end
  
  #--------------------------------------------------------------------------
  # ● Start Actor Command Selection
  #--------------------------------------------------------------------------    
  alias mog_battle_hud_start_actor_command_selection start_actor_command_selection
  def start_actor_command_selection
      mog_battle_hud_start_actor_command_selection
      @actor_command_window.viewport = nil
      @actor_command_window.x = MOG_BATTLE_HUD::COMMAND_POSITION[0] + $game_party.members[BattleManager.actor.index].hud_x
      @actor_command_window.y = MOG_BATTLE_HUD::COMMAND_POSITION[1] + $game_party.members[BattleManager.actor.index].hud_y
      @party_command_window.x = @actor_command_window.x
      @party_command_window.y = @actor_command_window.y  
  end  

end

#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  include MOG_BATTLE_HUD
  
  attr_accessor :battler_face
  attr_accessor :battler_face_name
  attr_accessor :screen_x
  attr_accessor :screen_y
  attr_accessor :screen_z
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  alias mog_battle_hud_initialize setup
  def setup(actor_id)
      mog_battle_hud_initialize(actor_id)
      battler_sprite_setup
  end  
    
  #--------------------------------------------------------------------------
  # ● Battler Sprite Setup
  #--------------------------------------------------------------------------  
  def battler_sprite_setup
      @battler_face = [0,0,0]
      @battler_face_name = @name + "_Face"
  end

  if BATTLER_FACE_ENABLE
  #--------------------------------------------------------------------------
  # ● Use Sprite?
  #--------------------------------------------------------------------------
  def use_sprite?
      return true
  end
  end
  
end

#==============================================================================
# ■ Sprite_Battler
#==============================================================================
class Sprite_Battler < Sprite_Base
  include MOG_BATTLE_HUD
  
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------    
  alias mog_battler_face_dispose dispose
  def dispose
      mog_battler_face_dispose
      dispose_battler_face
  end  
  
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------  
 alias mog_battler_face_update update
  def update
      refresh_face_battler
      mog_battler_face_update
      update_battler_face
  end
    
  #--------------------------------------------------------------------------
  # ● Refresh Face Battler
  #--------------------------------------------------------------------------    
 def refresh_face_battler
      return if @face_sprite != nil
     return if @battler == nil
     return if @battler.is_a?(Game_Enemy)
      setup_battler_screen if @battler.screen_x == nil or $game_system.battler_hud
      @face_sprite = Battler_Face_Sprite.new(self.viewport, @battler)
  end  
  
  #--------------------------------------------------------------------------
  # ● Setup Battler Screen
  #--------------------------------------------------------------------------      
 def setup_battler_screen
      $game_system.battler_hud = true
      @battler.screen_x = FACE_POSITION[0] + HUD_POSITION[0] + (MEMBERS_SPACE[0] * @battler.index)
      @battler.screen_y = FACE_POSITION[1] + HUD_POSITION[1] + (MEMBERS_SPACE[1] * @battler.index)
      @battler.screen_z = 103 if @battler.screen_z == nil
  end  
  
  #--------------------------------------------------------------------------
  # ● Dispose Battler Face
  #--------------------------------------------------------------------------      
 def dispose_battler_face
      return if @face_sprite == nil
     @face_sprite.dispose  
  end
  
  #--------------------------------------------------------------------------
  # ● Update Battler Face
  #--------------------------------------------------------------------------      
 def update_battler_face
      return if @face_sprite == nil
      @face_sprite.update_actor_battler
  end  
  
  #--------------------------------------------------------------------------
  # ● Update Posiion
  #--------------------------------------------------------------------------        
 alias mog_battler_face_update_position update_position
  def update_position
      mog_battler_face_update_position
      update_face_z
  end  
  
  #--------------------------------------------------------------------------
  # ● Update Face Z
  #--------------------------------------------------------------------------        
 def update_face_z
      return if @face_sprite == nil
      @face_sprite.update_face_z(self.z)
  end

  #--------------------------------------------------------------------------
  # ● Update Collapse
  #--------------------------------------------------------------------------                          
   alias mog_battle_hud_update_collapse update_collapse
   def update_collapse
       if face_can_cancel_method?
         self.opacity = 255
         self.visible = true
         return
      end
       mog_battle_hud_update_collapse
   end  
  
 #--------------------------------------------------------------------------
  # ● Update Instant Collapse
  #--------------------------------------------------------------------------                            
  alias mog_battle_hud_update_instant_collapse update_instant_collapse
   def update_instant_collapse
      if face_can_cancel_method?
         self.opacity = 255
         self.visible = true
         return
      end
       mog_battle_hud_update_instant_collapse
   end  
  
  #--------------------------------------------------------------------------
  # ● Init Visibility
  #--------------------------------------------------------------------------                                
  alias mog_battle_face_init_visibility init_visibility
  def init_visibility
      if face_can_cancel_method?
         self.opacity = 255
         self.visible = true
         return
      end
      mog_battle_face_init_visibility
  end
  
 #--------------------------------------------------------------------------
  # ● Face Can Cancel Method
  #--------------------------------------------------------------------------                                  
  def face_can_cancel_method?
      return false if !BATTLER_FACE_ENABLE
      return false if @battler.is_a?(Game_Enemy)
      return false if !$game_system.battler_hud
      return true
  end  
  
end

#==============================================================================
# ■ Battler Face Sprite
#==============================================================================
class Battler_Face_Sprite < Sprite
  include MOG_BATTLE_HUD
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------                
   def initialize(viewport = nil,battler)
       super(viewport)
       @battler = battler
       @f_im = Cache.battler(@battler.battler_face_name, 0)
       @f_cw = @f_im.width / 5
       @f_ch = @f_im.height
       self.bitmap = Bitmap.new(@f_cw,@f_ch)
       x = -(@f_cw / 2) + FACE_POSITION[0] + HUD_POSITION[0] + (MEMBERS_SPACE[0] * @battler.index)
       y = -@f_ch + FACE_POSITION[1] + HUD_POSITION[1] + (MEMBERS_SPACE[1] * @battler.index)
       @org_pos = [x,y]
       @battler.battler_face = [0,0,0]
       @battler_visible = true
       @low_hp = @battler.mhp * 30 / 100
       @old_face_index = 0
       self.z = @battler.screen_z
       make_face(true)
   end
  
 #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------                      
 def dispose
      super
      dispose_battler_face_sprite
 end    

  #--------------------------------------------------------------------------
  # ● Dispose Battler Face Sprite
  #--------------------------------------------------------------------------                    
  def dispose_battler_face_sprite
      self.bitmap.dispose
       @f_im.dispose
  end  
  
 #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------  
  def update_face_sprite(battler)
      @battler = battler
      update_face_reset_time
      update_face_effect
  end
  
 #--------------------------------------------------------------------------
  # ● Face Base Setting
  #--------------------------------------------------------------------------                
 def face_base_setting
     self.x = @org_pos[0]
      self.y = @org_pos[1]
      self.zoom_x = 1
      self.zoom_y = 1
      self.mirror = false  
 end
  
  #--------------------------------------------------------------------------
  # ● Check Base Face
  #--------------------------------------------------------------------------              
   def check_base_face(reset)
       face_base_setting
       return if @battler.battler_face[2] > 0
      @battler.battler_face = [0,0,0] if reset and @battler.battler_face[1] != 2  
       @battler.battler_face[0] = 3 if @battler.hp < @low_hp
       @battler.battler_face[0] = 4 if @battler.hp == 0
   end  
  
 #--------------------------------------------------------------------------
  # ● Make Face
  #--------------------------------------------------------------------------              
   def make_face(reset = false)
       self.bitmap.clear
       check_base_face(reset)
       src_rect_back = Rect.new(@f_cw * @battler.battler_face[0], 0, @f_cw, @f_ch)
       self.bitmap.blt(0,0, @f_im, src_rect_back)
       @old_face_index = @battler.battler_face[0]
  end  

  #--------------------------------------------------------------------------
  # ● Update Actor Battler
  #--------------------------------------------------------------------------          
  def update_actor_battler
       return if self.bitmap == nil
       update_face_effect
       update_face_reset_time
       make_face if @old_face_index != @battler.battler_face[0]              
   end
  
 #--------------------------------------------------------------------------
  # ● Update Face Z
  #--------------------------------------------------------------------------                
 def update_face_z(value)
      self.z = value + 2
  end  
  
 #--------------------------------------------------------------------------
  # ● Update Face Reset Time
 #--------------------------------------------------------------------------              
   def update_face_reset_time
       return if @battler.battler_face[2] == 0
       @battler.battler_face[2] -= 1
       if @battler.battler_face[2] == 0 or
        (@battler.hp < @low_hp and @battler.battler_face[0] == 0)
          make_face(true)
      end  
  end

  #--------------------------------------------------------------------------
  # ● Update Face Effect
  #--------------------------------------------------------------------------                
  def update_face_effect
       return if @battler.battler_face[2] == 0
       case @battler.battler_face[1]
          when 0
             face_damage
          when 1..2
             face_heal
          when 3
             face_action
       end
   end  
  
 #--------------------------------------------------------------------------
  # ● Face Damage
  #--------------------------------------------------------------------------                    
   def face_damage
       self.x = (@org_pos[0] - (@battler.battler_face[2] /2)) + rand(@battler.battler_face[2])
   end  
  
 #--------------------------------------------------------------------------
  # ● Face Heal
  #--------------------------------------------------------------------------                    
   def face_heal
       case  @battler.battler_face[2]
         when 20..40
             self.zoom_x += 0.01
             self.zoom_y = self.zoom_x
         when 0..20
             self.zoom_x -= 0.01
             self.zoom_y = self.zoom_x      
      end
   end    
 
 #--------------------------------------------------------------------------
  # ● Face Action
  #--------------------------------------------------------------------------                    
   def face_action
       case  @battler.battler_face[2]
         when 25..50
             self.zoom_x += 0.01
            self.zoom_y = self.zoom_x
             self.mirror = true
         when 0..25
             self.zoom_x -= 0.01
             self.zoom_y = self.zoom_x
             self.mirror = false
       end
       self.zoom_x = self.zoom_x > 1.5 ? self.zoom_x = 1.5 : self.zoom_x < 1 ? 1 : self.zoom_x
       self.zoom_y = self.zoom_y > 1.5 ? self.zoom_y = 1.5 : self.zoom_y < 1 ? 1 : self.zoom_y
   end
      
 end
 
#==============================================================================
# ■ Battle Manager
#==============================================================================
class << BattleManager
  
  #--------------------------------------------------------------------------
  # ● Battle End
  #--------------------------------------------------------------------------                    
  alias mog_battle_hud_battle_process_victory process_victory
  def process_victory
      execute_face_effect    
      mog_battle_hud_battle_process_victory
  end
  
  #--------------------------------------------------------------------------
  # ● Prepare
  #--------------------------------------------------------------------------                  
  def execute_face_effect
      for i in $game_party.members
          if i.hp > 0
             i.battler_face = [1,2,40]        
         end  
      end  
  end
  
end

#==============================================================================
# ■ Game Action
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # ● Show Animations
  #--------------------------------------------------------------------------    
 alias mog_battle_hud_show_animation show_animation
  def show_animation(targets, animation_id)
      make_face_action_battle
     mog_battle_hud_show_animation(targets, animation_id)
  end
  
  #--------------------------------------------------------------------------
  # ● Make Face Action
  #--------------------------------------------------------------------------                  
  def make_face_action_battle
      return if !@subject.is_a?(Game_Actor)
     @subject.battler_face = [2,3,50]
  end    
  
end  

#==============================================================================
# ■ Game Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
  
  #--------------------------------------------------------------------------
  # ● Item Apply
  #--------------------------------------------------------------------------                
  alias mog_battle_hud_item_apply item_apply
 def item_apply(user, item)
      old_hp = self.hp
      old_mp = self.mp
      mog_battle_hud_item_apply(user, item)
      check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
  end
  
  #--------------------------------------------------------------------------
  # ● Check Face Effect
  #--------------------------------------------------------------------------  
  def check_face_effect(old_hp,old_mp)
      if self.hp > old_hp or self.mp > old_mp
         self.battler_face = [1,1,40]
      elsif self.hp < old_hp
         self.battler_face = [3,0,40]
      end  
  end  
  
  #--------------------------------------------------------------------------
  # ● Added New State
  #--------------------------------------------------------------------------  
  alias mog_battle_hud_add_new_state add_new_state
  def add_new_state(state_id)
      mog_battle_hud_add_new_state(state_id)
      if self.is_a?(Game_Actor)
         self.battler_face = [1,1,40] if $data_states[state_id].note =~ /<Good State>/
         self.battler_face = [3,0,40] if $data_states[state_id].note =~ /<Bad State>/
      end  
 end    
  
  #--------------------------------------------------------------------------
  # ● Regenerate HP
  #--------------------------------------------------------------------------
  alias mog_battle_hud_regenerate_hp regenerate_hp
  def regenerate_hp
      old_hp = self.hp
      old_mp = self.mp    
      mog_battle_hud_regenerate_hp
      check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
  end

  #--------------------------------------------------------------------------
  # ● Regenerate MP
  #--------------------------------------------------------------------------
  alias mog_battle_hud_regenerate_mp regenerate_mp
  def regenerate_mp
      old_hp = self.hp
      old_mp = self.mp    
      mog_battle_hud_regenerate_mp
      check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
  end  

  #--------------------------------------------------------------------------
  # ● Can Check Face Effect
  #--------------------------------------------------------------------------                  
  def can_check_face_effect?(old_hp,old_mp)
      return false if self.is_a?(Game_Enemy)
      return true if old_hp != self.hp
      return true if old_mp != self.mp
      return false
  end
  
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # ● Invoke Counter Attack
  #--------------------------------------------------------------------------        
  alias mog_battle_hud_invoke_counter_attack invoke_counter_attack
  def invoke_counter_attack(target, item)
      mog_battle_hud_invoke_counter_attack(target, item)
      if target.is_a?(Game_Actor) and target.battler_face[0] != 2        
         target.battler_face = [2,3,50]
      end  
  end  
  
  #--------------------------------------------------------------------------
  # ● Invoke Magic Reflection
  #--------------------------------------------------------------------------        
  alias mog_battle_hud_invoke_magic_reflection invoke_magic_reflection
  def invoke_magic_reflection(target, item)
      mog_battle_hud_invoke_magic_reflection(target, item)
      if target.is_a?(Game_Actor) and target.battler_face[0] != 2        
         target.battler_face = [2,3,50]
      end  
  end    
  
end

#==============================================================================
# ■ Scene Battle
#==============================================================================  
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # ● select_enemy_selection
  #--------------------------------------------------------------------------
  alias mog_battle_cursor_select_enemy_selection select_enemy_selection
  def select_enemy_selection
      mog_battle_cursor_select_enemy_selection
      if $mog_rgss3_battle_cursor != nil
        @enemy_window.visible = false
         @info_viewport.rect.width = 0
      end  
 end
  
  #--------------------------------------------------------------------------
  # ● select_enemy_selection
  #--------------------------------------------------------------------------
  alias mog_battle_cursor_select_actor_selection select_actor_selection
  def select_actor_selection
      mog_battle_cursor_select_actor_selection
      if $mog_rgss3_battle_cursor != nil
         @actor_window.visible = false
         @info_viewport.rect.width = 0
      end  
 end
  
end  

$mog_rgss3_battle_hud = true
Le problème étant que lorsque je lance un combat avec les deux scripts actifs, j'ai l'erreur "Script Victor Engine - Animated Battle ligne 5993 : NoMethodErrorOccured undefined method '+' for nil:NilClass"
La ligne en question est : self.x  = position[Mad] + adjust_x
pas très parlant hein ^^'
Merci d'avance à tout ceux qui accepteront de m'aider Smile
Revenir en haut Aller en bas
 

[VXAce] Problème de compatibilité

Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1

 Sujets similaires

-
» Problème de compatibilité
» [RESOLU]Problème de compatibilité de script
» [VXAce] Conversion du script Credits Vx=>VxAce
» Problème de script : compatibilité ? [Resolu]
» Gros problème de compatibilité avec un script

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
RPG Maker VX :: Entraide :: Scripts :: Requêtes-
Créer un forum | ©phpBB | Forum gratuit d'entraide | Signaler un abus | Cookies | Forum gratuit