[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français

Plutôt que de mettre un "Haut vers bas" il te suffit d'exécuter le code du "Bas vers haut" en inversant les 2 couleurs. Et pareil pour les autres, ce qui ferais un dégradé horizontal, un vertical et un radial.

@ Zeus :
Oui, oui, j'en avais fait 2 mais je peux pas en faire d'autres sur ce PC (pas RM, pas Ruby)

Ca c'est un screen de GB où les dégradés se font en temps réel:

Un grosse "Jauge"!

@ mtarzaim
Pour les deux : RMXP et RMVX. Mais si tu sais pas un minimum faire du Ruby, c'est foutu... c'est destiné aux "semi-rubystes".

#------------------
Ensuite :
Et bien, entre le temps où j'ai envoyé le script et le moment où il est apparu, il s'est écoulé un labs de temps...
Et donc sont sorties des VERSIONS OPTIMISEES de ces scripts. Ce qui fait que je les reposte :

 
#====================================================
# Draw Degrade
# Josué Alvarez (RPG-man)
#-------------------------------------------------------------
#Crée un bitmap contenant un dégradé
#====================================================
=begin
/!\ Mode d'emploi /!\
Voici un exemple d'utilisation :
c1 = Color.new(255, 0, 0, 255)                # Première couleur
c2 = Color.new(200, 150, 0, 255)           # Deuxième couleur
w = 200                                                      # Largeur du bitmap
h = 200                                                       # hauteur du bitmap
 
bitmap = Bitmap.new(w, h)                      # Création du bitmap vide
bitmap.draw_degrade(w, h, c1, c2, 2)    # Création du dégradé sur le bitmap
 
sprite = Sprite.new                                    # Création du sprite
sprite.bitmap = bitmap                             " Attribution du bitmap au sprite
///////////////////////////
Les arguments
\\\\\\\\\\\\\\\\\\\\\\\\\\\
1 : Largeur du bitmap
2 : Hauteur du bitmap
3 : Première couleur
4 : Deuxième couleur
5 : Type de dégradé 
( 0 : droite vers gauche, 1: gauche vers droite, 2 haut vers bas, 3 bas vers haut )
=end
 
 
class Bitmap
  def draw_degrade(w, h, col1, col2, type=0)
    @col1 = col1
    @col2 = col2
    @couleur = col1
 
 
case type 
#===================================
#Bas vers haut
#===================================
when 2
@red = (col2.red - col1.red)/ h
@blue = (col2.blue - col1.blue) / h
@green = (col2.green - col1.green) / h
@opacity = (col2.alpha - col1.alpha) /h
    for i in 0...h
 
      self.fill_rect(0, i, w, 1, @couleur)
    
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
  end
  
#===================================
#Haut vers bas
#===================================
when 3
@red = (col2.red - col1.red)/ h
@blue = (col2.blue - col1.blue) / h
@green = (col2.green - col1.green) / h
@opacity = (col2.alpha - col1.alpha) / h
    for i in 0...h
 
      self.fill_rect(0, h-i, w, 1, @couleur)
    
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
      
  end
 
 
#===================================
# Gauche vers droite
#===================================
 
when 0
@red = (col2.red - col1.red) / w
@blue = (col2.blue - col1.blue) / w
@green = (col2.green - col1.green) / w
@opacity = (col2.alpha - col1.alpha) / w
    for i in 0...w
 
      self.fill_rect(i, 0, 1, h, @couleur)
 
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
      
    end
    
#===================================
#Droite vers gauche
#===================================
when 1
@red = (col2.red - col1.red) / w
@blue = (col2.blue - col1.blue) / w
@green = (col2.green - col1.green) / w
@opacity = (col2.alpha - col1.alpha) / w
 
    for i in 0...w
 
  self.fill_rect(w-i, 0, 1, h, @couleur)
 
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
      
end
#===================================
#Radial
#===================================
when 5
if w < h
  m = w
else
  m = h
end
@red = (col2.red - col1.red) / m
@blue = (col2.blue - col1.blue) / m
@green = (col2.green - col1.green) / m
@opacity = (col2.alpha - col1.alpha) /m
for i in 0...m/2 + 1
  self.encadre(w, h, @couleur, i, true, true)
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
end
#===================================
# Radial inverse
#===================================
when 6
  if w < h
  m = w
else
  m = h
end
 
@red = (col2.red - col1.red) / m
@blue = (col2.blue - col1.blue) / m
@green = (col2.green - col1.green) / m
@opacity = (col2.alpha - col1.alpha) /m
for i in 0...m/2 + 1
  self.encadre(w, h, @couleur, i, true, false)
      @couleur.red += @red
      @couleur.blue += @blue
      @couleur.green += @green
      @couleur.alpha += @opacity
end
#=======================================================
#=======================================================
end
return self
end
#=======================================================
#=======================================================
#/////////////////////////////
#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
end

 
#=======================================================
# Cadres
# Josué Alvarez (RPG-man)
#---------------------------------------------------------------
# Encadre un bitmap
#=======================================================
=begin
/!\ Mode d'emploi /!\
//////////////////////////////////
Arguments
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
1 : largeur du bitmap
2 : hauteur du bitmap
3 : Couleur de l'encadrement
4 : épaisseur du trait (des options après)
5 : Trait fin :
       o si true : trace un cadre de 1 pixel qui a pour distance du bord du bitmap l'argument 4
       o si false : encadre le bitmap avec un trait d'une largeur de l'argument 4
6 : commencement du cadre au bord:
             o si true : commencera toujours le cadre au bord
             o si false et 'Trait fin' true, commence l'encadrement à #{argument4} pixels du bord.
=end
 
 
 
 
class Bitmap
  def encadre(w, h, color, ep=1, fin=false, debut=true)
    
    if debut == true
      deb = ep-1
    else
      deb = 0
    end
    
#======================
#======================
    for i in deb...w-deb
      if fin == false
        
      for j in 0...ep
      self.set_pixel(i, j, color)
      self.set_pixel(i, h-(j+1), color)
      end
    
  else
    
    self.set_pixel(i, ep, color)
    self.set_pixel(i, h-ep, color)
  end
  
    end
#======================
#======================
#======================
#======================
    for i in deb...h-deb
      if fin == false
      for j in 0...ep
      self.set_pixel(j, i, color)
      self.set_pixel(w-(j+1), i, color)
      end
  else
        self.set_pixel(ep, i, color)
        self.set_pixel(w-ep, i, color)
      end
    end
#======================
#======================
  end
end

 
#======================================================================
# Draw_jauge
# Par RPG-Man
#--------------------------------------------------
# Crée une jauge
# Pour changer la longueur
# sprite.src_rec(0, 0, largeur, hauteur)
#======================================================================
=begin
///////////////////////////////
Arguments
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
type : type de dégradé (voir draw_degrade)
c1, c2 : couleurs du dégradé à l'arrière
c3 : couleur du cadre
opacity : opacité du blanc transparent au dessus
extra : mettre des dégradés de noir sous le blanc
opacity_extra : opacité de ces dégradés
=end
 
class Bitmap
def draw_jauge(type, c1, c2, c3, opacity=50, extra=false, opacity_extra=50)
 
self.draw_degrade(self.width, self.height, c1, c2, type)
self.encadre(self.width, self.height, c3, 1)
 
b = Bitmap.new(self.width, self.height)
b.fill_rect(b.rect, Color.new(255, 255, 255, 255))
 
if extra == true
black = Color.new(0, 0, 0, 255)
transp = Color.new(0, 0, 0, 50)
 
c = Bitmap.new(self.width, self.height/2)
c.draw_degrade(c.width, c.height, black, transp, 3)
 
d = Bitmap.new(self.width, self.height/2)
d.draw_degrade(d.width, d.height, transp, black, 3)
 
self.blt(0, 0, c, c.rect, opacity_extra)
self.blt(0, self.height/2, d, d.rect, opacity_extra)
c.dispose
d.dispose
end
 
self.blt(0, 0, b, b.rect, opacity)
b.dispose
end
end