❤ 0 Auteur : Fabien
Logiciel : RPG Maker XP
Nombre de scripts : 1
Installation
A placer au-dessus de Main.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
| # Lumières Dynamiques Version 2c
# Un script imaginé, conçu et réalisé par Fabien - fabien_35@hotmail.com
# Pour utiliser ce script: appeler ecran_à_trouer
# suivi des fonctions lums ( pour des lumières qui peuvent bouger et s'animer)
# et des fonctions lumsF( pour le lumières qui sont fixes)
# le tout peut se faire dans un "inserer script", dans un évent,
#il faut seulement que le code ne soit pas relu plusieurs fois. ( à l'aide d'un intérrupeur local par ex)
# pour ceux qui voudrait toucher un peu, il y a un seul sprite pour tout,
#vous pouvez le manipuler comme n'importe quel sprite , sa variable étant $lum.img
#les lumières sont stockées dans @lums sous la forme [nom,op,x,y]
#@lums est un hash, et la clé est l'id donné au début.
#si x et y valent nil, le code prend comme coordonées celle de l'évent de numéro égal à cette clé.
# $lums.lums[2][3]+=10 induira par exemple une augmentation de l'opacité de la lumière sur l'event 2.
# on peut de cette manière animer à volonté les lumières.
# fonctions utiles.
def ecran_à_trouer(fond=Color.new(255,255,255),fixes=false, opacité=255)
if $lum.is_a?(Lumières_dynamiques)
$lum.img.bitmap.dispose
end
$lum=Lumières_dynamiques.new(fond,fixes,opacité)
end
#---------------------------------------------------------------------
def lum(nom,id=0,op=255,x=nil,y=nil)
$lum.lums[id]=nom,op,x,y
end
#---------------------------------------------------------------------
def lumF(nom,id=0,op=255,x=nil,y=nil)
$lum.ajout_lumF(nom,id,op,x,y)
end
#---------------------------------------------------------------------
#---------------------------------------------------------------------
class Lumières_dynamiques
attr_accessor :lums
attr_accessor :img
attr_accessor :periode
#---------------------------------------------------------------------
def initialize(fond,fixes,opacité)
@mode= fond.is_a?(Color) ? fixes ? 2 : 1 : 3
#1=Fond 640*480 monocolore : s'enclenche si fond est un tableau
#2=Fond de la taille de la map monocolore, pour porter des lumières fixes: si fond n'est pas un tableau et que fixes est true
#3=Fond image stocké dans le répertoire \pictures : si fond n'est pas un tableau et que fixes est false
case @mode
when 1
@bmp=Bitmap.new(640,480)
@couleur=fond
when 2
@bmp=Bitmap.new($game_map.width*32,$game_map.height*32)
@bmp.fill_rect(@bmp.rect,fond)
when 3
@bmp=RPG::Cache.picture(fond)
end
@lums=Hash.new # chaque lumière est ainsi: [nom,id,op]. Elles sont stockées dans @lums.
@img=Sprite.new
@img.opacity=opacité
@img.bitmap=Bitmap.new(640,480)
@img.blend_type=2
@img.z=10
@id_map=$game_map.map_id # mémorisation de l'id map
@periode=1
maj
end
#---------------------------------------------------------------------
def maj
if Graphics.frame_count%@periode !=0 then return end
@img.visible=true
if not @id_map==$game_map.map_id # Si on a changé de map
if @img.visible then @img.visible=false end# On éfface tout
return #et on ne met plus à jour
end
@id_map=$game_map.map_id
case @mode
when 1 # dans le premir mode on éfface avec une couleur unie
@img.bitmap.fill_rect(@img.bitmap.rect,@couleur)
when 2..3 # dans le second on remplace par le fond standard enregistrés dans @bmp
rect=Rect.new($game_map.display_x/4,$game_map.display_y/4,640,480)
@img.bitmap.blt(0,0, @bmp,rect)
end
for lum in @lums
image=RPG::Cache.picture(lum.at(1).at(0))
if lum.at(1).at(2) == nil
if lum.at(0).is_a?(Array)
id=lum.at(0).at(0)
else
id =lum.at(0)
end
if id==0
x,y=$game_player.screen_x,$game_player.screen_y
else
x,y=$game_map.events[id].screen_x,$game_map.events[id].screen_y
end
else
x,y=lum.at(1).at(2),lum.at(1).at(3)
end
if x-image.width/2<640
if y-image.height/2<480
if x+image.width/2>0
if y+image.height/2>0
@img.bitmap.blt(x-image.width/2,y-image.height/2,image,image.rect,lum.at(1).at(1))
end
end
end
end
end
end
#---------------------------------------------------------------------
def ajout_lumF(nom,id,op,x,y)
if not @mode ==1
img=RPG::Cache.picture(nom)
tx,ty=img.width, img.height
if x== nil
if id==0
x,y=$game_player.screen_x,$game_player.screen_y
else
x,y=$game_map.events[id].screen_x,$game_map.events[id].screen_y
end
end
@bmp.blt(x-tx/2,y-ty/2,img,img.rect,op)
else
p "les lumières dynamiques ne sont pas configurées pour les lumières fixes. "
p "Pour utiliser cette fonction, donnez true en 3eme argument de ecran_à_trouer"
end
end
#---------------------------------------------------------------------
end
#---------------------------------------------------------------------
#---------------------------------------------------------------------
class Scene_Map
alias base_update update
def update
base_update
if $lum.is_a?(Lumières_dynamiques) then $lum.img.disposed? ? $lum=nil : $lum.maj end
end
end
#---------------------------------------------------------------------
#--------------------------------------------------------------------- |
Utilisation normale
Voila maintenant comment vous servir de ce code :
Pour déclarer que vous voulez assombrir l'écran (on l'assombrit pour pouvoir ensuite l'éclairer bien sur) il suffit de faire "insérer script" dans un event en proc parallèle et d'écrire:
ensuite, en dessous, vous pouvez mettre vos lumières. A chaque fois que vous voulez en ajouter une, écrivez:
nom est le nom du fichier de votre lumière, qui doit être dans le dossier pictures de votre jeu,
et id est le numéro de l'évent sur lequel vous voulez afficher cette lumière. Si vous ne le connaissez pas, double-cliquez sur votre évent: l'id est inscrit dans la barre bleu en haut de la fenetre de l'event.
Maintenant créez une boucle et mettez dedans une commande "attendre" de une frame. ( ces commandes sont sur la première page des commandes, première colonne)
On peut également utiliser des intérrupteur locaux, mais je le déconseille car si vous revenez plus tard sur la map après l'avoir quitté vos intérrupteurs seront toujours activés et vous aurez des problèmes. A utilser seulement si vous comprenez bien les ch
Vous pouvez faire un test.
Evitez de mettre trop de lumières au même endroit ou ça risque de ramer. Evitez aussi les trop grosses lumières.
Ah une dernière chose: les images de lumières. Pour commençer vous pouvez prendre les images présentes dans la démo,
mais si vous voulez en faire de nouvelles, sachez qu'il faut que la zone à éclairer soit noire, et tout le reste soit transparent.
La transparence est obligatoire pour que le script fonctionne. Vous pouvez changer du noir à une autre couleur, dans quel cas votre lumière éclairera de la couleur complémentaire : rouge>cyan ; bleu> jaune ; magenta>vert , etc. Faîtes des éssais.
Donc si vous voulez afficher une image telle quelle, vous devez inverser ses couleurs. Regardez dans la démo ci-dessous pour exemple, ce n'est pas compliqué mais je ne saurais pas l'expliquer simplement.
Utilisatation avancée
Cela n'est cependant que l'éffet de base. On peut aller plus loin et faire bien plus.
Je vais maitenant décrire un peu plus en détail les possibilités, mais celà va être un peu plus difficile. Si vous n'y comprenez rien, vous pourrez vous contentez d'utiliser la méthode simple que j'ai décrit ci-dessus.
Lorsqu'on appelle ecran_à_trouer, on peut ne lui donner aucun argument. Mais on peut aussi lui en donner un, deux ou trois.
la liste de ces arguments est : couleur,fixes et opacité
couleur doit être un objet Color, je rappelle que Color.new prend 4 argument qui sont la valeur de rouge entre 0 et 255, la valeur de vert, de bleu, et la valeur d'opacité. Cette couleur sera celle de votre fond, de l'obscurité... a une petite nuance près : les couleurs sont inversées. Le blanc devient noir, le rouge devient bleu clair,le vert devient magenta, etc... ( regardez mon avatar, les couleurs opposées sont l'une en face de l'autre. ). Pour trouver la couleur que vous désirez sans vous fatiguer les neurones, déssinez là dans un logiciel de déssin et prenez le négatif de votre image. Relevez le code RVB de la couleur obtenue et reportez le dans le Color.new avec l'opacité voulue.
Bref par exemple écrire :
1
| ecran_à_trouer(Color.new(0,255,255,200)) |
plongera le joueur dans un brouillard rouge.
Par défaut, si vous ne donnez pas cet argument, il vaut Color.new(255,255,255,255), ce qui fait un noir totalement opaque.
fixes ne peut prendre que deux valeurs : true ou false. Celà détermine si on a le droit d'utiliser des lumières fixes, dont je parlerais plus bas. Pour l'activer on fait donc :
1
| ecran_à_trouer(Color.new(0,255,255,200),true) |
ce qui n'a pas d'éffet visible, mais sera utile ensuite.
Par défaut, si vous ne précisez pas cet argument, il vaut false.
opacité est tout simplement l'opacité de la nuit, de 0 à 255. Par exemple on pourra la mette à 0, la nuit sera alors invisible, et l'augmenter plus tard pour simuler la tombée de la nuit.
1
| ecran_à_trouer(Color.new(0,255,255,200),true,100) |
dans cet exemple le rouge de la nuit est devenu presque transparent.
A propos de lum maintenant. Cette fonction aussi peu prendre d'autres arguments:
vous pouvez donc vous passer d'écrire des trois derniers si vous voulez, dans quel cas leur valeur respectives seront 255,nil et nil.
op est l'opacité de cette lumière: une lumière de faible opacité éclaira peu, à 255 la lumière éclairera au maximum.
x et y sont des coordonées écran. si elles valent nil comme c'est le cas par défaut, le code n'en tient pas compte et affiche la lumière sur l'évent dont l'id a été donné. Si vous donnez des valeurs, la lumière sera affichée à ces coordonées sur l'écran.
Je rappelle que pour fixer un objet sur la map à partir de ses coords écran( pour qu'il se déplace en même temps que la carte), on soustrait $game_map.display_x/4 et $game_map.display_y/4 aux coordonées.
Sachez que même si vous utilisez x et y, l'id n'est pas inutile pour autant car dans le code cet id est le nom de votre lumière. D'ailleurs, si vous donnez x et y, vous pouvez donner "bidule-truc" ou " Jean-Marc" comme id à cette lumière, celà ne fera rien.
Connaitre l'id de sa lumière est en tout cas indispensable pour pouvoir l'animer ensuite, donc il faut vous souvenir de ce que vous avez donné.
Maintenant un autre point: les lumières fixes. Ce script le lague pas particulièrement avec un cinq ou dix lumières se déplacant à l'écran, si elle sont de tailles raisonnables. Cependant on a parfois envie d'avoir beaucoup plus de lumière, et celà peu poser problème.
Pour celà il y a une solution: les lumières fixes. Ce sont des lumières qui ne peuvent pas être animées, qui ne peuvent même pas se déplacer, mais qui ne consomment aucune puissance. Aucune. Pour créér une lumière fixe, vous devez appellez
C'est exactement les mêmes arguments que pour la fonction lum, reportez vous à ce que j'ai écrit ci-dessus.
Par contre il faut avoir préciser dès le début que l'on avait l'intention d'utiliser des lumières fixes, en donnant true comme second argument de ecran_à_trouer .
Sachez que ceci bascule le code dans un mode de fonctionnement interne différent, qui consomme légérement plus de puissance. Rien de bien important, celà ne se voit généralement pas, mais bon une fps c'est une fps, donc j'ai mis un intérrupteur. D'autant puis que ce mode prend plus de puissance sur une grande carte.
Il existe un autre mode : le fond en image. Au lieu de mettre un fond uni vous pouvez mettre une image.
Pour celà il suffit de mettre le nom de votre image à la place de la Color, dans ecran_à_trouer.
Comme ceci :
1
| ecran_à_trouer("brouillard") |
Celà peut être utile à plusieurs choses, par exemple de la brume ou l'on ne voit qu'à 3 pas devant soi, sauf autour des lampadaires, etc... On peut utiliser les lumières fixes dessus.
Mais n'ayant pas testé ni develloppé cette fonction, je ne saurai vous dire comment elle va réagir et donc vous déconseille son utilisation. Son amélioration fera peut-être l'objet d'une version ultérieure du script. Quoi qu'il en soit, vous pouvez vous mettre en Color.new(0,0,0,0),fixes=true et afficher un grand panorama en lumière fixe, celà reviendra au même et vous êtes sur que ça marche.
Un dernier point, mais pas des moindes : animer votre lumière.
vous pouvez accéder aux informations concercant vos lumières: elles sont stockées dans le Hash $lum.lums
Pour accéder à la lumière affichée sur l'évent 23, vous devez écrire
cet objet-ci est un tableau de cette forme
vous pouvez donc modifiez ces valeurs à votre guise, de cette manière :
1
| $lum.lums[id]=[nouveau_nom,nouvelle_op,nouveau_x,nouveau_y] |
vous pouvez modifier les paramètres un par un comme dans n'importe que tableau :
$lum.lums[id][0] désigne le nom , $lum.lums[id][2] désigne x
Les possiblités d'animation sont vastes: changer le nom permet de faire plusieurs étapes d'animation à la lumière,
ou encore un faisceau de torche qui est tourné dans la même direction que le héros.
Changer l'opacité permet de faire une lumière vacillante :
1
| $lum.lums[id][1]=255-rand(50) |
ou encore qui s'allume et s'éteind :
1
| $lum.lums[id][1]=120+120*Math.cos(Graphics.frame_count/200.0) |
(peu importe les équations, c'est juste illustrer le principe)
Changer le x et le y permet de déplacer l'image à volonté, par exemple en cercle autour du héros,( pour des lucioles)
1
2
| $lum.lums[id][2]=$game_player.screen_x+64*Math.cos(Graphics.frame_count/200.0)
$lum.lums[id][3]=$game_player.screen_y+64*Math.sin(Graphics.frame_count/200.0) |
voilà... il n'y a pas de possibilités de changer l'id de la lumière une fois qu'elle a été créée, mais on peut la détruire grâce à :
et ensuite en refaire une autre.
Rajouts et blabla divers
Rajout 1 : le principe du script est de faire des trous dans un écran placé devant la carte. Celà est donc adapté pour de la lumière perçant la nuit. Cependant le principe est tout à fait adaptable pour éclairer en plein jour, avec de la lumière colorée ou blanche.
Pour celà écrivez simplement
Il faudra cependant que vos images de lumière soit blanches sur fond transparent ( au lieu de noir sur fond transparent) car les couleurs ne sont plus inversés. Celà dit, celà n'a plus trop d'intéret par rapport à faire des sprites normaux. Sinon que c'est déjà organisé et programmé pour suivre les events tout seul, ce qui peut être pas mal pour les débutants...
Rajout 2 : Il est très possible qu'avec un peu trop de lumière, par exemple comme dans la démo, celà rame à mort chez vous.
Il y a une parade simple à celà: baisser la fréquence de mise à jour. Mettez cette variable :
sur des valeurs supérieures à 0. Par défaut elle est à 1, mais plusec le chiffre est elevé moins celà ramera. Cependant cela induira des saccades désagréables au-delà de 2 ou 3, donc... (dans la démo la pièce d'échec vous permet ce réglagle).
|
Chat
