vincentmhdMembre- Nombre de messages : 9
Age : 37
Localisation : Amiens
Distinction : aucune
Date d'inscription : 06/03/2009 
Mto Soleil
Dim 3 Jan 2010 - 22:44
Mto Soleil
-Introduction
Assez de la pluie, de la neige, et de l'orage!! ^^ voilà du Soleil made in mhd! 
J'en avais déjà parlé dans la boite à idée.
J'en avais déjà parlé dans la boite à idée.
-Description
Euh une image pour commencer serait bien ^^...
Bon, le screen n'est pas terrible terrible... c'est parce que les rayons apparaissent et disparaissent tant que la météo est active... Elle est "animée". Bon, ça n'éblouïe pas pour autant.
En réalité, le soleil est un point hors de l'écran, et un ensemble de rayons semblants provenir de ce point. Les rayons apparaissent, puis disparraissent, ponctuellement ça peut être sympathique.
-Installation
Ce script n'échappe pas à la régle du "copiez en dessous de material".
Il n'a pas de nécéssité particulière. Cet effet lumineux n'a pas besoin d'images.
-Utilisation
Il est très simple:
Activation:
dans un appel de script mettre "$sun.play(intensité, temps)" comme pour les vraies météos: l'intensité va de 1 à 10, et le "temps" correspond au temps d'apparition de la météo.
Désactivation: "$sun.stop(temps)"
Alors, compliqué?
Il y a deux autres petites fonctions:
$sun.position(heure, minute) permet de faire le lien avec des scripts ou des events parallèlles de temps.
$sun.change_opacity(opacity, duration =0) permet de faire changer tous les rayons en une opacité commune.
-Configuration:
Le module de configuration est grand pour vous permettre de l'adapter à vos besoins.
Référez-vous aux commentaires, normalement il devrait être assez compréhensible et permet beaucoup de variante.
-Le script:
- Spoiler:
- Code:
#===============================================================================
#
#
# Mto_Sun.v3
#
#
#===============================================================================
#
#by Vincentmhd,
#http://vincentmhdmaker.canalblog.com/
#v1 -> v2 Les rayon peuvent maintenant faire le tour complet de l'écran
#v2 -> v3 Correction de la méthode Stop
# Ajustement de la longueur des rayons en fonction de la distance du soleil possible
# Meilleure gestion de l'intensité
#=====================================NOTE======================================
=begin
Ce script est un script Météorologique. Il permet d'appeler le Soleil, comme
on appelle la pluie, ou la neige.
Le soleil est composé de rayon qui suivent leur propre cycle. Ils apparaissent,
restent, disparaissent, attendant, pour réapparaitre et ainsi de suite. A chaque
réapparition ils changent de place, forme.
La position du Soleil se détermine par l'heure (et les minutes)
appel par la méthode:
$sun.position(heure,minutes)
Pour appeler le Soleil:
$sun.play(Intensité, Temps_d'_apparition)
Pour arrêter la météo:
$sun.stop(temps_de_disparition)
Pour changer l'opacité de tout les rayons à la fois momentanément
$sun.change_opacity(opacity, duration =0)
Le tout est assez customisable dans le module ci-dessous.
=end
#-------------------------------------------------------------------------------
module Mhd_Sun
#===============================================================================
# Rayons
#===============================================================================
#Images et Sprites
LONGUEUR_MAX = 500
LONGUEUR_MIN = 300
HAUTEUR_MAX = 30
HAUTEUR_MIN = 5
CALCUL_DISTANCE = true #détermine s'il l'on prend en compte la distance écran<->soleil
#dans le calcul de la longueur des rayons
VARIANCE_ANGLE = 30 #Delta des angles des rayons
ALPHA_RAYON = 2*255/3 #Alpha des images de bases
OPACITY_MAX = 255 #Min et max de l'opacité des
OPACITY_MIN = 255/2 #Sprites des rayons
#Durées des Cycles:: Durées
#Transition_naturelle
DUREE_APP_MAX = 120
DUREE_APP_MIN = 60
#Attend
WAIT_MAX = 60
WAIT_MIN = 5
#Lumine
SOLEIL_MAX = 160
SOLEIL_MIN = 60
#===============================================================================
# Soleil
#===============================================================================
HEURE_DEFAULT = 14 #Pris si rien n'est spécifié
MINUTE_DEFAULT = 0
CHANGE_DUREE = 60 #Durée moyenne de changement d'opacité général par défaut
CHANCE_CHANGE = 5000 #Chance sur 1 d'avoir un changement d'opacité général
#à la frame
DISTANCE_SOLEIL = 550 #Rayon de rotation
X_ORIGINE = 416/2 #Axe de rotation
Y_ORIGINE = 544/2 #Axe de rotation
TETA_MIN = 25 #Angle parcourru à l'écran (par rapport à la droite y = Y_ORIGINE)
TETA_MAX = 155 #Angle parcourru à l'écran (par rapoort à la droite y = Y_ORIGINE)
HEURE_MIN = 8 #A Heure_min, Téta = Téta_min
MINUTE_MIN = 15 #60 min = 1h 0 min donc 60 n'existe pas!
HEURE_MAX = 19 #A Heure_max, Téta = Téta_max
MINUTE_MAX = 15
NBS_RAYONS_MIN = 5
NBS_RAYONS_MAX = 15 #ne correspond pas au vrai max et min (+ ou - 20%)
#===============================================================================
# Influences Mutuelles
#===============================================================================
RONDEUR = 90 #avec le placement des sprites sur les
#contours et non directement au soleil
#on perd la rondeur de celui-ci la rondeur
#est un correctif fonction de la variance
#angulaire et de l'angle avec l'axe
#Soleil/centre de rotation
INFLUENCE_H = 90 #représente l'influence du pourcentage
#horaire du soleil sur la dimension
#des rayons: au zénith les rayons sont à
#100% de leur longueur possible. Au
#crépuscule et à l'aube, ils sont au
#minimun à LONGUEUR_MIN*(1-INFLUENCE_H/100)
end
#===============================================================================
#
#
# Petits utilitaires
#
#
#===============================================================================
module Mhd_Math
#convertir en radians
def put_in_rad(angle)
return angle = ((Math::PI.to_f * angle.to_f) /180)
end
#plus ou moins X%
def plus_ou_moins(nombre, pourcentage)
pourcentage = (100 - pourcentage) + rand( pourcentage*2 )
pourcentage = pourcentage.to_f/100
nombre = nombre.to_f * pourcentage
return nombre
end
end
#Inclusion dans l'espace commun
include Mhd_Math
#===============================================================================
# Ajout aux couleurs
#===============================================================================
class Color
def moyenne_avec(color)
self.red = (self.red + color.red) / 2
self.green = (self.green + color.green) / 2
self.blue = (self.blue + color.blue) / 2
self.alpha = (self.alpha + color.alpha) / 2
end
end
#==============================================================================
# Ajout aux Bitmap
#==============================================================================
class Bitmap
def moyenne_avec(bitmap)
for x in 0...self.width
for y in 0...self.height
couleur = self.get_pixel(x,y)
couleur.moyenne_avec(bitmap.get_pixel(x,y))
self.set_pixel(x,y,couleur)
end
end
end
def gradient_param(colorA, colorB, param)
return ((1-param)*colorA.to_f + (param)*colorB.to_f).to_i
end
def gradient_color(colorA, colorB, param)
r= gradient_param(colorA.red, colorB.red, param)
g= gradient_param(colorA.green, colorB.green, param)
b= gradient_param(colorA.blue, colorB.blue, param)
a= gradient_param(colorA.alpha, colorB.alpha, param)
return Color.new(r,g,b,a)
end
def mhd_gradient_A(couleur_B, rect = self.rect)
for x in 0...rect.width
for y in 0...rect.height
couleur_A = self.get_pixel(x + rect.x, y + rect.y)
param = ((rect.width.to_f - x.to_f)*(y.to_f))/(rect.width.to_f * rect.height.to_f)
couleur_C = gradient_color(couleur_A, couleur_B, param)
self.set_pixel(x + rect.x, y + rect.y, couleur_C)
end
end
end
def mhd_gradient_B(couleur_B, rect = self.rect)
for x in 0...rect.width
for y in 0...rect.height
couleur_A = self.get_pixel(x + rect.x,y + rect.y)
param = ((rect.width.to_f - x.to_f)*(rect.height.to_f - y.to_f))/(rect.width.to_f * rect.height.to_f)
couleur_C = gradient_color(couleur_A, couleur_B, param)
self.set_pixel(x + rect.x, y + rect.y, couleur_C)
end
end
end
def mhd_gradient_C(couleur_B, rect = self.rect)
for y in 0...rect.height
for x in 0...rect.width
couleur_A = self.get_pixel(x + rect.x, y + rect.y)
param = ((rect.height.to_f - y.to_f)*(x.to_f))/(rect.width.to_f * rect.height.to_f)
couleur_C = gradient_color(couleur_A, couleur_B, param)
self.set_pixel(x + rect.x, y + rect.y, couleur_C)
end
end
end
def mhd_gradient_D(couleur_B, rect = self.rect)
for y in 0...rect.height
for x in 0...rect.width
couleur_A = self.get_pixel(x + rect.x,y + rect.y)
param = ((rect.width.to_f - x.to_f)*(rect.height.to_f - y.to_f))/(rect.width.to_f * rect.height.to_f)
couleur_C = gradient_color(couleur_A, couleur_B, param)
self.set_pixel(x + rect.x, y + rect.y, couleur_C)
end
end
end
#===============================================================================
# Dessine des Rayons
#===============================================================================
def draw_rayon_A
self.fill_rect(self.rect, Color.new(255,255,255,0))
self.mhd_gradient_A(Color.new(255,255,255,Mhd_Sun::ALPHA_RAYON),Rect.new(0, 0, self.width, self.height/2) )
self.mhd_gradient_B(Color.new(255,255,255,Mhd_Sun::ALPHA_RAYON),Rect.new(0, self.height/2, self.width, self.height - self.height/2) )
end
def draw_rayon_B
self.fill_rect(self.rect, Color.new(255,255,255,0))
self.mhd_gradient_C(Color.new(255,255,255,Mhd_Sun::ALPHA_RAYON),Rect.new(0, 0, self.width/2, self.height) )
self.mhd_gradient_D(Color.new(255,255,255,Mhd_Sun::ALPHA_RAYON),Rect.new(self.width/2, 0, self.width - self.width/2, self.height) )
end
end
#===============================================================================
#
#
# Les rayons
#
#
#===============================================================================
class Rayon
def initialize(soleil_x, soleil_y, soleil_teta, intensity, pourcentage_horraire)
physical_data(pourcentage_horraire, intensity)
creer_sprite(soleil_x, soleil_y, soleil_teta)
clear_timer
end
def physical_data(pourcentage_horraire, intensity)
@distance = 0
@pourcentage = pourcentage_horraire
@intensity = intensity
@opacity = Mhd_Sun::OPACITY_MIN + ((@intensity.to_f/10)*(Mhd_Sun::OPACITY_MAX.to_f - Mhd_Sun::OPACITY_MIN.to_f) )
@opacity = (Mhd_Math.plus_ou_moins( @opacity, 20)).to_i
end
def clear_timer
@fade = false
@duree = 0
@transition = 0
@wait = Mhd_Sun::WAIT_MIN + rand(Mhd_Sun::WAIT_MAX - Mhd_Sun::WAIT_MIN)
@soleil = 0
end
#===============================================================================
# La Sprite...
#===============================================================================
#Créer la sprite, et les données physiques
def creer_sprite(soleil_x, soleil_y, teta)
@sprite = Sprite.new()
@sprite.opacity = 0
if ((@pourcentage <= 1.0) && (@pourcentage >= 0.0))
position(soleil_x, soleil_y, teta)
else
@sprite.dispose
end
end
#regroupe les méthodes physiques
def position(soleil_x, soleil_y, soleil_teta)
if !(@sprite.disposed?)
calcul_angle(soleil_teta)
calcul_coord(soleil_x, soleil_y, @angle)
choix_bitmap
end
end
#===============================================================================
# L'angle
#===============================================================================
#Calcul l'angle du rayon en fonction de la position du soleil dans sa
#trajectoire cela se manifeste en tout premier par son angle
def calcul_angle(teta)
if !(@sprite.disposed?)
angle = 180 - teta
delta = rand(Mhd_Sun::VARIANCE_ANGLE)
if rand(2)>= 1
angle += delta
else
angle -= delta
end
@angle = angle
#calcul rondeur
@rondeur = (1 - Mhd_Sun::RONDEUR.to_f/100) + (Mhd_Sun::RONDEUR.to_f/100)*(1 - delta.to_f/(Mhd_Sun::VARIANCE_ANGLE.to_f))
end
end
#===============================================================================
# Les coordonnées
#===============================================================================
def calcul_coord(soleil_x, soleil_y, rayon_teta)
if !(@sprite.disposed?)
rayon_teta = put_in_rad(rayon_teta)
b = (soleil_y.to_f + soleil_x.to_f * Math.tan(rayon_teta))
a = (b - soleil_y.to_f)/( - soleil_x.to_f)
i=[]
j=[]
k=[]
l=[]
i[0] = 0.0
i[1] = b
j[0] = -b/a
j[1] = 0.0
k[0] = 544.0
k[1] = 544.0*a +b
l[0] = (416.0 -b )/a
l[1] = 416.0
tab = [i,j,k,l]
id = nil
distance = nil
for n in 0...tab.size()
if ( (tab[n][1] >= 0) && (tab[n][1]<= 416) && (tab[n][0] >= 0) && (tab[n][0]<= 544) )
d = Math.sqrt((tab[n][1]-soleil_y)*(tab[n][1]-soleil_y) + (tab[n][0]-soleil_x)*(tab[n][0]-soleil_x))
if distance == nil
distance = d
id = n
else
if distance > d
distance = d
id = n
end
end
end
end
if !(id == nil)
@distance = distance
@sprite.x = tab[id][0]
@sprite.y = tab[id][1]
else
@sprite.dispose
end
end
end
#===============================================================================
# Choix de l'image
#===============================================================================
#Selon les coordonées et l'angle du rayon, il ne va prendre la même image pour
#masquer les coins de ces dernières.
def choix_bitmap
if !(@sprite.disposed?)
angle = @angle
#Condition permettant de connaitre le côté de l'apparition
a = ( (angle >= -90) && (angle <= 0) && !(!(@sprite.y == 0)) )
b = ( (angle >= 0) && (angle <= 90) && !(!(@sprite.x == 0)) )
c = ( (angle >= 90) && (angle <= 180) && !(!(@sprite.y == 416)) )
d = ( (angle >= -180) && (angle <= -90) && !(!(@sprite.x == 544)) )
#Proportion des rayon en fonction du pourcentage horraire
if(@pourcentage >0.5 )
proportion = 2*(1 - @pourcentage)
else
proportion = @pourcentage
end
proportion = (1 - Mhd_Sun::INFLUENCE_H.to_f/100) + ((Mhd_Sun::INFLUENCE_H.to_f/100) * proportion )
if (a||b||c||d)
#Rayon de type B
angle += 90 #angle à ré-adapter
@sprite.bitmap = $mhd_ray_B
longueur = Mhd_Sun::HAUTEUR_MIN + ((@intensity.to_f/10)*(Mhd_Sun::HAUTEUR_MAX.to_f - Mhd_Sun::HAUTEUR_MIN.to_f))
longueur = (Mhd_Math.plus_ou_moins( longueur , 20)).to_i
hauteur = Mhd_Sun::LONGUEUR_MIN + ((@intensity.to_f/10)*(Mhd_Sun::LONGUEUR_MAX.to_f - Mhd_Sun::LONGUEUR_MIN.to_f))
hauteur = (Mhd_Math.plus_ou_moins( hauteur , 20)).to_i
if Mhd_Sun::CALCUL_DISTANCE == true
#longueur *= (hauteur - @distance) /hauteur
hauteur -= @distance
end
longueur *= proportion
hauteur *= proportion *@rondeur
@sprite.zoom_x = (longueur.to_f/Mhd_Sun::HAUTEUR_MAX.to_f)
@sprite.zoom_y = (hauteur.to_f/Mhd_Sun::LONGUEUR_MAX.to_f)
else
@sprite.bitmap = $mhd_ray_A
longueur = Mhd_Sun::LONGUEUR_MIN + ((@intensity.to_f/10)*(Mhd_Sun::LONGUEUR_MAX.to_f - Mhd_Sun::LONGUEUR_MIN.to_f))
longueur = (Mhd_Math.plus_ou_moins( longueur , 20)).to_i
hauteur = Mhd_Sun::HAUTEUR_MIN + ((@intensity.to_f/10)*(Mhd_Sun::HAUTEUR_MAX.to_f - Mhd_Sun::HAUTEUR_MIN.to_f))
hauteur = (Mhd_Math.plus_ou_moins( hauteur , 20)).to_i
if Mhd_Sun::CALCUL_DISTANCE == true
#hauteur *= (longueur - @distance) / longueur
longueur -= @distance
end
longueur *= proportion *@rondeur
hauteur *= proportion
@sprite.zoom_x = (longueur.to_f/Mhd_Sun::LONGUEUR_MAX.to_f)
@sprite.zoom_y = (hauteur.to_f/Mhd_Sun::HAUTEUR_MAX .to_f)
end
@sprite.angle = angle
if ((longueur <= 0 )||( hauteur <= 0))
@sprite.dispose
end
end
end
#===============================================================================
# Actions
#===============================================================================
#Change l'opacité (indépendanment de fade-in et fade_out)
def change_opacity( opacity, transition)
@target_opacity = opacity
@transition = transition
if (transition == 0 && (!(@sprite.disposed?)))
@sprite.opacity = @target_opacity
end
end
#Force le rayon à s'éteindre
def fade_out(time)
@wait = 0
@transition = 0
@duree = - time
@soleil = 0
@fade = true
end
#===============================================================================
# Cycle du Rayon
#===============================================================================
def cycle_update(soleil_x, soleil_y, teta)
#En suspend en cas de transition
if @transition == 0
#Apparition
if @duree > 0
d = @duree
if !(@sprite.disposed?)
@sprite.opacity = (@sprite.opacity * (d - 1) + @opacity) / d
end
@duree -= 1
if @duree == 0
@soleil = Mhd_Sun::SOLEIL_MIN + rand(Mhd_Sun::SOLEIL_MAX - Mhd_Sun::SOLEIL_MIN)
end
end
#Brille
if @soleil >0
@soleil -=1
if @soleil == 0
@duree = -(Mhd_Sun::DUREE_APP_MIN + rand(Mhd_Sun::DUREE_APP_MAX - Mhd_Sun::DUREE_APP_MIN))
end
end
#Disparition
if @duree < 0
d = -@duree
if !(@sprite.disposed?)
@sprite.opacity = (@sprite.opacity * (d - 1) + 0) / d
end
@duree += 1
if (@duree == 0)&&(@wait >= 0)
if @fade == true
@wait=-1
else
@wait = Mhd_Sun::WAIT_MIN + (((10 - @intensity.to_f)/10)*(Mhd_Sun::WAIT_MAX.to_f - Mhd_Sun::WAIT_MIN.to_f))
@wait = (Mhd_Math.plus_ou_moins( @wait , 20)).to_i
end
@sprite.dispose
end
end
#Attend
if @wait >0
@wait -= 1
if @wait == 0
@opacity = Mhd_Sun::OPACITY_MIN + ((@intensity.to_f/10)*(Mhd_Sun::OPACITY_MAX.to_f - Mhd_Sun::OPACITY_MIN.to_f) )
@opacity = (Mhd_Math.plus_ou_moins( @opacity, 20)).to_i
creer_sprite(soleil_x, soleil_y, teta)
@duree = Mhd_Sun::DUREE_APP_MIN + rand(Mhd_Sun::DUREE_APP_MAX - Mhd_Sun::DUREE_APP_MIN)
end
end
end
end
#===============================================================================
# Update
#===============================================================================
def update(soleil_x, soleil_y, teta, pourcentage)
@pourcentage = pourcentage
update_change_opacity
cycle_update(soleil_x, soleil_y, teta)
end
def update_change_opacity
if @transition > 0
if !(@sprite.disposed?)
d = @transition
@sprite.opacity = (@sprite.opacity * (d - 1) + @target_opacity) / d
end
@transition -= 1
if (@transition == 0)
if (@duree > 0)
@duree = (Mhd_Sun::DUREE_APP_MIN + rand(Mhd_Sun::DUREE_APP_MAX - Mhd_Sun::DUREE_APP_MIN))
else
if (@duree < 0)
@duree = -(Mhd_Sun::DUREE_APP_MIN + rand(Mhd_Sun::DUREE_APP_MAX - Mhd_Sun::DUREE_APP_MIN))
end
end
end
end
end
end
#===============================================================================
#
#
# Le Soleil
#
#
#===============================================================================
class Mto_Sun
def initialize
@play = false
@chance = Mhd_Sun::CHANCE_CHANGE
@stop_time = -1
@x = 0
@y = 0
@teta = 0
@change_count = 0
@change_target = 0
horaires()
angles ()
position()
end
#===============================================================================
# Petits Paramètres
#===============================================================================
def Nombre_rayons?
@nbs_rayon = Mhd_Sun::NBS_RAYONS_MIN + ((@intensity.to_f/10)*(Mhd_Sun::NBS_RAYONS_MAX-Mhd_Sun::NBS_RAYONS_MIN).to_f).to_i
@nbs_rayon = (Mhd_Math.plus_ou_moins(@nbs_rayon, 25)).to_i
end
#Definie les heures du jour (correspondance angles/heures adaptable)
def horaires(heure_min = Mhd_Sun::HEURE_MIN, minute_min = Mhd_Sun::MINUTE_MIN, heure_max = Mhd_Sun::HEURE_MAX, minute_max = Mhd_Sun::MINUTE_MAX)
@total_min = (60*heure_min) + minute_min
@total_max = (60*heure_max) + minute_max
end
#Definie les angle min et max (correspondance angles/heures adaptable)
def angles(angle_min = Mhd_Sun::TETA_MIN, angle_max = Mhd_Sun::TETA_MAX)
@angle_min = (360 - angle_min.to_f)
@angle_max = (360 - angle_max.to_f)
end
#Calcul du pourcentage horaire
def pourcentage_horaire(heure, minute)
total = heure * 60 + minute
@pourcentage = (total.to_f - @total_min.to_f)/(@total_max.to_f - @total_min.to_f)
end
def size?
print(@nbs_rayon)
end
#===============================================================================
# Actions
#===============================================================================
#Active
def play(intensite, apparition)
if(@play == false)
@soleil = []
@play = true
@time = apparition
@intensity = intensite
@stop_time = -1
Nombre_rayons?
create_rayon
end
end
#Désactive
def stop(time = 0)
if @play == true
@change_count = 0
@stop_time = time + 60
for i in 0...@soleil.size()
@soleil[i].fade_out(time)
end
end
end
#Calcul la position du Soleil
def position(heure = Mhd_Sun::HEURE_DEFAULT, minute = Mhd_Sun::MINUTE_DEFAULT)
pourcentage_horaire(heure, minute)
@teta = (@angle_max - @angle_min)*(@pourcentage) + @angle_min
@x = (Mhd_Sun::X_ORIGINE.to_f + (Mhd_Sun::DISTANCE_SOLEIL.to_f)*( Math.cos(((Math::PI * @teta) /180)) ))
@y = (Mhd_Sun::Y_ORIGINE.to_f + (Mhd_Sun::DISTANCE_SOLEIL.to_f)*( Math.sin(((Math::PI * @teta) /180)) ))
end
#Change toutes les opacités
def change_opacity(opacity, time = Mhd_Sun::CHANGE_DUREE)
@change_target = opacity
@change_count = time
for i in 0...@soleil.size()
@soleil[i].change_opacity(opacity, time)
end
end
#===============================================================================
# Update
#===============================================================================
def create_rayon
for i in 0...@nbs_rayon
@soleil += [Rayon.new(@x, @y, @teta, @intensity, @pourcentage)]
end
end
def update
stop_count
if @play
update_change
for i in 0...@soleil.size()
@soleil[i].update(@x, @y, @teta, @pourcentage)
end
end
end
def stop_count
if @stop_time > 0
@stop_time -= 1
if @stop_time == 0
@play = false
@stop_time = -1
end
end
end
def stopping?
if @stop_time > 0
return true
else
return false
end
end
def update_change
#un seul changement par défaut à la fois
if !(stopping?)
if @change_count == 0
a = rand(@chance)
if a == @chance/2
opacity = (@intensity.to_f)*255/10
opacity = (Mhd_Math.plus_ou_moins( opacity, 25)).to_i
duree = Mhd_Sun::CHANGE_DUREE/2 + rand(Mhd_Sun::CHANGE_DUREE)
change_opacity(opacity , duree)
end
else
@change_count -= 1
end
end
end
end
#==============================================================================#
# #
# Création de la Météo et des images #
# #
#==============================================================================#
class Scene_Title
alias mhd_sun_create_game_objects create_game_objects
def create_game_objects
mhd_sun_create_game_objects
#horrizontal
$mhd_ray_A = Bitmap.new(Mhd_Sun::LONGUEUR_MAX, Mhd_Sun::HAUTEUR_MAX)
$mhd_ray_A.draw_rayon_A
#vertical
$mhd_ray_B = Bitmap.new(Mhd_Sun::HAUTEUR_MAX, Mhd_Sun::LONGUEUR_MAX)
$mhd_ray_B.draw_rayon_B
$sun = Mto_Sun.new
end
end
class Scene_Map
alias vincentmhd_sun_update update
def update
vincentmhd_sun_update
$sun.update
end
end
-Crédits : Vincentmhd
Hum je n'ai jamais envoyé un post de script aussi rapidement...
Edit:: j'ai corrigé quelques petits défauts du script le soir même... je savais bien que c'était trop vite ^^
Shadow of LifeMembre- Nombre de messages : 870
Age : 28
Localisation : Joyeux. Comment ça c'est pas la bonne case ?
Distinction : Artiste de la flagornerie.
Porte parole du Ô grand Voilà voilà.
Président du club des masochistes du forum
Fake Gentleman
Soumis ^^
Date d'inscription : 13/09/2009
Re: Mto Soleil
Lun 4 Jan 2010 - 15:44
Bravo pour ce magnifique script : je t'applaudis de mes 5 mains ( ... :gné: )
Je l'utiliserais surement pour mon jeu.
Encore bravo !
Je l'utiliserais surement pour mon jeu.
Encore bravo !
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum