¡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
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Últimos temas
» Necesito Script
por Elian84 Hoy a las 04:44

» Holaaa a tod@s!!!
por chronoMxx Hoy a las 03:41

» [AYUDA]Hootshot de moghunter
por Rudy_kinneas Hoy a las 01:06

» El poder oculto (Segunda entrega)
por alex1633 Ayer a las 23:18

» Tutorial Interactivo [Uso de interruptores]
por alex1633 Ayer a las 19:39

» Hola mucho gusto
por Hk Diamond Ayer a las 13:49

» SoraDeathss se presenta!
por chronoMxx Ayer a las 07:50

» {AYUDA}Blizz-ABS Script
por chronoMxx Ayer a las 06:45

» las cosas como son...
por Bleuw Ayer a las 04:18

» Busco artistas graficos para proyecto serio
por Rudy_kinneas 2016-12-02, 20:52

Afiliados
Estadísticas
Tenemos 3381 miembros registrados.
El último usuario registrado es Hk Diamond.

Nuestros miembros han publicado un total de 79767 mensajes en 11247 argumentos.
Navega con Google Chrome
[DESCARGA]

Agrandar una imagen vx ace

 :: RPG Maker :: Ayuda RPG

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

DopellSerch
Novato
Novato

0/3

Créditos 125

Gracias : 19

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Ayuda RPG

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