[SaniOKh]

TUTO PAR SANIOKHBon, face à des nombreuses questions des débutants dans le making qui veulent faire leur propre Zelda sur RPG Maker 2000/2003, je préfère mettre un peu du mien en espérant que ça les aidera.
Alors, comment faire...
LE SYSTEME A-RPG et ANIMATIONS D'EPEE
Je commence tout de suite par le système A-RPG.
Ce système nécessitera de prévoir beaucoup de switches et de variables.

• Une variable que j'appelerai [touche] qui servira à détécter quand la touche ESPACE est appuyée.
• Un Switch que j'appelerai [attaque] qui servira à détécter si le perso attaque ou pas.

Puis, pour chaque monstre:

• Une variable [monstre_PV] qui servira de PV au monstre.
• Un switch [monstre_mort] qui détérminera si le monstre est mort ou pas.
• Une variable [monstre_objet] qui détérminera quel objet le héros trouvera sur le cadavre du monstre (enfin... au lieu du cadavre du monstre ).
• Un switch [monstre_objet_pris] qui détérminera si l'objet est pris ou pas.

Tout d'abord, allons bidouiller notre chère base de données. Pour ce faire, un petit coup de F8, puis dans le dernier onglet Common Events (Evénements communs). Allons créer un premier événement commun qu'on appelera [ATTAQUE]. Alors, dans les conditions de départ, on met Parallel Process (Processus Parallèle), puis on entre quelque chose qui ressemble à ça:

Code: [Sélectionner]

<>Detecter Touche [touche]    //Ici, on ne coche que la case 5 ou autre bouton que vous assignerez à l'épée.
<>Attendre 0.0 sec          // au cas où, pour éviter certains bugs
<>Si [touche]=5             //5 ou la valeur que vous avez choisie plus haut
_<>switch [attaque] ON
_<>Attendre 0.3 secondes   // durée optimale... enfin, vous pouvez mettre 0.5 ou 0.1 (pour les plus sados ^^)
_<>switch [attaque] OFF
<>Fin

Pour ceux qui songent à importer des animations de Link qui attaque, rien de plus facile. On est dans la base de données, alors tant qu'à faire, allons gérer les anims.

Je laisse tomber l'étape de création des anims, la plupart d'entre vous savent le faire. Alors, on crée un autre événement commun qu'on appelera [ANIMATION]. En condition de départ, on laisse Appel (Call).

On suppose que les animations de Link en train d'attaquer se nomment (dans un jeu avec deux épées, la normale et l'excalibur): epee1_haut, epee1_bas, epee1_gauche, epee1_droite, epee2_haut, epee2_bas, epee2_gauche, epee2_droite. Dans tous les cas où on appelera ces fonctions, on cochera la case ATTENDRE LA FIN DE L'EXECUTION, et l'animation sera appliquée à l'événement [héros].

Alors, allons créer d'abord la chose pour l'épée 1.

Code: [Sélectionner]

<>si événement [héros] est tourné en haut
_<>afficher animation de combat [epee1_haut]
<>Fin
<>si événement [héros] est tourné en bas
_<>afficher animation de combat [epee1_bas]
<>Fin
<>si événement [héros] est tourné à gauche
_<>afficher animation de combat [epee1_gauche]
<>Fin
<>si événement [héros] est tourné à droite
_<>afficher animation de combat [epee1_droite]
<>FinVoilà ce qui est fait. Mais alors, si Link attaque, on aura toujours l'épée 1 dans sa main! Pas logique! Alors nous allons introduire une nouvelle condition.
Par exemple, l'épée de départ de Link est un objet qui se nomme epee1, la deuxième se nomme epee2, et quand Link récupère une épée, il s'en équippe.

Code: [Sélectionner]

<>si le héros [Link] est équippé avec l'objet [epee2]
_<>si événement [héros] est tourné en haut
__<>afficher animation de combat [epee2_haut]
_<>Fin
_<>si événement [héros] est tourné en bas
__<>afficher animation de combat [epee2_bas]
_<>Fin
_<>si événement [héros] est tourné à gauche
__<>afficher animation de combat [epee2_gauche]
_<>Fin
_<>si événement [héros] est tourné à droite
__<>afficher animation de combat [epee2_droite]
_<>Fin
Sinon:
_<>si le héros [Link] est équippé avec l'objet [epee1]
__<>si événement [héros] est tourné en haut
___<>afficher animation de combat [epee1_haut]
__<>Fin
__<>si événement [héros] est tourné en bas
___<>afficher animation de combat [epee1_bas]
__<>Fin
__<>si événement [héros] est tourné à gauche
___<>afficher animation de combat [epee1_gauche]
__<>Fin
__<>si événement [héros] est tourné à droite
___<>afficher animation de combat [epee1_droite]
__<>Fin
_<>
<>Voilà, on a tout bêtement récopié le code de l'épée 1 en le modifiant un peu.

Des fois, c'est génant de voir l'animation de combat. Par exemple, pendant les cinématiques, sous les CHIPS de la carte qui cachent le perso, ou dans les ménus. Alors, pour empêcher ça, on introduit deux autres switch qu'on appelera [cinématique] qui sera utilisé pour les cinématiques et désactivé par défaut et [recouvert] qui sera utilisé pour les cas où le perso passe par-dessous les chips qui doivent le cacher et sera désactivé aussi.
J'ai encore une petite idée pour embellir tout ça: et si on rendait le héros transparent le temps de l'anim'? Pas mal, quand même . Allez, on fait ça.
A la fin, notre script pour les anims de l'épée sera:

Code: [Sélectionner]

<>si le switch[cinématique] est OFF
_<>si le switch[recouvert] est OFF
__<>Transparence du héros: TRANSPARENT
__<>si le héros [Link] est équippé avec l'objet [epee2]
___<>si événement [héros] est tourné en haut
____<>afficher animation de combat [epee2_haut]
___<>Fin
___<>si événement [héros] est tourné en bas
____<>afficher animation de combat [epee2_bas]
___<>Fin
___<>si événement [héros] est tourné à gauche
____<>afficher animation de combat [epee2_gauche]
___<>Fin
___<>si événement [héros] est tourné à droite
____<>afficher animation de combat [epee2_droite]
___<>Fin
__Sinon:
___<>si le héros [Link] est équippé avec l'objet [epee1]
____<>si événement [héros] est tourné en haut
_____<>afficher animation de combat [epee1_haut]
____<>Fin
____<>si événement [héros] est tourné en bas
_____<>afficher animation de combat [epee1_bas]
____<>Fin
____<>si événement [héros] est tourné à gauche
_____<>afficher animation de combat [epee1_gauche]
____<>Fin
____<>si événement [héros] est tourné à droite
_____<>afficher animation de combat [epee1_droite]
____<>Fin
___<>
__<>Transparence du héros: OPAQUE
__<>
_<>
<>
<>si le switch [recouvert] est ON
_<>Jouer le son [le son qui a servi pour l'animation]
<>FinVoilà. Pas méchant, quand même .

Maintenant allons intégrer tout ça dans le premier événement commun [ATTAQUE].
Voici, le code, pour vous en rappeler:

Code: [Sélectionner]

<>Detecter Touche [touche]
<>Attendre 0.0 sec
<>Si [touche]=5
_<>switch [attaque] ON
_<>Attendre 0.3 secondes
_<>switch [attaque] OFF
<>Fin

Non, non, on ne va pas recopier encore ce gros code... on va tout bêtement appeler son éxécution et virer en même temps le temps (0.3 secondes) pour que la durée de l'attaque corresponde à la durée de l'anim..

Code: [Sélectionner]

<>Detecter Touche [touche]
<>Attendre 0.0 sec
<>Si [touche]=5
_<>switch [attaque] ON
_<>Appeler Evénement: [ANIMATION]
_<>switch [attaque] OFF
<>Fin

Je crois que c'est bon pour les événements communs.
Que ceci ne vous rébute pas , c'est a faire une seule fois, au début.
Minatenant, les monstres mêmes.

Les monstres sont de simples événements, comme les PNJ.
Alors, voilà comment on peut faire un monstre qui attaque.

Tout d'abord, en première page:

Conditions de départ: rien de particulier.
Sprite: le sprite du monstre
Vitesse et fréquence: assez pour qu'il se déplace, quand même
Type de mouvement: vers le héros? Bah, n'importe.
Lancement: Contact événement/héros

Allons maintenant programmer ce monstre.
Si vous vous souvenez, j'ai parlé des deux switch et deux variables qu'on dédiera à chaque monstre? Et bien, c'est ici que nous allons les utiliser.
On prend un exemple, ou à chaque attaque Link perd 1 PV, le monstre idem, et que le monstre est tué après cinq coups.

Code: [Sélectionner]

<>Si [ATTAQUE] est OFF
_<>[Link PV] -1
<>Fin
<>Si [ATTAQUE] est ON
_<>Variable [monstre_PV]+1
_<>Si [monstre_PV] >= 5
__<>Variable [monstre_objet]aléatoire entre 1 et 10
__<> switch[monstre_mort] ON
_<>Fin
<>Fin
<>
Tout ça n'est pas très beau... rajoutons des effets spéciaux ^^ Voici une palette d'effets et de réactions possibles (cette liste est non-exhaustive, en faisant marcher votre imagination, vous en trouverez bien d'autres):

Code: [Sélectionner]

<>Si [ATTAQUE] est OFF
_<>[Link PV] -1

_<>Jouer son [...] //vous pouvez mettre ici un son à jouer quand Link se fait mal
_<>Flasher événement [héros] //Par exemple, quand Link prend un coup, il devient blanc pendant un certain temps.
_<>Afficher animation [..., héros] //comme dans MoS, vous pouvez mettre une animation de "découpage" sur Link quand il se fait toucher, ou comme dans mon jeu, vous pouvez faire une petite mention "-HP" qui apparaît
_<>Sécouer l'écran [...] //comme dans SQ:HS, un peu soulant à force
_<>Déplacer événement [héros]: se tourner à 180°, pas en avant, se tourner à 180° (sans oublier de cocher "ignorer si impossible") //pour éviter que le perso ne se fasse tuer d'entrée sans que vous ne puissiez rien faire, le perso peut s'écarter après chaque coup.

<>Fin
<>Si [ATTAQUE] est ON
_<>Variable [monstre_PV]+1

_<>Jouer son [...] //vous pouvez mettre ici un son à jouer quand un monstre se fait toucher
_<>Flasher événement [cet événement] //en rouge, par exemple
_<>Afficher animation [..., cet événement] //comme dans MoS, vous pouvez mettre une animation de "découpage" sur l'ennemi
_<>Sécouer l'écran [...] //comme dans SQ:HS, un peu soulant à force
_<>Déplacer événement [cet événement]: se tourner à 180°, pas en avant, se tourner à 180° (sans oublier de cocher "ignorer si impossible") //pour éviter que ce soit trop facile ^^

_<>Si [monstre_PV] >= 5
__<>Variable [monstre_objet]aléatoire entre 1 et 10
__<> switch[monstre_mort] ON
_<>Fin
<>Fin
<>

Bon, fini la première page.

Les pages suivantes sont plus faciles à faire: ce sont des pages d'objets.
Selon la variable [monstre_objet] ce sera un objet où un autre... par exemple, le premier objet sera à [monstre_objet]=1, un autre à [monstre_objet]=3 etc. Laissez l'intervalle avec le prochain objet plus grande si vous voulez qu'un monstre laisse un objet plus souvent que les autres.

Chaque page sera... de ce genre:

Conditions de départ: variable[monstre_objet] à une certaine valeur, puis switch [monstre_mort] ON
Sprite: dans chaque cas, le sprite de l'objet
Vitesse et fréquence: immobile
Type de mouvement: n'importe, puisqu'il ne bouge pas
Lancement: toucher

En code:

Code: [Sélectionner]

<>Ajouter objet [objet de votre choix] 1
<>switch [monstre_objet_pris] ON
<>

Si vous voulez que des fois le monstre ne laisse rien, l'avant-dernère page sera comme ça:

Conditions de départ: variable[monstre_objet] à la plus grande des valeurs, puis switch [monstre_mort] ON
Sprite: rien
Vitesse et fréquence: immobile
Type de mouvement: n'importe, puisqu'il ne bouge pas
Lancement: auto ou parallèle

En code:

Code: [Sélectionner]

<>
<>switch [monstre_objet_pris] ON
<>

Puis pour finir en beauté:

Conditions de départ: switch [monstre_mort] ON et switch[monstre_objet_pris] ON
Sprite: rien
Vitesse et fréquence: immobile
Type de mouvement: n'importe, puisqu'il ne bouge pas
Lancement: Toucher ou appui

En code:

Code: [Sélectionner]

<>
<>switch [monstre_objet_pris] ON
<>

Et voilà, c'est fini pour les monstres .
Ainsi que pour le système ARPG et les anims.

LES COEURS
Par exemple, nous avons Link qui perd un coeur à chaque coup ennemi (comme dans MoS). Il a, par exemple, trois coeurs au début (mort après trois coups... pour les sados ^^). Alors, il faudra d'abord bidouiller ses caractéristiques. En "PV Max" mettez le nombre de coeurs que Link a au début du jeu, ici: 3 coeurs. Jusqu'à maintenant, rien de dur.

Tout d'abord, il faudra grapher. Beaucoup. Voire trop.
Au début, faire un support pour votre barre de vie.
Qu'est-ce qu'un support? Par exemple, ça (pris de mon jeu Stareclain Quest: Hidden Spells):


Ou ça (pris du Starter Pack de Xfixfium (même s'il n'utilise pas tout à fait le même procédé)



Le support est le graphisme tel qu'il est quand les vies sont à plat, et surtout quand il y a le moins de choses à afficher à l'écran.

Et voici les parts les plus pénibles: créer des dessins... enfin, voilà le truc:
Pour Zelda, il ne suffit pas de faire une image d'un coeur plein, puis une image d'un demi-coeur... il faudra faire des images des ensembles!
Enfin, bon, un exemple sera plus parlant. Dans cet exemple, Link pourra avoir de 3 à 10 coeurs, et perd un coeur par coup ennemi.
Imaginons que  est un coeur plein et V est un coeur vide. Voici tous les dessins qu'il faudra faire:
VVV
VVVV
VVVVV
VVVVVV
VVVVVVV
VVVVVVVV
VVVVVVVVV
VVVVVVVVVV
 
 
 
 
 
 
 
 
 
 

Eh oui, ce genre de dessins (pardon pour les images, Christopho, mais c'est pour la bonne cause ):




Ca en fait pas mal, hein? 18 dessins... enfin, bon. Imaginons que c'est déjà fait.

Allez, vous avez fait vos dessins.
Maintenant, encore et toujours, allons voir la base des données et nos chers événements communs.
On crée un événement commun [HUD], puis un autre qu'on appelera [COEURS]
Dans [HUD] on met la condition de départ: Appel, puis on met ça:

Code: [Sélectionner]

<>Appeler événement: [COEURS]Pas plus dur.

Maintenant, allons dans [COEURS] ou tout va se corser.
Il nous faudra deux variables que je nommerai [PV] et [PV_max], mais aussi il faudra dédier à la chose deux images. Les images des coeurs vides seront en 1, les images des cours pleins seront en 2, ils auront une couleur transparente (évidemment) seront placés au même endroit (superposés, en fait), suivront l'écran plutôt que la carte et n'auront pas d'effet de mouvement tels que la rotation ou les ondulations.

Considérez que dans ce système, les PV de Lnk correspondent aux coeurs qu'il a en ce moment et ses PV Max correspondent aux receptacles (il m'a toujours fait marrer, ce mot ^^) de coeurs que Link a en tout.

Le codage se fera de cette façon (je suis toujours l'exemple avec les coeurs qui vont de 3 à 10):

Code: [Sélectionner]

<>Effacer image 1
<>Effacer image 2
<>variable [PV]= PV du héros [Link]
<>variable [PV_max]= PV Max du héros [Link]
<>Si variable [PV_max]= 10
_<>Afficher image 1 [10_coeurs_vides]
<>SINON
_<>Si variable [PV_max]= 9
__<>Afficher image 1 [9_coeurs_vides]
_<>SINON
__<>Si variable [PV_max]= 8
___<>Afficher image 1 [8_coeurs_vides]
__<>SINON
___<>Si variable [PV_max]= 7
____<>Afficher image 1 [7_coeurs_vides]
___<>SINON
____<>Si variable [PV_max]= 6
_____<>Afficher image 1 [6_coeurs_vides]
____<>SINON
____<>Si variable [PV_max]= 5
_____<>Afficher image 1 [5_coeurs_vides]
____<>SINON
_____<>Si variable [PV_max]= 4
______<>Afficher image 1 [4_coeurs_vides]
_____<>SINON
______<>Si variable [PV_max]= 3
_______<>Afficher image 1 [3_coeurs_vides]
______<>Fin
_____<>Fin
____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
<>Si variable [PV]= 10
_<>Afficher image 2 [10_coeurs_pleins]
<>SINON
_<>Si variable [PV]= 9
__<>Afficher image 2 [9_coeurs_pleins]
_<>SINON
__<>Si variable [PV]= 8
___<>Afficher image 2 [8_coeurs_pleins]
__<>SINON
___<>Si variable [PV]= 7
____<>Afficher image 2 [7_coeurs_pleins]
___<>SINON
____<>Si variable [PV]= 6
_____<>Afficher image 2 [6_coeurs_pleins]
____<>SINON
_____<>Si variable [PV]= 5
______<>Afficher image 2 [5_coeurs_pleins]
_____<>SINON
______<>Si variable [PV]= 4
_______<>Afficher image 2 [4_coeurs_pleins]
______<>SINON
_______<>Si variable [PV]= 3
________<>Afficher image 2 [3_coeurs_pleins]
_______<>SINON
________<>Si variable [PV]= 2
_________<>Afficher image 2 [2_coeurs_pleins]
________<>SINON
_________<>Si variable [PV]= 1
__________<>Afficher image 2 [1_coeurs_plein]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
Bon, ça paraît méchant, mais pas du tout.

Voilà, pas plus bête que ça pour les coeurs. Maintenant passons à l'affichage des données numériques, tels rubis.

Et encore une fois, il faudra grapher. Cette fois-ci, c'est la création d'un logo avec un rubis (histoire de montrer que ce sont des rubis, quand même) et de 10 fichiers graphiques, chacun représentant... un chiffre sur un fond transparent. Oui, un dessin pour 0, un autre pour 1 etc.

On aura besoin de pas mal de variables cette fois-ci.
Supposons qu'on veut afficher les rubis avec trois chiffres (je précise que dans ce cas, il faut éviter que l'argent dépasse les 999 rubis) .
Il nous faudra ces variables:
[Argent], [centaines], [dizaines], [unités].

Et un autre événement commun appelé.... disons [RUBIS] avec Appel comme condition de départ.

Les images 3,4,5 et 6 (1 et 2 étant utilisées par les coeurs) seront affichées l'une à la suite de l'autre dans un coin de l'écran: la 3 sera le logo des rubis, la 4 sera le chiffre des centaines, la 5 sera celui des dizaines et la 6 celui des unités. A vous de trouver comment les placer

Allez, on code l'événement commun [RUBIS]!

Code: [Sélectionner]

<>Effacer image 3
<>Effacer image 4
<>Effacer image 5
<>Effacer image 6
<>Variable [Argent] = argent du groupe
<>Variable [Unités] = Variable[Argent]
<>Variable [Unités] modulo 10             //au fait MODULO est une division, où on garde comme résultat le RESTE de la division, et non pas le résultat proprement dit. Ici, il ne nous restera que des unités.
<>Variable [Argent] - Variable [Unités]
<>Variable [Argent] / 10
<>Variable [Dizaines] = Variable [Argent]
<>Variable [Dizaines] modulo 10         // mais si, c'est logique.
<>Variable [Argent] - Variable [Dizaine]
<>Variable [Argent] / 10
<>Variable [Centaines] = Variable [Argent]
// Allez, on a nos centaines, dizaines et unités! Maintenant, plaçons-les!
<>Afficher image 3 [logo_rubis]
<>Si variable [Centaines]= 0
_<>Afficher image 4 [chiffre_0]
<>SINON
_<>Si variable [Centaines]= 9
__<>Afficher image 4 [chiffre_9]
_<>SINON
__<>Si variable [Centaines]= 8
___<>Afficher image 4 [chiffre_8]
__<>SINON
___<>Si variable [Centaines]= 7
____<>Afficher image 4 [chiffre_7]
___<>SINON
____<>Si variable [Centaines]= 6
_____<>Afficher image 4 [chiffre_6]
____<>SINON
_____<>Si variable [Centaines]= 5
______<>Afficher image 4 [chiffre_5]
_____<>SINON
______<>Si variable [Centaines]= 4
_______<>Afficher image 4 [chiffre_4]
______<>SINON
_______<>Si variable [Centaines]= 3
________<>Afficher image 4 [chiffre_3]
_______<>SINON
________<>Si variable [Centaines]= 2
_________<>Afficher image 4 [chiffre_2]
________<>SINON
_________<>Si variable [Centaines]= 1
__________<>Afficher image 4 [chiffre_1]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
<>Si variable [Dizaines]= 0
_<>Afficher image 5 [chiffre_0]
<>SINON
_<>Si variable [Dizaines]= 9
__<>Afficher image 5 [chiffre_9]
_<>SINON
__<>Si variable [Dizaines]= 8
___<>Afficher image 5 [chiffre_8]
__<>SINON
___<>Si variable [Dizaines]= 7
____<>Afficher image 5 [chiffre_7]
___<>SINON
____<>Si variable [Dizaines]= 6
_____<>Afficher image 5 [chiffre_6]
____<>SINON
_____<>Si variable [Dizaines]= 5
______<>Afficher image 5 [chiffre_5]
_____<>SINON
______<>Si variable [Dizaines]= 4
_______<>Afficher image 5 [chiffre_4]
______<>SINON
_______<>Si variable [Dizaines]= 3
________<>Afficher image 5 [chiffre_3]
_______<>SINON
________<>Si variable [Dizaines]= 2
_________<>Afficher image 5 [chiffre_2]
________<>SINON
_________<>Si variable [Dizaines]= 1
__________<>Afficher image 5 [chiffre_1]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
<>Si variable [Unités]= 0
_<>Afficher image 6 [chiffre_0]
<>SINON
_<>Si variable [Unités]= 9
__<>Afficher image 6 [chiffre_9]
_<>SINON
__<>Si variable [Unités]= 8
___<>Afficher image 6 [chiffre_8]
__<>SINON
___<>Si variable [Unités]= 7
____<>Afficher image 6 [chiffre_7]
___<>SINON
____<>Si variable [Unités]= 6
_____<>Afficher image 6 [chiffre_6]
____<>SINON
_____<>Si variable [Unités]= 5
______<>Afficher image 6 [chiffre_5]
_____<>SINON
______<>Si variable [Unités]= 4
_______<>Afficher image 6 [chiffre_4]
______<>SINON
_______<>Si variable [Unités]= 3
________<>Afficher image 6 [chiffre_3]
_______<>SINON
________<>Si variable [Unités]= 2
_________<>Afficher image 6 [chiffre_2]
________<>SINON
_________<>Si variable [Unités]= 1
__________<>Afficher image 6 [chiffre_1]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin

Ca va? Vous tenez le coup? Mais non, ce n'est pas méchant, ce gros bloc de code .
Maintenant, au risque de vous faire paniquer, et si on embelissait un peu?
Allez, on enlève les zéros inutiles. Au lieu d'afficher "021", ça va nous afficher "21".
Pour les centaines, c'est simple, on va éjecter le 0 tout simplement.
Pour les dizaines, on va éjecter le zéro seulement si besoin est (s'il n'y a pas de centaines). On le fera evc une petite condition.. allez, retenez votre souffle. le voilà, le gros code à l'état final:

Code: [Sélectionner]

<>Variable [Argent] = argent du groupe
<>Variable [Unités] = Variable[Argent]
<>Variable [Unités] modulo 10
<>Variable [Argent] - Variable [Unités]
<>Variable [Argent] / 10
<>Variable [Dizaines] = Variable [Argent]
<>Variable [Dizaines] modulo 10
<>Variable [Argent] - Variable [Dizaine]
<>Variable [Argent] / 10
<>Variable [Centaines] = Variable [Argent]
<>Afficher image 3 [logo_rubis]

<>Si variable [Centaines]= 9
_<>Afficher image 4 [chiffre_9]
<>SINON
_<>Si variable [Centaines]= 8
__<>Afficher image 4 [chiffre_8]
_<>SINON
__<>Si variable [Centaines]= 7
___<>Afficher image 4 [chiffre_7]
__<>SINON
___<>Si variable [Centaines]= 6
____<>Afficher image 4 [chiffre_6]
___<>SINON
____<>Si variable [Centaines]= 5
_____<>Afficher image 4 [chiffre_5]
____<>SINON
_____<>Si variable [Centaines]= 4
______<>Afficher image 4 [chiffre_4]
_____<>SINON
______<>Si variable [Centaines]= 3
_______<>Afficher image 4 [chiffre_3]
______<>SINON
_______<>Si variable [Centaines]= 2
________<>Afficher image 4 [chiffre_2]
_______<>SINON
________<>Si variable [Centaines]= 1
_________<>Afficher image 4 [chiffre_1]
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
<>Si variable [Dizaines]= 0          //On place la condition!
_<>Si variable [Centaines] != 0
__<>Afficher image 5 [chiffre_0]
_<>Fin
<>SINON
_<>Si variable [Dizaines]= 9
__<>Afficher image 5 [chiffre_9]
_<>SINON
__<>Si variable [Dizaines]= 8
___<>Afficher image 5 [chiffre_8]
__<>SINON
___<>Si variable [Dizaines]= 7
____<>Afficher image 5 [chiffre_7]
___<>SINON
____<>Si variable [Dizaines]= 6
_____<>Afficher image 5 [chiffre_6]
____<>SINON
_____<>Si variable [Dizaines]= 5
______<>Afficher image 5 [chiffre_5]
_____<>SINON
______<>Si variable [Dizaines]= 4
_______<>Afficher image 5 [chiffre_4]
______<>SINON
_______<>Si variable [Dizaines]= 3
________<>Afficher image 5 [chiffre_3]
_______<>SINON
________<>Si variable [Dizaines]= 2
_________<>Afficher image 5 [chiffre_2]
________<>SINON
_________<>Si variable [Dizaines]= 1
__________<>Afficher image 5 [chiffre_1]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin
<>Si variable [Unités]= 0
_<>Afficher image 6 [chiffre_0]
<>SINON
_<>Si variable [Unités]= 9
__<>Afficher image 6 [chiffre_9]
_<>SINON
__<>Si variable [Unités]= 8
___<>Afficher image 6 [chiffre_8]
__<>SINON
___<>Si variable [Unités]= 7
____<>Afficher image 6 [chiffre_7]
___<>SINON
____<>Si variable [Unités]= 6
_____<>Afficher image 6 [chiffre_6]
____<>SINON
_____<>Si variable [Unités]= 5
______<>Afficher image 6 [chiffre_5]
_____<>SINON
______<>Si variable [Unités]= 4
_______<>Afficher image 6 [chiffre_4]
______<>SINON
_______<>Si variable [Unités]= 3
________<>Afficher image 6 [chiffre_3]
_______<>SINON
________<>Si variable [Unités]= 2
_________<>Afficher image 6 [chiffre_2]
________<>SINON
_________<>Si variable [Unités]= 1
__________<>Afficher image 6 [chiffre_1]
________<>Fin
_______<>Fin
______<>Fin
_____<>Fin
____<>Fin
___<>Fin
__<>Fin
_<>Fin
<>Fin

Voilà, fini pour les rubis. Vous pouvez en faire autant avec les compteurs de bombes, de flèches...
Pour finir, revenons à notre événement commun [HUD]
Il est comme ça, OK?

Code: [Sélectionner]

<>Appeler événement: [COEURS]On rajoute un truc:

Code: [Sélectionner]

<>Appeler événement: [COEURS]
<>Appeler événement: [RUBIS]
Tout ce que vous rajoutez qui doit apparaître à l'écran est à placer dans le [HUD].

Maintenant, à chaque fois que quelquechose fera Appel à [HUD] vous aurez affiché sur l'écran les coeurs et les rubis (et, si vous avez ajouté des trucs, plein d'autres choses ).

Seulement, il faudra faire appel à [HUD] à chaque fois que quelque chose change dans votre statut: vous perdez ou gagnez des PV, des rubis... etc. Par exemple, avec les monstres, quand un monstre vous attaque:

Code: [Sélectionner]

<>Si [ATTAQUE] est OFF
_<>[Link PV] -1
_<>Appeler événement [HUD]      //<= comme ça, le coup est tout de suite comptablisié par l'affichage des coeurs
<>Fin
<>Si [ATTAQUE] est ON
_<>Variable [monstre_PV]+1
_<>Si [monstre_PV] >= 5
__<>Variable [monstre_objet]aléatoire entre 1 et 10
__<> switch[monstre_mort] ON
_<>Fin
<>Fin
<>
Il faudra aussi faire appel à [HUD] à deux moments: au tout début du jeu et après les téléportations, en arrivant sur une nouvelle map. (merci à Cham de m'avoir signalé cette omission ^^)

Alors, pour le début du jeu, on aura encore besoin d'un switch [Premier affichage] et d'un événement.

Conditions de départ: aucune
...
Lancement: Auto

Code: [Sélectionner]

<>Appeler événement [HUD]
<>Switch [Premier affichage] ON

Conditions de départ: le switch [Premier affichage] est ON
...
Lancement: Toucher ou Appui

Code: [Sélectionner]

<>
//rien :)

Voilà, et pour les passages dans les maps, il y a deux solutions: soit faire appel à [HUD] juste après avoir téléporté le héros, dans l'événement même qui le téléporte...
...soit placer des événements comme celui décrit ci-dessus dans chaque map et désactiver le switch [Premier affichage] après chaque téléportation dans l'événement même qui téléporte le héros.

Une autre méthode d'affichage des coeurs et des rubis consiste à mettre [HUD] en processus parallèle, et ajouter à la fin <>Attendre (durée de réactualisation). Ce système est plus simple, parce qu'il ne nécésite pas d'appeler [HUD] au moindre changement de la vie ou des finances, mais il a un défaut: celui de ne pas être instantané, à chaque changement, il faut attendre un peu avant que ça ne s'affiche. Et à des durées trop faibles, le jeu peut ramer.

Code: [Sélectionner]

<>Appeler événement: [COEURS]
<>Appeler événement: [RUBIS]
<>Attendre 0.5 sec   // où 0.5 est la période de réactualisation de la barre de vie
Bon, enfin voilà.
C'est un peu confus, tout ça, mais ça aborde les gros problèmes que rencontrent les débutants quand ils font leur Zelda.
Je n'aborde pas le menu perso, parce que ce serait trop complèxe, parce qu'il y a beaucoup de façons d'en faire un, et parce que ... je ne sais pas faire ^^ (sauf le menu contextuel).

Voilà, amusez-vous bien et faites les méilleurs Zelda!ANNEXE 1 PAR CHAMAutre façon de régler le problème des coeurs :
cette fois, on ne va pas faire de fond, simplement toute les images doivent être créé :
pas de coeur, coeur plein, 1 coeur, 2 coeur, etc...disons qu'il a 10 coeurs, et qu'on attribue 1 point par demi coeur, cela fait en tout 20 images plus celle qui est vide.

On prend alors seulement une variable "nb de coeur" et on fait un évènement [COEUR] qui est en appel.
ça dode en gros :

Code: [Sélectionner]

<> variable opér[20:nb de coeur]=20  (on attribue la valeur maximale. Si vous voulez que le héros parte avec des points en moins dès le départ)
<>Fourche:Variable[20:nb de coeur]=20
     <>Afficher Image(l'image qui correspond à 10 coeurs soit 20 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin
 
<>Fourche:Variable[20:nb de coeur]=19
     <>Afficher Image(l'image qui correspond à 10 coeurs 1/2 soit 19 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin

Vous répétez jusqu'à ce que la variable égale 0, auquel cas vous mettez

<>Fourche:Variable[20:nb de coeur]=0 inf/égal (au cas où les points deviendrez plus bas que zéros)
     <>Afficher Image(l'image qui correspond à 0 coeurs soit 0 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin


Voilà, normallement vous faites ensuite ce qui a été dit par Sani' sur l'évènement HUD, en rajoutant

Code: [Sélectionner]

<>Appeler événement: [COEURS]
<>Appeler événement: [RUBIS]
<>Attendre 0.5 sec   // où 0.5 est la période de réactualisation de la barre de vie
et c'est prêt !ANNEXE 2 PAR CHAMPour le codage de l'épée, votre héros risque de continuer d'avancer durant sont coup. résultat : on dirait qu'il fait une glissade. Je vous conseil donc d'ajouter juste avant les fourchettes conditionnelles et juste avant la transparence, "déplacer un évènement > le héros > attendre (vitesse 8)
ainsi, votre héros donnera des coups d'épée sur place. bon je vous met le codage sur celui de Sani' :

Code: [Sélectionner]

<>si le switch[cinématique] est OFF
_<>si le switch[recouvert] est OFF
  <>Dépl; Héros : Attente                                                     //// ICI
__<>Transparence du héros: TRANSPARENT
__<>si le héros [Link] est équippé avec l'objet [epee2]
___<>si événement [héros] est tourné en haut
____<>afficher animation de combat [epee2_haut]
___<>Fin
___<>si événement [héros] est tourné en bas
____<>afficher animation de combat [epee2_bas]
___<>Fin
___<>si événement [héros] est tourné à gauche
____<>afficher animation de combat [epee2_gauche]
___<>Fin
___<>si événement [héros] est tourné à droite
____<>afficher animation de combat [epee2_droite]
___<>Fin
__Sinon:
___<>si le héros [Link] est équippé avec l'objet [epee1]
____<>si événement [héros] est tourné en haut
_____<>afficher animation de combat [epee1_haut]
____<>Fin
____<>si événement [héros] est tourné en bas
_____<>afficher animation de combat [epee1_bas]
____<>Fin
____<>si événement [héros] est tourné à gauche
_____<>afficher animation de combat [epee1_gauche]
____<>Fin
____<>si événement [héros] est tourné à droite
_____<>afficher animation de combat [epee1_droite]
____<>Fin
___<>
__<>Transparence du héros: OPAQUE
__<>
_<>
<>
<>si le switch [recouvert] est ON
_<>Jouer le son [le son qui a servi pour l'animation]
<>FinANNEXE 3 PAR SANIOKH[/color]Bon, allons implémenter un petit système d'intelligence artificielle (non, je plaisante , mais ça n'est est pas loin)
Vous vous souvenez certainement de notre joli monstre?

Code: [Sélectionner]

<>Si [ATTAQUE] est OFF
_<>[Link PV] -1
<>Fin
<>Si [ATTAQUE] est ON
_<>Variable [monstre_PV]+1
_<>Si [monstre_PV] >= 5
__<>Variable [monstre_objet]aléatoire entre 1 et 10
__<> switch[monstre_mort] ON
_<>Fin
<>Fin
<>Maintenant, ce qu'on peut faire, est de diviser cette page en deux pages. D'abord, faites INSERER une nouvelle page juste après celle-ci.
Les deux pages vont avoir l'air de ça:

Condition de départ: aucune
Sprite: monstre
Mouvement: à vous de voir
Lancement: contact

Code: [Sélectionner]

<>[Link PV] -1
<>

Condition de départ: [ATTAQUE] est ON
Sprite: monstre
Mouvement: à vous de voir
Lancement: contact

Code: [Sélectionner]

<>Variable [monstre_PV]+1
<>Si [monstre_PV] >= 5
_<>Variable [monstre_objet]aléatoire entre 1 et 10
_<> switch[monstre_mort] ON
<>Fin
<>

Quel est l'intérêt? Par exemple, si on assigne deux mouvements différents (page 1: le monstre se rapproche, page 2: le monstre s'éloigne) on peut créer des effets sympas tels que: le monstre vous évite si vous agitez trop votre épée, ou sursaute dès que vous attaquez...


Je vais maintenant parler des épées... vous savez, quand vous attaquez un ennemi... il ne perd qu'un point de vie dans notre exemple? Si vous changez d'épée, ce sera pareil... alors pourquoi changer? Bah, je vais réctifier le tir
Alors, tout d'abord, dans la base des données réduisez l'attaque du héros Link à 1. Après, allez dans les propriétés des objets. L'épée 1 doit avoir l'attaque à 0. L'épée 2 doit l'avoir... à plus que zéro .
A chaque fois que Link obtient une épée, il s'en équippe, nous sommes d'accord? Alors, maintenant, allons voir notre monstre. Introduisez une nouvelle variable [héros_attaque]. Maintenant, remplacez ça (quand le héros attaque):

Code: [Sélectionner]

<>Variable [monstre_PV]+1 par ça:

Code: [Sélectionner]

<>[héros_attaque] = ataque du héros [Link]
<>Variable [monstre_PV]+[héros_attaque]Ce qui fait que, avec l'épée 1, Link enlève 1 PV à chaque coup, avec la 2, il en enlève plus etc.

[Cham]

HAHA, les p'tits nouveaux n'ont plus le droit de poser des questions sur solarus !!!
(j'éspère que ce topic est épinglé)
en tout cas bravo, ça c'est un truc vraiment utile ! (ça va m'aider pour l'argent, parce que j'avais pas du tout l'intention de faire comme ça, mais ma technique n'aurait surement pas marcher. Merci !)

[SaniOKh]

J'ai passé une heure à le taper
Alors si vous trouvez une erreur, n'hésitez pas à signaler.

[Link.TC]

Bon le topic a l'air interressant, je l'épingle, merci a Sani'

[Cham]

Tiens, j'ai une question. Tu met que l'évènement HUD est en appel, et que lui même appel les coeur, rubis, etc... Mais dans ce cas, il faut que dès le début du jeu il y est un évènement qui appelle le HUD, dinon ,le HUD ne s'affichera que dès que le héros trouvera quelque chose/tuera un enemi et rammassera un rubis/perdra un coeur, non ?

[SaniOKh]

Oui, il y a ça aussi. Dans ce cas, il faudra mettre dans la première map un événement ainsi constitué:

Condition de départ: rien
Lancement: Auto

Code: [Sélectionner]

<>Appeler événement [HUD]
<>Switch [Un switch ^^] ON

Condition de départ: Switch  [Un switch ^^] ON
Lancement: Appui ou toucher...

Code: [Sélectionner]

-rien

Une fois que cet événement a appelé la fonction HUD, il ne marche plus.
Tiens, je vais rajouter ça dans le tuto d'origine.

[Cham]

A ton avis, n'y aurais -til pas un moyen d'afficher pendnat tout le jeu le HUD par le biais des évènements commun ? Parce que recollé du codage dans tout les évènement de téléportation, ça va être chaud !!!

[SaniOKh]

Et bien, au début, je voulais essayer en mettant dans les processus parallèle, mais ça ne l'a pas vraiment fait...
une méthode que je pense "essayable" est de placer [HUD] en processus parallèle en rajoutant à la fin un truc du genre:
<>Attendre 1.0 sec
pour une réactualisation toutes les secondes...
Si ça marche, je le rajouterai.

[Cham]

ouais, ça marche grave, c'est super.
Là vu qu'en ce moment j'essaye de faire le vrai moteur A-rpg de mon jeu, je teste plein de solution, j'ai déjà tester les truc de zelda ABS, et là je teste les tienne. Donc la réactualisation chaque sconde, ça marche !

[SaniOKh]

Je viens de tester de mon côté, en effet, ça marche nickel-chrome.
Je rajoute au tuto.

[Cham]

Autre façon de régler le problème des coeurs :
cette fois, on ne va pas faire de fond, simplement toute les images doivent être créé :
pas de coeur, coeur plein, 1 coeur, 2 coeur, etc...disons qu'il a 10 coeurs, et qu'on attribue 1 point par demi coeur, cela fait en tout 20 images plus celle qui est vide.

On prend alors seulement une variable "nb de coeur" et on fait un évènement [COEUR] qui est en appel.
ça dode en gros :

Code: [Sélectionner]

<> variable opér[20:nb de coeur]=20  (on attribue la valeur maximale. Si vous voulez que le héros parte avec des points en moins dès le départ)
<>Fourche:Variable[20:nb de coeur]=20
     <>Afficher Image(l'image qui correspond à 10 coeurs soit 20 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin
 
<>Fourche:Variable[20:nb de coeur]=19
     <>Afficher Image(l'image qui correspond à 10 coeurs 1/2 soit 19 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin

Vous répétez jusqu'à ce que la variable égale 0, auquel cas vous mettez

<>Fourche:Variable[20:nb de coeur]=0 inf/égal (au cas où les points deviendrez plus bas que zéros)
     <>Afficher Image(l'image qui correspond à 0 coeurs soit 0 demi coeurs, plus les coordonée de l'images)
     <>
     <>fin


Voilà, normallement vous faites ensuite ce qui a été dit par Sani' sur l'évènement HUD, en rajoutant

Code: [Sélectionner]

<>Appeler événement: [COEURS]
<>Appeler événement: [RUBIS]
<>Attendre 0.5 sec   // où 0.5 est la période de réactualisation de la barre de vie
et c'est prêt !

[SaniOKh]

Si je ne me trompe pas, cette façon de procéder n'est pratique que si le personnage a un nombre fixe de coeurs (comme dans l'exemple de Xfixfium, tout compte fait).
En effet, avec cette méthode, nous avons à faire ces dessins: (  pour un coeur plein, A pour un demi-coeur et V pour un coeur vide):
VVVVVVVVVV
AVVVVVVVVV
  VVVVVVVVV
  AVVVVVVVV
  VVVVVVVV
  AVVVVVVV
  VVVVVVV
  AVVVVVV
  VVVVVV
  AVVVVV
  VVVVV
  AVVVV
  VVVV
  AVVV
  VVV
  AVV
  VV
  AV
  V
  A
 

Mais si le nombre de coeurs augmente en cours de la partie, il faudra refaire le même jeu de graphismes en augmentant d'un coeur! Ce n'est pas vraiment pratique dans ce cas-là...

[Cham]

ben je pense que l'ont peut faire ajouter un niveau de point en faisant dans une 21ème fourchette, par exemple, la condition "si quart de coeur1 ON, alors,
si variable nombre de poins 21, alors rajouter un coeur. Mais dans ce cas , il ne faut montrer que les coeurs apparents, jamis les coeurs vide. donc comme tu le dis ça peut être plus contraignant.

[Cham]

Dsl si je fais un double post, c'est juste pour dire que pour le codage de l'épée, votre héros risque de continuer d'avancer durant sont coup. résultat : on dirait qu'il fait une glissade. Je vous conseil donc d'ajouter juste avant les fourchettes conditionnelles et juste avant la transparence, "déplacer un évènement > le héros > attendre (vitesse 8)
ainsi, votre héros donnera des coups d'épée sur place. bon je vous met le codage sur celui de Sani' :

Code: [Sélectionner]

<>si le switch[cinématique] est OFF
_<>si le switch[recouvert] est OFF
  <>Dépl; Héros : Attente                                                     //// ICI
__<>Transparence du héros: TRANSPARENT
__<>si le héros [Link] est équippé avec l'objet [epee2]
___<>si événement [héros] est tourné en haut
____<>afficher animation de combat [epee2_haut]
___<>Fin
___<>si événement [héros] est tourné en bas
____<>afficher animation de combat [epee2_bas]
___<>Fin
___<>si événement [héros] est tourné à gauche
____<>afficher animation de combat [epee2_gauche]
___<>Fin
___<>si événement [héros] est tourné à droite
____<>afficher animation de combat [epee2_droite]
___<>Fin
__Sinon:
___<>si le héros [Link] est équippé avec l'objet [epee1]
____<>si événement [héros] est tourné en haut
_____<>afficher animation de combat [epee1_haut]
____<>Fin
____<>si événement [héros] est tourné en bas
_____<>afficher animation de combat [epee1_bas]
____<>Fin
____<>si événement [héros] est tourné à gauche
_____<>afficher animation de combat [epee1_gauche]
____<>Fin
____<>si événement [héros] est tourné à droite
_____<>afficher animation de combat [epee1_droite]
____<>Fin
___<>
__<>Transparence du héros: OPAQUE
__<>
_<>
<>
<>si le switch [recouvert] est ON
_<>Jouer le son [le son qui a servi pour l'animation]
<>Fin

[SaniOKh]

Je pense que le message valait la peine de faire un double-post, donc, je te pardonne
Allez, je rajoute ton tuto au post d'origine.
Et j'en rajouterais volontiers une couche aussi

POur le système de rubis lorsque tu te rend a 1000 il est suposer de rester a 999 rubis mais il retombe a 0? Comment se fait -il (rpg maker 2000)

[SaniOKh]

J'avais bien précisé que les rubis dans ce cas ne doivent pas dépasser 999 .
Si tu es courageux, tu peux ajouter un quatrième chiffre ^^.
Sinon, débrouille-toi pour que les rubis ne dépassent pas 999.

[Cham]

ça peut marcher une fourche conditionnelle qui dit que si l'argent est au dessus de 999, alors la variable reviens à 999 ?
Je demande parce que je me sui s pas encore lancé dans le systeme monétaire (je m'occupe de la prog des enemis.)

Oui bien sûr Cham : dans ta base de donnée , il faut que tu ailles dans évènement commun .
Ceci fait , en déclenchement il faut mettre procéssus parallèle ( avec ou sans interupteurs ) .
Dans la commande de l'évènement , il faut comme condition que si le nombre de ta variable [argent] est supérieure ou égale à 999 , alors (ensuite tu vas dans modifier variable ) tu modifies une seule variable donc [argent] dans opération à effectuer , tu mets rendre égal à et dans Opérande tu mets 999 .

J'espère avoir répondu à ta question    .

Enfin normalement ça devrait marcher car moi je sais que pour mon jeu ça avait marché mais moi c'est moi , et vous bah c'est vous .

[SaniOKh]

Oui, Marco, processus parallèle, ou, si on ne veut pas utiliser trop dévénements communs, on peut ajouter ce code dans l'événement [RUBIS] même, tout au début. (EDIT: enfin, pas tout au début, mais après ça:

Code: [Sélectionner]

<>Variable [Argent] = argent du groupe)

Ca me rappèle, quand je voulais faire un compteur comme ça pour mon jeu (sauf que c'était pour les flèches) , j'ai mis trois chiffres aussi, et quand le cmopteur dépassait 999, j'ai fait de sorte que ça affichait "+999" et c'était bien sympa. (j'ai enlevé après)

[...linkin p@rk...]

C'est très bien expliqué...
Oui mais...
C'est super mega long !!!!!
Il faut avoir le courage de lire tous ça et aussi pour les nouveaux dans rpg maker et ben faut qu'il comprennent !!
Mais sinon bien jouer pour écrire tous ça, car ça a dû être très long !!

 

Encore bravo !

[SaniOKh]

Tu trouves que c'est long? 
Bon, d'accord, juste un petit peu , mais au mois j'ai essayé de compacter les explications au maximum
Ce tutoriel a été fait pour ceux qui viennent de débuter, qui veulent comprendre comment marchent les systèmes que je leur propose, et surtout qui n'ont pas peur d'essayer toutes les foncions de RPG Maker
Voilà. Merci à toi pour ton apréciation
Si quelqu'un veut écrire un autre "ANNEXE" pour le tutoriel, vous êtes les bienvenus

Désolé les gars mes la technique del'actualisation automatique ne marche pas sur toutes les configs. Pourquoi croyez vous que chris c'est fait chier à copir coller une ligne partout?
Tout simplement parce que si vous testez votre système sur un Pc de moins d'un Ghz il va ramer.

Si j'ai le courage, je vous ferais un tuto assez particulier et en rapport avec Zelda 

[SaniOKh]

Désolé Blacky, mais ta remarque était un peu inutile, j'avais bien précisé que cette technique fait ramer l'ordi dans le premier post ^^
Pourquoi crois-tu que j'ai fait pareil?

Pour le tuto, on attendra de voir ça, même si je crois avoir fait le tour de la chose (sauf les menus persos que chacun fait à sa façon) . Quoique, si tu fais les descriptifs des objets, ce sera pas mal

J'ai regardé ton premier message et quelque chose me parait bizare. Si j'ai bien tout comprit il suffit que le switch d'attaque soit activé et que tu sois en contacte avec l'énemi pour le bléssé. Mais de cette manière même si l'adversaire est dérrière il sera bléssé! Non! Aussi j'ai la solution, (je sais pas si vous avez déja corriger ce problème) utilisé d'autre variable: v[X heros], v[Y heros], v[X monstre] et v[Y monstre]. Chacune égale au coordonné. Après le code est simple

on vas dons la programmation du monstre,

<>si heros regarde vers haut
    <>si [Y heros]>[Y monstre]
        <>si [X heros]=[X monstre]
            _[vie monstre]+1
        fin
    fin
fin
<>si heros regarde vers bas
    <>si [Y heros]<[Y monstre]
        <>si [X heros]=[X monstre]
            _[vie monstre]+1
        fin
    fin
fin
<>si heros regarde vers gauche
    <>si [Y heros]=[Y monstre]
        <>si [X heros]>[X monstre]
            _[vie monstre]+1
        fin
    fin
fin
<>si heros regarde vers droite
    <>si [Y heros]=[Y monstre]
        <>si [X heros]<[X monstre]
            _[vie monstre]+1
        fin
    fin
fin

J'espère que vous comprenderez je sais que des fois je suis incomprèensible.

[Cham]

cette technique est bien, le seul problème, c'est : si il y a plusieur enemi dans la map, alors il va falloir faire autant de variable XY qu'il y a d'enemis. apès elles sont réutilisable, heureusement. Néammoins, ça peut etre pratique ces variable si on fait un menu personnalisé.
Mais c'est plus dur comme codage..

Excuse moi mais j'ai pas vraiment besoin de cours moi 

Pour ce qui est du tutorial, je peux vous proposer un système qui permet de gérer une image symbolisant le boutton action et qui change suivant les possibilité durant la partit du jeu. Je l'avais réalisé durant la réalisation de Zelda MSM mais personne ne l'a jamais vu. 

[Cham]

j'ai jamais dit que c'était dur pour tout le monde, Black_fox, encore moins pour toi...

MAis oui, ce serait interressant un bouton qui change suivant les actions, justement, je prévoyais d'en faire un...

bah attends d'ici a ce soir normalement je vais le mettre la car j'ai regardé ce que j'ais fait le plus long sera de faire les graph!

EDIT par SaniOKh: suite à une demande de BLACK_FOX, je crée un sujet dédié à son tuto:
http://forums.zelda-solarus.com/index.php?topic=10721

[Neo2]

------------------------------------------------------------------
Jour Nuit
------------------------------------------------------------------

C'est bien les Zelda, mais les System Jour/Nuit vous permettent de faire des évènement en plus qui appraissent selon certainnes heure. C'est très utile, non ?
Voici comment cela marchera :

Code: [Sélectionner]

<>VARIABLE temps : +1 chaques secondes
<>SI temps = ou > 60
><>VARIABLE temps - 60
><>VARIABLE temps2 +1Comment sa c'est pas compliqué ? Au contraire, c'est très compliqu, je vous est juste mis l'indispensable. Voici comment sa marche : 'temps' représent les secondes en réalité, mais les minutes dans le jeu. 'temps2' représente donc les minutes en réalité, et les heures dans le jeu.

Voici le code :

Code: [Sélectionner]

<>ATTENTE 1s
<>VARIABLE 'minute' +1
||>SI 'minute' = OU > A 60
||<>VARIABLE 'heure' +1
||<>VARIABLE 'minute' AJUSTER 0
 \\-----
||>SI 'heure' = OU > A 24 /* Pour comptez le nombre de jour */
||<>VARIABLE 'jour' +1
||<>VARIABLE 'heure' AJUSTER 0
\\-----
/* Ensuite, si vous voulez faire dse mois, des années, etc... Reprenez le même system de jour */
Maintenant, c'est bien, on as du temps et tout et tout, mais si rien ne se passe, le temps ne change pas, plein e chose comme sa, sa sert pas vraiment à grand chose... Nous allons donc procédez en trois étapes :
1/ Evenement
2/ Soleil/Lune
3/ Temps au Hasard


LES EVENEMENTS
Vous êtes en train de pensez 'C'est simple, on affiche l'évènement à l'heure qu'on veut !'. C'est totalement vrai, mais moi, je préfère être plus précis, e tutilisez les minutes ainsi que les jours, avec un system de semaine.
On va crée un évènement en processus parrallèle.

Code: [Sélectionner]

||>SI 'heure' = /* entrez ici l'heure ou vous voulez que le personnage apparaissent */
||||>SI 'minute' = /* minute où le perso doit apparaître */
||||<>SWITCH 'perso1' ON
||\\-----
\\-----Maintenant, pour faire comme moi les jeurs de la semaines, il suffit de rajouté une condition et mettre le switch dedans.


SOLEIL/LUNE
Le plus utile dans les system jour/nuit, c'est surtout ce qu'on va apprendre : faire des tons différent. Il ne faut pas oublié que les animations de combats ne vont pas comme par magie changez de couleurs ! Vous devrez les refaires, mais en changeant le ton (dans le system d'animation).

Code: [Sélectionner]

||>SI 'heure' = /* entrez ici l'heure ou vous voulez que le ton change*/
||||>SI 'minute' = /* minute où le ton changent*/
||||<>TON /* Vous savez remplir sa je pense... */
||\\-----
\\-----

TEMPS AU HASARD
Note : cela ne marche qu'avec un system de semaine !
Un peu plus complexe, mais toujours possible. Refaite ce code autant de fois que vous voulze changez le temps. Pour ma part, je prend Mardi, il pleut.

Code: [Sélectionner]

||>SI 'jour' = 2
||<>TON /* Optionnel, mais quand il pleut, généralement il fait plus sombre */
||<>METEO pluie
\\-----Voila, mais n'oubliez pas de remettre à la normal au début de chaque jour !

J'aimerai savoir s'il est possible d'afficher une vidéo avant le menu de départ.

PS:Je réfléchi sur un moyen pour affiché les objets, je vous prévient quand c'est fini

[RoyalLink]

moi, les rubis ne marche pas. Les rubis sont affichée, mais lorsque le joueur touche et prends le rubis, le compteur reste a zero??

 

J'aimerai savoir s'il est possible d'afficher une vidéo avant le menu de départ.

Hélas non , c'est impossible avec RPG Maker .

moi, les rubis ne marche pas. Les rubis sont affichée, mais lorsque le joueur touche et prends le rubis, le compteur reste a zero??

As-tu bien penser à rajouter +1 ( s'il est vert ) , +5 ( s'il est bleu ) ... à la variable [rubis] quand le héros ramasse le rubis ?
Je ne pense pas que tu l'ais fait car sinon , ça marcherai à la perfection .

As tu pensé aussi à appeller l'évènement rubis ou as tu fais le système qui actualise automatiquement?

Sinon RM peut faire marcher des video AVI qui marche pas sur toutes les configurations et d'ailleurs à mon sens c'est inutile car ce n'est d'une grande qualité...
( Comme tout ce qui est fait avec RM Mais comme on dit c'est mieux que rien... )

[RoyalLink]

Je n'ai pas compris ce que vous vouliez dire black fox et marco.

Si je crois avoir compris un peu, il faut que j'appelle l'évènement (hud) a chaque fois que mon bonhomme prends un rubis (qui est déja fait) et que je rajoute le nombre de sous selon la valeur du rubis  (qui est déja fait aussi!)

En fait , tu utilises le charset du rubis pour le voir apparaitre par terre .

Tu mets en condition de déclenchement " au contact du héros " . Ensuite , en commande de l'évènement , tu mets ceci :
*modifier variable
-Variable à modifier : la variable [rubis]
-Opération à effectuer : Additionner
-Opérande : le nombre qui dépend de la couleur du rubis ( +1 s'il est vert , +5 s'il est bleu ... )
...

Ce qui veut dire que quand tu marcheras sur le rubis , alors ton argent augmentera de x rubis .

[RoyalLink]

laissez faire... C'était ma version de rpg maker qui faussait!(rm03 bostée)

Pour les rubis ne modifier pas la variable , mais l'argent du groupe.
Aussi j'ai essayer des chose que vous dite, la variable[argent] bloque à 999 mais l'argent continue de monter donc il faut enlever le sur plus grace à une autre variable
<>si variable[argent]> ou = 1000
     <>variable[???]=argent du groupe
     <>variable[???]-999
     <>ajouter/retirer monnai -v[???]

Exemple: argent 1023

faire 1023-999=24
faire 1023-24=999

donc l'argent ne dépasse pas 999

[Maze]

euh escuse moi mai j'i arrive pa comme ta di   

pourtan g  envi mai bon:chepa:

parce ke j'en fé un jeu avec des combats a la zelda avec des épés et des monstres 

tu di "ecrire kelke chose comme sa" mai l'ecrire ou??

pitié explike moi tout

[lelinuxien]

Bonjour et bienvenue, Maze. Je te prierais avant tout d'aller lire le règlement car le langage SMS et les fautes d'orthographes volontaires n'ont rien à faire sur le forum.

[Maze]

escuse moi je savais pas

[lelinuxien]

escuse moi je savais pas

Avec la ponctuation, ce serait parfait.
Mais bon, "nul ne peut ignorer la loi".

Bon, sa m'as pris 2 essais, mais maintenant les rubis fonctionnes à 100% et sans aucuns bugs! lol, sérieusement j'ai pas eu besoin de tes tutoriaux SaniOKh, mais, pour ceux qui veulent faire un Zelda, et qui ne savent rien du tout, c'est bien de commencer par ici! C'était une bonne idée, comme sa, plus personne ne devrais répondre au question du genre 'Comment je fait pour que Link attaque un monstre'!

[Gobbi]

Super Sani' !!
Maintenant t'as plus qu'à faire pareil pour RPG Maker XP !

[Spring Up]

Salut Gobbi,

Peut être que c'est déjà fait?
http://www.rpg-creation.com/rm2k/xp/arpg.php

Très cordialement.

[SaniOKh]

Merci, Spring Up ^^
Je ne prévois pas en faire autant pour RPG XP pour une simple et bonne raison: je n'y connais rien ^^.
(et aussi la plupart des makers font leurs jeux avec RPG Maker 2000 ou 2003)

Salut.

Je comprend pas vraiment le "Détecter touche". J'esseye de faire que si j'appuies sur un bouton, ça fasse l'évènement, mais j'ai tout fouillé... J'ai rien trouvé.

[Gobbi]

Merci Spring Up, je pense que ce site va beaucoup me servir...

[SaniOKh]

Salut.

Je comprend pas vraiment le "Détecter touche". J'esseye de faire que si j'appuies sur un bouton, ça fasse l'évènement, mais j'ai tout fouillé... J'ai rien trouvé.

Je ne compremds pas ce qu'il y a de si difficile... tu crées un événement en condition "processus parallèle", qui a cette tête-là (il te faudra aussi une variable que je nommerai TOUCHE):

Code: [Sélectionner]

<>Détecter touche (TOUCHE)
<>Si TOUCHE=5
 <>... ce que tu veux qu'il y aie quand on appuye sur espace...
 <>
<>FIN...enfin, explique un peu mieux ce que tu veux faire et ce que tu ne comprends pas.