Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3821 miembros registrados.
El último usuario registrado es MikeWasauski.

Nuestros miembros han publicado un total de 86311 mensajes en 12305 argumentos.

Agrandar una imagen vx ace

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker VX ACE Agrandar una imagen vx ace

Mensaje por DopellSerch el 2013-07-06, 20:00

Bueno, pues desde haceun tiempo estuve buscando una hud para 1 pj que sea bonitah pero..no pude encontrar xD una compatible e_e, por lo que decidi utilizar la Active Hud meter de MogHunter, pero necesito ayuda para agrandar la imagen de "Battle_Hud_Layout"
del script para poder utilizar esta:

====
Este es el script de la hud:
Código:
#==============================================================================
# +++ 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
===
La cosa es que el resultado final deberia ser algo asi:

Estaria muy agradecido de que me puedan ayudar enserio TT-TT
avatar
DopellSerch
Novato
Novato

0/3

Créditos 125

Gracias : 19

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.