Propriété d'une image en script (Résolu)

module PLAYER_HUD
                  Toggle = true
                  Xcoord = 270
                  Ycoord = 260
                  Zcoord = 49
end

module PLAYER_HUD
                  Toggle = true # Toggle's the hud
                  Xcoord = 270 # Position
                  Ycoord = 260
end
class Window_Base < Window

def draw_health(i=0,x=0,y=0)
  #=============================================================#
  # Small formula determines which picture should be displayed. #
  #=============================================================# 
  q = (i * 10) # Total amount of pictures needed.
  w = ($game_party.actors[0].maxhp.to_f / q.to_f) # Hp per picture.
  for c in (1..q)
    a = (w * c) # Top hp range
    b = (w * c) - w # Low hp range
    if ($game_party.actors[0].hp > b && $game_party.actors[0].hp <= a)
      j = c
    end
  end

    # This is the siren effect. It is activated at low health and switches
    # the background graphic, making it appear to flash red.
    if $siren == 0
      if i > 0 && i < 10
        background =  RPG::Cache.picture("HUD/" + "Background-" + (i.to_s))
      else
        background = RPG::Cache.picture("HUD/" + "Background-EXT")
      end
    else
      if i > 0 && i < 10
        background =  RPG::Cache.picture("HUD/" + "Background-" + (i.to_s) + "-2")
      else
        background = RPG::Cache.picture("HUD/" + "Background-EXT-2")
      end
    end
   
    # This is the green health bar. The formula determins the ending number.
    # places pictures in intervals of 10 for each upgrade. Example:
    # No upgrade = Images: 1-10. First upgrade includes 1-20 (11-20 are new pics).
    # Look at pictures folder for a better understanding.
   
    if j != nil
      arc =  RPG::Cache.picture("HUD/Health/" + (j.to_s))
    else
      arc = nil
    end
   
    # Small red circle that flashes when low on health.
    if $alert > 0
      siren = RPG::Cache.picture("HUD/alert-" + $alert.to_s)
    else
      siren = RPG::Cache.picture("")
    end
   
    cw = background.width 
    ch = background.height
    src_rect = Rect.new(0, 0, cw, ch)   
    self.contents.blt(x, y, background, src_rect)
   
    if arc != nil
      self.contents.blt(x, y, arc, src_rect)
    else
    end   
   
    if $alert != nil
      self.contents.blt(x, y, siren, src_rect)
    else
    end
   
end

def draw_face(x, y)
  # Looks for the actors face named according to rmxp database
  # in folder pictures/HUD/
    name = $game_party.actors[0].name
    face = RPG::Cache.picture("HUD/" + name)
    cw = face.width 
    ch = face.height
    src_rect = Rect.new(0, 0, cw, ch)   
    self.contents.blt(x, y, face, src_rect)
end
 
def draw_hud(x=0,y=0,orn=0)
  health = case $game_party.actors[0].maxhp
  # Change HP numbers here
  when 10 then 1 # Max HP at upgrade 1
  when 20 then 2
  when 30 then 3
  when 40 then 4
  when 50 then 5
  when 60 then 6
  when 70 then 7
  when 80 then 8
  when 90 then 9
  when 100 then 10 # Max HP at upgrade 10# Max HP at upgrade 10
  else
    health = 11
  end
  draw_health(health,x,y + 70)
  draw_face(x + 459,y + 62)
end
 


end

class Window_PlayerHUD < Window_Base
def reset
    @old_hp = @actor.hp
    @old_sp = @actor.sp
    @old_max_hp = @actor.maxhp
    @old_siren = $siren
    @old_alert = $alert
end
 
def initialize
    super(PLAYER_HUD::Xcoord, PLAYER_HUD::Ycoord, 603, 228)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.windowskin = RPG::Cache.windowskin("")
    self.opacity = 0
    $siren = 0
    $alert = 0
    @actor = $game_party.actors[0]
    if @actor != nil
    reset
    refresh
    end
  end 

def refresh
  self.contents.clear
    draw_hud(0,0)
    reset
end
 
def update
  @actor = $game_party.actors[0]
  if @actor != nil
    if @old_hp != @actor.hp or
      @old_max_hp != @actor.maxhp or
      @old_siren != $siren or
      @old_alert != $alert
  refresh
  end
  end
end
end

class Scene_Map
alias phud_main main
  def main
    @phud = Window_PlayerHUD.new
    @phud.x = PLAYER_HUD::Xcoord
    @phud.y = PLAYER_HUD::Ycoord
    if PLAYER_HUD::Toggle == false
    @phud.visible = false 
    else
    @phud.visible = true 
    end   
    phud_main
    @phud.dispose
  end
alias phud_update update
  def update
    if PLAYER_HUD::Toggle == false
    @phud.visible = false 
    else
    @phud.visible = true 
    end   
    @phud.update
    phud_update
  end 
end 

#============================================================================
# SCRIPT DE JAUGE GRAPHIQUE
# Stephane Roys, Royer
# Fevrier 2007
# Projet: Petite Boite à outils pour aider les event maker

# Ce script permet de gèrer en event l'apparition d'une jauge dont la longueur
# dépend d'une variable RPG Maker
#------------------------
# EXPLICATION (lire attentivement)
#------------------------
# CREER un jauge graphique en event
# Faire inserer commentaire :
# Jauge graphique nom x y var min max  votre_image votre_texte
# Remplacer
#          nom le nom identifiant votre jauge
#          x et y par les coordonnées ecran ou s'affichent votre jauge
#          var par le numéro de votre variable RPG maker qui contrôle la jauge (entre 1.999)
#          min la valeur minimale que peut prendre la variable (par ex : 0)
#          max la valeur maximale que peut prendre la variable (par ex : 100)
#          "votre_image" est le nom de l'image que vous avez importé dans le répertoire Pictures
#          "votre_texte" entre guillement est le nom de votre jauge (par ex "HP").
# DEPLACER une jauge graphique
# Faire inserer commentaire: jauge graphique deplace x y p
# Remplacer
#          x par la position de la fenetre sur la largeur
#          y par la position de la fenetre sur la hauteur
#          p l'opacité de la fenetre de jauge
# Si vous voulez remplacer une coordonnées parune variable de RPG maker, il vous suffit d'ecrire v1
# pour la variable 1, v2 pour la variable 2 et ainside suite

# EFFACER une jauge graphique
# Faire inserer commentaire: jauge graphique nom efface
# Remplacer nom par le nom de la jauge que vous voulez effacer
#------------------------
# exemple:
# inserer commentaire : Jauge graphique Hp  0 0 1 0 100 majauge HP
# ici on créé un jauge hp qui s'affiche en 0,0 (coin haut gauche)
# gèré par la variable001, dont les valeurs sont comprises entre 0 et 100
# L'image est réprésentée par "majauge"
# Le texte HP apparait par au dessus de la jauge

# Inserer commentaire Jauge Graphique Deplace Hp  v1 v2 255
# deplace la jauge Hp en v1, v2 qui sont 2 variables de RPG maker, avec une opacité de 255


#------------------------
# RECOMMANDATIONS
#------------------------
# 1- Vous pouvez changer la taille de la Police de toute jauge ici:
FONT=""
TAILLE=16

#2- Prenez soin de donner des noms différents à vos jauges sinon vous risquez d'avoir des conflits

#3- Ne crééez pas une jauge en processus parallèle sinon vous allez créér une nouvelle jauge à chaque frame
# jusqu'a ce que RM bug

#4- La sauvergarde est comprise dans le script. Donc apres un load votre jauge sera dans l'etat ou elle a été sauvée

#5- Les jauges s'effacent toutes seuls quand vous sortez de la map vers un menu, et elles se recréent seules quand vous revenez sur la map

#============================================================================

INTERPRETER_JAUGEG="JAUGEGRAPHIQUE"

#==============================================================================
# Interpreter
# Permet d'ajouter une fonction un pas vers en commentaire dans un event
#==============================================================================
class Interpreter

  alias outil_jaugeg2_command108 command_108

  def command_108
    # Commande non valide
    if not @parameters[0].split.size<7
      # Commande valide
      if @parameters[0].upcase[/JAUGE GRAPHIQUE/]=="JAUGE GRAPHIQUE"
        #----------------------
        # Recupère les parametres de la commande(x,y,var,min,max,"votre_image","votre_texte")
        com=@parameters[0].split
        nom=com[2]
        # fonction DEPLACER
        if com[3].upcase=="DEPLACE"
          # Cherche la jauge par son nom
          for jaugeg in $game_party.jaugesg
            next if jaugeg.nom.upcase!=nom.upcase
            # Recupère les valeurs d'une variable ou la valeur brute
            mot=com[4]
            x= ( mot[0,1]=="v" ? $game_variables[(mot.gsub!("v") {}).to_i] : mot.to_i)
            mot=com[5]
            y= ( mot[0,1]=="v" ? $game_variables[(mot.gsub!("v") {}).to_i] : mot.to_i)
            mot=com[6]
            p= ( mot[0,1]=="v" ? $game_variables[(mot.gsub!("v") {}).to_i] : mot.to_i)
            jaugeg.deplace(x,y,p)
            return true
          end
          return true
        end
        # Fonction EFFACE
        if com[3].upcase=="EFFACE"
          # cherche le nom et efface la jauge
          for jaugeg in $game_party.jaugesg
            next if jaugeg.nom.upcase!=com[4].upcase
            jaugeg.off
            return true
          end
        end
        # fonction CREER
        x=com[3].to_i
        y=com[4].to_i
        var=com[5].to_i
        min=com[6].to_i
        max=com[7].to_i
        image=com[8]
        texte=com[9]
        # Crée la jauge
        Jauge_Graphique.new(nom,x,y,var,min,max,image,texte)
        return true
      end
    end
    outil_jaugeg2_command108
  end
end

#============================================================================
# JAUGE
# Créé le tableau des Jauges de Jeu
#============================================================================
class Game_Party
  attr_accessor:jaugesg
  alias jaugeg2_game_party_initialize initialize
  #--------------------------------------------------------------------------
  # INITIALIZE
  #--------------------------------------------------------------------------
  def initialize
    jaugeg2_game_party_initialize
    # Tableau des jauges
    @jaugesg=[]
  end
end

#============================================================================
# JAUGE
#============================================================================
class Jauge_Graphique
 
  attr_accessor:nom
  attr_accessor:value
  attr_accessor:x
  attr_accessor:y
  attr_accessor:texte
  attr_accessor:opacite
  attr_accessor:image
  attr_accessor:var
  attr_accessor:w
  attr_accessor:h
  attr_accessor:fin_jaugeg
 
  #--------------------------------------------------------------------------
  # INITIALIZE
  #--------------------------------------------------------------------------
  def initialize(nom,x,y,var,min,max,image,texte)
    @x=x;@y=y;@var=var;@min=min;@max=max
    @texte=texte
    @nom=nom
    @fin_jaugeg=false
    @visible=true
    @image=image
    @opacite=255
    image=Bitmap.new("Graphics/Pictures/"+image)
    @w=image.width
    @h=image.height
    $game_party.jaugesg.push(self)
  end
 
  #--------------------------------------------------------------------------
  # UPDATE
  # Calcule la longueur de la jauge en fonction de la variable var affectée
  #--------------------------------------------------------------------------
  def update
    @value = @w * $game_variables[@var] / (@max-@min)
  end

  #--------------------------------------------------------------------------
  # OFF
  # Termine la jauge
  #--------------------------------------------------------------------------
  def off
    @fin_jaugeg=true
  end
 
  #--------------------------------------------------------------------------
  # DEPLACEMENT
  # Deplace la jauge
  #--------------------------------------------------------------------------
  def deplace(x,y,p)
    @x=x
    @y=y
    @opacite=p
  end
end

#============================================================================
# ¦ Spriteset Map
#============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  alias jaugeg2_spriteset_map_initialize initialize
  alias jaugeg2_spriteset_map_dispose dispose
  alias jaugeg2_spriteset_map_update update
 
  #--------------------------------------------------------------------------
  # INITIALIZE
  #--------------------------------------------------------------------------
  def initialize
    # Créé les jauges
    @jaugeg_windows=[]
    for jauge in $game_party.jaugesg
      setup_jaugeg(jauge)
    end
    jaugeg2_spriteset_map_initialize
  end
 
  #--------------------------------------------------------------------------
  # SETUP
  #--------------------------------------------------------------------------
  def setup_jaugeg(jauge)
    window=Window_Base.new(jauge.x, jauge.y, jauge.w+32, jauge.h+32+TAILLE)
    window.contents = Bitmap.new(window.width - 32, window.height - 32)
    window.contents.font.color= Color.new(0,0,0)
    window.opacity=0
    window.contents_opacity = jauge.opacite
    window.z = 3000
    window.contents.font.name = FONT
    window.contents.font.size = TAILLE
    @jaugeg_windows.push(window)
  end

  #--------------------------------------------------------------------------
  # UPDATE
  #--------------------------------------------------------------------------
  def update
    jaugeg2_spriteset_map_update
    #-----------------------------
    # Cherche si une nouvelle jauge a été créée
    for key in @jaugeg_windows.size..$game_party.jaugesg.size-1
      setup_jaugeg($game_party.jaugesg[key])
    end
    #-----------------------------
    # Update la jauge
    delete_window=[]
    delete_jauge=[]
    for key in  0..$game_party.jaugesg.size-1
      jauge=$game_party.jaugesg[key]
      window=@jaugeg_windows[key]
      # Affiche la fenêtre de la jauge
      update_jaugeg(jauge, window)
      # Observe si la jauge est disposée
      if jauge.fin_jaugeg
        delete_window.push(window)
        delete_jauge.push(jauge)
      end
    end
    #-----------------------------
    # Dispose la jauge
    for window in delete_window
      window.dispose
      @jaugeg_windows.delete(window)
    end
    for jauge in delete_jauge
      $game_party.jaugesg.delete(jauge)
    end
  end
 
  #--------------------------------------------------------------------------
  # UPDATE JAUGE
  #--------------------------------------------------------------------------
  def update_jaugeg(jauge,window)
    #-----------------------------
    # Recalcule la jauge
    jauge.update
    window.x=jauge.x
    window.y=jauge.y
    window.contents_opacity=jauge.opacite
    #-----------------------------
    window.contents.clear
    image=Bitmap.new("Graphics/Pictures/"+jauge.image)
    w=image.width
    h=image.height
    # Affiche l aportion de la jauge graphique et le texte
    window.contents.draw_text(0,0,jauge.w,jauge.h,jauge.texte,1)
    window.contents.blt(0, TAILLE, image, Rect.new(0,0,jauge.value,jauge.h))
  end
 
  #--------------------------------------------------------------------------
  # DISPOSE
  #--------------------------------------------------------------------------
  def dispose
    jaugeg2_spriteset_map_dispose
    for window in @jaugeg_windows
      window.dispose
    end
  end
end