[VX] Opacité progressive et Gestionnaire

Maire Lv.9 Age : 37 Inscrit le : 04/02/2009 Messages : 326

Opacité progressive et Gestionnaire

-Introduction

J'ai remarqué que je n'étais pas le seul à rechercher l'économie de place sur une map. Les murs sont épais, si on y ajoute le toit, si le mur fait 2 de haut. La place perdue est énorme. De plus, cette épaisseur occasionne pas mal de problème de logique. C'est dans la même optique que la passabilité de contours, sauf que là on s'occupe de l'opacité des events.

-Description

Ce script permet de modifier l'opacité des events en fondu (par défaut en 30 frames). J'avais déjà fait la remarque que la modification d'opacité de l'éditeur était moche car brutale. Je vous présente ma solution.
Ce script est un peu plus que ça. Généralement les events utilisés pour substituer des murs, des toits, doivent changer d'opacité sous certaines conditions. Les déclencheurs sont généralement des events sur le sol, ou un horrible event parallélle. Sur une map de ville, ça devient vite mission impossible, avec tout les toits, les murs... par expérience ça devient vite trop compliqué.
Ce script permet de mettre les conditions de changement d'opacité dans l'event même, par l'intermédaire des commentaires.
Ce script contient les conditions les plus réccurantes: si player.x> cste... si player dans le rectangle A... Cependant, l'interpréteur est suffisament simple et flexible pour vous permettre d'y inclure vos conditions propres: si switch[] = true... ou je ne sais quoi.
Je vais vous montrez plus loin comment ajouter des conditions au script.

-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.

-Utilisation

Après l'avoir installé, faites votre petit event et glisser lui un premier commentaire:

OPACITY CODE 125 xxxxx

OPACITY CODE permet au script de reconnaitre la demande.
Cela signifie qu'après il y a l'opacity recherchée puis le code de la condition d'application...
La syntaxe est rigide donc attention aux espaces.
125 correspond dans l'exemple à l'opacité voulue. L'opacité est toujours en 3 chiffres ou on laisse des espaces vides. La position dans la chaine est très importante.
Le code (xxxxxx ) peut être n'importe quoi pourvu que l'interpréteur du script le connaisse. C'est un identifiant. C'est donc grâce à cela que vous pouvez mettre les mains dans le camboui et ajouter vos identifiants.

Avant regardons, le deuxième commentaire à mettre à la suite:
OPACITY PARAM xx xx xx xx

[justify]OPACITY PARAM permet au script de reconnaitre la demande.
(xx xx xx xx ) sont des paramètres tiers que vous utiliserez pour les conditions. Par tiers, j'entend qui n'exitent pas en tant que variables dans le jeu, des constantes contrairement aux coordonées du player. La synthaxe est importante, c'est une boucle qui lit la ligne. Un paramètre pour elle, a 2 caratères (Je me confonds en excuses... pas de nombre à trois chiffres, je trouvais cela marginal, les map sont rarement de plus de 99), et ils sont espacés d'un espace. Si votre paramètre ne fait que 1 caractère, mettez un espace à la place des dizaines. (xx x xx xx ). Les paramètres sont stockés dans un tableau de tableau de tableau, car les paramètres sont relatif à l'event @tab[i][2].
Voilà pour les paramètres

Revenons au code. Dans le fond, le code n'est qu'un identifiant. La partie du code à modifier s'appelle "interpreter":

Spoiler:

C'est assez simple (du moins tout dépend de votre conditon à placer). A chaque code, correspond un when, et dans chaque when, il y a Apply. Cette méthode applique les changements en fonction la condition:

Code:: when "Xp>P[0]"
Apply( ($game_player.x > @tab[i][2][0]) ,i,time)

"Xp>P[0]" est le code, c'est un identifiant.
($game_player.x > @tab[i][2][0]) est la fameuse condition:
@tab[i][2][0] est le premier paramètre de notre tableau de toute à l'heure.
(attention à ne pas vouloir accéder à des cases inexistantes)

Pour faire simple: il suffit d'intercaller un nouveau when "votre identifiant" suivi d'Apply( votre condition, i, time)
Ca reste assez simple.

Je vous invite à aller lire le cours de Miraino Hikari pour rédiger vos conditions.

Edit du 22/09/09: un mini module a été ajouté avec la possibilité de modifier le temps de fondu par défaut simplement et le rayon de l'update.

Maire Lv.9 Age : 37 Inscrit le : 04/02/2009 Messages : 326

-Crédit: Vincentmhd

-La démo

Démo légère
Démo plus lourde (Démos non à jour)

-Le script

Code:: #===============================================================================
#
#
# Fade Opacity.v2
#
#
#===============================================================================
#
#By Vincentmhd
#http://vincentmhdmaker.canalblog.com/
#
#01/09/2009 - .v0 creation
#22/09/2009 - .v1 optimisation anti-lag
#08/11/2009 - .v2 modification nom de module OPACITY
#
#
#
#=====================================NOTE======================================
#
#
#
#-------------------------------------------------------------------------------
#
#
#Ce script permet de changer l'opacité progressivement. Par défault, il change
#les opacités en 30 frames. C'est suffissant observer pour la progression...
#La méthode crée peut-être appellée par script et le temps de fade changé, il
#est en second argument de la méthode.
#
#
#
#Le plus intéressant du script est son gestionnaire d'opacité:
#Ce script permet de gérer les opacités des maps de manière induite
#pour qu'un event devienne translucide selon la position du héros.
#
#Il y a 2 commentaires à inserer dans l'event pour cela:
#Le premier:
#
#OPACITY CODE 125 Xp>P[0]
#
#Ce commentaire donne l'opacité escontée et le code de la condition de changement
#d'opacité.
# + 125 correspond à l'opacité escontée, elle est toujours en 3 chiffres.
# + Le code correspond à la chaine après l'espace suivant 125.
#Pour le moment, l'interpreter ne connait pas beaucoup de formule. Les besoins
#de chacun sont differents et plus l'interpreteur sera long moins le script se
#sera rapide à l'execution, donc, je préfère vous laisser finir de compléter
#l'interpreteur. Ca ne demande pas beaucoup de connaissance en script.
#La méthode se trouve à partir de la ligne 145.
#
#
#Le second commentaire:
#
#OPACITY PARAM 34 07
#
#Ce commentaire contient les paramètres des conditions.
#X et Y sont des paramètres exterieurs. Ils sont contenus dans array.
#sa taille varie selon le nombre d'arguments présents dans le commentaire:
#
#
#OPACITY PARAM 20 07 5 34 12 49
#
#donnera [20, 7, 5, 34, 12, 49]
#-------------------------------------------------------------------------------
module OPACITY_DATA
Default_time = 30 #temps du fondu par défault en frame
UpDate_rayon = 20 #côté du rectangle autour du player "Updaté"
end

#==============================================================================#
# #
# Gestionnaire d'opacités #
# #
#==============================================================================#
class Gst_Opacity

attr_accessor :tab

def initialize
@tab = []
end

#------------------------------------------------------------------------------#
#Appelée dans la setup map, vide puis complète le tableau du gestionnaire. #
#------------------------------------------------------------------------------#
def setup
@tab = []
for event in $game_map.events.values
next if event.list == nil
code = ""
for i in 0...event.list.size
if event.list[i].code == 108
a = ""
a = event.list[i].parameters.to_s
#Reconnaissance de
if a[0,12] == "OPACITY CODE"
target = a[13, 3].to_i
code = a[17, a.size - 17].to_s
end
param = []
if a[0,13] == "OPACITY PARAM"
n = 14
j = 0
while (a[n]!= nil)
param[j] = a[n,2].to_i
j+=1
n+=3
end
if (code != "")
@tab += [[event.id,code,param,nil,target]]
end
end
end
end
end
update(true,0)
end

#------------------------------------------------------------------------------#
#Met à jour les opacités des events sur la map. #
#------------------------------------------------------------------------------#
def update( init = false ,time = OPACITY_DATA::Default_time)
for i in 0...@tab.size
if ((init)||(($game_map.events[@tab[i][0]].x - $game_player.x).abs <= OPACITY_DATA::UpDate_rayon)||(($game_map.events[@tab[i][0]].y - $game_player.y).abs <= OPACITY_DATA::UpDate_rayon))
interpreter(i,time)
end
end
end
#------------------------------------------------------------------------------#
#Applique les changements #
#------------------------------------------------------------------------------#
def Apply(cond,i,time = OPACITY_DATA::Default_time)
if (@tab[i][3] == nil)
@tab[i][3] = cond
end
if (cond)
if (@tab[i][3] == true)
$game_map.events[@tab[i][0]].op_Change(@tab[i][4], time)
@tab[i][3] = false
end
else
if (@tab[i][3] == false)
$game_map.events[@tab[i][0]].op_Change (255, time)
@tab[i][3] = true
end
end
end
#------------------------------------------------------------------------------#
#Vérifie si les conditions sont atteintes et applique les changements #
#------------------------------------------------------------------------------#
def interpreter( i, time = OPACITY_DATA::Default_time)
case @tab[i][1].to_s
when "Xp>P[0]"
Apply( ($game_player.x > @tab[i][2][0]) ,i,time)
when "Xp<=P[0]"
Apply( ($game_player.x <= @tab[i][2][0]) ,i,time)
when "Yp<=P[0]"
Apply( ($game_player.y <= @tab[i][2][0]) ,i,time)
when "Yp>P[0]"
Apply( ($game_player.y > @tab[i][2][0]) ,i,time)
when "C"
#Dans le rectangle
Apply( ((($game_player.x >= @tab[i][2][0])&&($game_player.x <= @tab[i][2][1])&&($game_player.y >= @tab[i][2][2])&&($game_player.y <= @tab[i][2][3]))) ,i,time)
when "CC"
#Dans le rectangle A ou B
Apply( (((($game_player.x >= @tab[i][2][0])&&($game_player.x <= @tab[i][2][1])&&($game_player.y >= @tab[i][2][2])&&($game_player.y <= @tab[i][2][3]))||(($game_player.x >= @tab[i][2][4])&&($game_player.x <= @tab[i][2][5])&&($game_player.y >= @tab[i][2][6])&&($game_player.y <= @tab[i][2][7])))) ,i,time)
when "C-C"
#Dans le rectangle A mais pas dans B
Apply( (((($game_player.x >= @tab[i][2][0])&&($game_player.x <= @tab[i][2][1])&&($game_player.y >= @tab[i][2][2])&&($game_player.y <= @tab[i][2][3]))&&!(($game_player.x >= @tab[i][2][4])&&($game_player.x <= @tab[i][2][5])&&($game_player.y >= @tab[i][2][6])&&($game_player.y <= @tab[i][2][7])))) ,i,time)
else
#rien...
end
end

end

#==============================================================================#
# #
# Modification de Character #
# #
#==============================================================================#
class Game_Character
attr_accessor :target_Op, :Op_count

#Modification de l'initialize
alias op_initialize initialize
def initialize
op_initialize
@target_Op = 255
@Op_count = 0
end

#Création de méthode de changement d'Opacité
def op_Change (op , duration = OPACITY_DATA::Default_time)
@Op_count = duration
@target_Op = op
if @Op_count == 0
@opacity = op
end
end

#Il n'y a qu'une ligne à modifier mais impossible en alias...
#------------------------------------------------------------------------------
# * Move Type : Custom
#------------------------------------------------------------------------------
def move_type_custom
if stopping?
command = @move_route.list[@move_route_index] # Get movement command
@move_failed = false
if command.code == 0 # End of list
if @move_route.repeat # [Repeat Action]
@move_route_index = 0
elsif @move_route_forcing # Forced move route
@move_route_forcing = false # Cancel forcing
@move_route = @original_move_route # Restore original
@move_route_index = @original_move_route_index
@original_move_route = nil
end
else
case command.code
when 1 # Move Down
move_down
when 2 # Move Left
move_left
when 3 # Move Right
move_right
when 4 # Move Up
move_up
when 5 # Move Lower Left
move_lower_left
when 6 # Move Lower Right
move_lower_right
when 7 # Move Upper Left
move_upper_left
when 8 # Move Upper Right
move_upper_right
when 9 # Move at Random
move_random
when 10 # Move toward Player
move_toward_player
when 11 # Move away from Player
move_away_from_player
when 12 # 1 Step Forward
move_forward
when 13 # 1 Step Backwards
move_backward
when 14 # Jump
jump(command.parameters[0], command.parameters[1])
when 15 # Wait
@wait_count = command.parameters[0] - 1
when 16 # Turn Down
turn_down
when 17 # Turn Left
turn_left
when 18 # Turn Right
turn_right
when 19 # Turn Up
turn_up
when 20 # Turn 90° Right
turn_right_90
when 21 # Turn 90° Left
turn_left_90
when 22 # Turn 180°
turn_180
when 23 # Turn 90° Right or Left
turn_right_or_left_90
when 24 # Turn at Random
turn_random
when 25 # Turn toward Player
turn_toward_player
when 26 # Turn away from Player
turn_away_from_player
when 27 # Switch ON
$game_switches[command.parameters[0]] = true
$game_map.need_refresh = true
when 28 # Switch OFF
$game_switches[command.parameters[0]] = false
$game_map.need_refresh = true
when 29 # Change Speed
@move_speed = command.parameters[0]
when 30 # Change Frequency
@move_frequency = command.parameters[0]
when 31 # Walking Animation ON
@walk_anime = true
when 32 # Walking Animation OFF
@walk_anime = false
when 33 # Stepping Animation ON
@step_anime = true
when 34 # Stepping Animation OFF
@step_anime = false
when 35 # Direction Fix ON
@direction_fix = true
when 36 # Direction Fix OFF
@direction_fix = false
when 37 # Through ON
@through = true
when 38 # Through OFF
@through = false
when 39 # Transparent ON
@transparent = true
when 40 # Transparent OFF
@transparent = false
when 41 # Change Graphic
set_graphic(command.parameters[0], command.parameters[1])
when 42 # Change Opacity
op_Change(command.parameters[0])
when 43 # Change Blending
@blend_type = command.parameters[0]
when 44 # Play SE
command.parameters[0].play
when 45 # script
eval(command.parameters[0])
end
if not @move_route.skippable and @move_failed
return # [Skip if Cannot Move] OFF & movement failure
end
@move_route_index += 1
end
end
end

#UpDate de l'opacité
def op_update
if @Op_count>0
d = @Op_count
@opacity = (@opacity * (d - 1) + @target_Op) / d
@Op_count -=1
end
end

#Modification de l'upDate globale
alias opacity_update update
def update
opacity_update
op_update
end
end

#==============================================================================#
# #
# Modification du Player #
# #
#==============================================================================#
class Game_Player
attr_accessor :x, :y
#utilisée seulement en téléportation
alias mhd_op_moveto moveto
def moveto(x, y)
mhd_op_moveto(x,y)
$game_opacity.update()
end

alias mhd_trans reserve_transfer
def reserve_transfer(map_id, x, y, direction)
mhd_trans(map_id, x, y, direction)
$game_player.x =x
$game_player.y =y
end

#surcharger les commandes de mouvements du player... toutes!
alias op_move_down move_down
def move_down(turn_ok = true)
op_move_down(turn_ok)
$game_opacity.update()
end

alias op_move_left move_left
def move_left(turn_ok = true)
op_move_left(turn_ok)
$game_opacity.update()
end

alias op_move_right move_right
def move_right(turn_ok = true)
op_move_right(turn_ok)
$game_opacity.update()
end

alias op_move_up move_up
def move_up(turn_ok = true)
op_move_up(turn_ok)
$game_opacity.update()
end

alias op_move_lower_left move_lower_left
def move_lower_left
op_move_lower_left
$game_opacity.update()
end

alias op_move_lower_right move_lower_right
def move_lower_right
op_move_lower_right
$game_opacity.update()
end

alias op_move_upper_left move_upper_left
def move_upper_left
op_move_upper_left
$game_opacity.update()
end

alias op_move_upper_right move_upper_right
def move_upper_right
op_move_upper_right
$game_opacity.update()
end
end

#==============================================================================#
# #
# Création du gestionnaire #
# #
#==============================================================================#
class Scene_Title
alias opacity_create_game_objects create_game_objects
def create_game_objects
opacity_create_game_objects
$game_player.x =$data_system.start_x
$game_player.y =$data_system.start_y
$game_opacity = Gst_Opacity.new
end
end

#==============================================================================#
# #
# Mise à jour du Gestionnaire à la Map #
# #
#==============================================================================#
class Game_Map
alias op_setup_events setup_events
def setup_events
op_setup_events
$game_opacity.setup
end
end

Maire Lv.9 Age : 37 Inscrit le : 04/02/2009 Messages : 326

Nouvelle version!

Elle est beaucoup plus rapide, même si elle était déjà rapide. (plus rapide c'est, c'est mieux c'est non?)
En fait, avant le gestionnaire parcourrait tout les events de la map à chaque mouvement du Player.
Maintenant, elle ne vérifie plus que les events proches parmis les events de la map ayant les commentaires spécifiques au script. Les events proches sont les events contenus dans un rectangle de 40 x 40 tiles (par défaut), centré sur le player. Le côté du rectangle est facilement accessible dans un module, juste sous l'en-tête.

L'opacité conditionnelle se définie dans l'event en commentaire aussi. (Je l'ai fait car certains events peuvent être fondus en 125, en 0 ou autre valeur... en 0 cela peut servir à réaliser une compétence de détection des Invibles, avec une condition basée sur un game_switch par exemple.

L'interpréteur est beaucoup beaucoup plus clair, avec la fonction Apply.

Sujet: Re: [VX] Opacité progressive et Gestionnaire Mar 22 Sep 2009 - 13:39

Merci beaucoup =D (mais c'est possible d'avoir un screen?).
*donne des points*

Flibustier Lv.21 Age : 30 Inscrit le : 24/05/2008 Messages : 3234

Bizarre ton appel de script..
Tu ne fais intervenir que $game_player.x > i
Et le reste alors ^^'
Il nous manque

Code:: $game_player.x <i
$game_player.y > i
$game_player.y < i

Pour que nous sachions avec exactitude où doit se faire la modif ^^

Sinon bon script, bien que assez chian à mettre en oeuvre (le nombre d'event juste pour une simple maison >.>)

PS : Je télécharge car j'ai un doute sur la fonction de ton script x]
Je te dis après si c'est bon !

EDIT : Nan c'est bon c'est bien ce que je disais =3

Maire Lv.9 Age : 37 Inscrit le : 04/02/2009 Messages : 326

Je me suis peut-être mal exprimé, il n'y a pas d'appel de script à faire. Pour avoir un event qui change d'opacité selon une condition, il suffit de lui mettre les commentaires adéquats.

Pour ajouter des conditions, c'est le script en lui-même qui est à modifier, mais j'ai essayer de simplifier la chose, en allégeant la partie à modifier: l'interpreteur (ligne 145).

Spoiler:

L'interpréteur contient déjà les conditions les plus récurrantes (en reprenant ta syntaxe):
$game_player.x >i
$game_player.x <=i
$game_player.y > i
$game_player.y <=i
Si dans le rectangle ijkl, le code est C
"($game_player.x >i && $game_player.x" < j && $game_player.y >" k && $game_player.y < l )"
et
Si dans le rectangle ijkl ou dans le rectangle i'j'k'l', le code est CC
"($game_player.x >i && $game_player.x < j && $game_player.y >k && $game_player.y <" l)||($game_player.x ">i' && $game_player.x <"j' && $game_player.y ">k' && $game_player.y < l' )"

i j k l i' j' k' l' sont stockés dans un tableau de tableaux de tableaux d'où sa tête peu avenante: @tab[i][2][index du paramètre voulu]

La fonction Apply prend en argument la condition, l'iterateur, et le temps de modification. C'est la condition que vous pouvez tranformer à votre guise.

Pour le nombre d'events... soit il faut être courageux, soit il faut se faire de gros CharacterSet avec des bouts entiers de la maison... généralement je fais du 3x3 et parfois plus, en 3 voir 4 events tu obtiens ta maison au lieu de 27... l'économie n'est pas des moindres. Cependant cela représente un espace mémoire un peu plus important, mais pas énorme...

Je ne met pas à jour les démos, je vous met un lien vers mon projet qui me sert de test pour mes scripts. Lourd mais d'une pierre 1, 2 ,3 coups!

>>Mon atelier de script

Edit::

J'y ai repensé...
En fait oui, tu peux changer l'opacité sans passer par le gestionnaire en appel, cependant la commande d'event de VX permenttant de changer l'opacité est surchargée pour le faire en fondu pendant le temps par défaut donc elle reste plus pratique. Par contre dans l'appel, tu peux passer en arguments le temps du fondu.
op_change(opacité, frames)

Sinon j'ai réfléchi, je peux facilement faire une méthode pour ajouter un event au gestionnaire en appel. Cependant la condition doit pré-exister dans l'interpréteur.

Flibustier Lv.21 Age : 30 Inscrit le : 24/05/2008 Messages : 3234

Ah ok =)

Bonne continuation ^^

» Un gestionnaire d'objet
» Gestion de projet : gestionnaire de versions

[VX] Opacité progressive et Gestionnaire

[VX] Opacité progressive et Gestionnaire

Sujets similaires

Sujets similaires