Nouveau tuto: Le modulo sous RM, toujours sympa!

Vous êtes sous RM et vous vous êtes déjà posés la question:"Mais à quoi sert ce fameux modulo, il sert à rien, et on s'en sert jamais?!"
Ce tuto est fais pour vous!
En effet, le modulo peut se voir très sympatique!
Ce n'est pas pour rien que le modulo fais parti d'une des opérations de bases dans RM, comme dans pas mal de langage!
En effet, on ne vois ni les carrés, ni les racines carrés etc sous RM.
Bon certes, on peut toujours à l'aide d'un appel de script, à savoir que le carré s'écrit ** dans RM...
Tout d'abord, qu'est ce que le modulo?
Un modulo, c'est une opération qui permet de retrancher de manière successive une certaine valeur à un nombre afin d'obtenir un nombre compris entre 0, et la valeur dont on a retranché successivement, non incluse.
Petit exemple 7 modulo 3:
7 - 3 = 4
4 - 3 = 1
Si on retranche de nouveau 3, 1 - 3 = -2, et - 2 < 0, donc ce n'est pas bon.
Donc 7 modulo 3 = 1.
J'ai fais ici pour ceux qui connaissent une soustraction euclidienne, même si ça marche normalement en division euclidienne (7/3 = 2, et on prend le reste qui vaut 1. En gros, 7 modulo 3 = 3 * 2 + 1, le resultat étant le reste de la division, donc ici, 1).
En informatique, le modulo se note généralement %, ou mod. En ruby, c'est %.

Vous me direz c'est bien beau, mais à quoi ça sert ?!
Généralement, le modulo est surtout utilisé pour des intervalles de temps. Vous savez, le chrono, que peut être vous utilisez? Et bien il marche grâce au fameux modulo!
On va examiner le fonctionnement, de manière toute bête:

Code:


min = @total_sec / 60
sec = @total_sec % 60


On a ici deux variables, min et sec, où min enregistre les minutes de l'ordinateur
et sec les secondes.
Voyons ce que ça donne!
Imaginons qu'on a 3 minutes 50
3*60 = 180
180 + 50 = 230
On a donc 230.
230 / 60 = 3
donc min = 3
et 230 % 60 (modulo) = 50, car 230 / 60 = 180 + 50, et que 180/60 = 3.
On a donc bien min = 3,
et sec = 50.

C'est bien beau mais à quoi ça sert réellement me demanderez vous!
Oui oui ça arrive ^^!
Imaginez que vous voulez répéter une animation sur le héros toutes les 70 frames ?
Un event en processus parallel, aficher une animation sur le héros, attendre 70 frames?
En rigole d'avance! La seule chose que vous allez faire ,c'est bloquer votre personnage!
J'avais trouvé une astuce, il y a longtemps, afficher une animation sur le héros, attendre 1 frame, attendre une frame attendre une frame attendre une frame, bref mettre un attendre uen frame autant que l'on veut d'attente de frame totale avant répétition.
Sauf que ça fais laguer un minimum le jeu, et niveau bricolage, y a pas pire ^^!
Sinon, il y a l'astuce de la boucle en modulo!
Alé hop, on créé un event en processus parallel
On initialise une variable, $compteur par exemple = 0
Une petite boucle:

Code:


<boucle>
$compteur += 1  # on incrémente la variable compteur, donc on l'augmente de 1
Condition : le script: $compteur % 70 == 0 # On regarde si la variable compteur est divisible par 70.
Afficher une animation sur le héros
fin de la condition
attendre 1 frame
<fin de la boucle>


M'enfin, ca c'est un exemple de base. C'est donc plus ou moins utile pour faire intervenir un événement à interval régulier, sans avoir à réinitialiser sa variable à chaque événement en cours
Interessons nous maintenant à une utilisation plutôt utile: les transitions.
En effet, vous savez les histoire de déplacements d'images etc... Vous pensez que ça viens miraculeusement?
Et bien non, là encore, une histoire de modulo, d'autant plus qu'en script, il n'existe pas le fameux "attendre 20 frames"!
Enfin bref, les effets de transitions sont dues aux modulos!
Je vais docn vous parler des transitions de fogs!
Et oui, en event, on a pas de possibilité de faire apparaitre un brouillard en transition, il apparait directement, donc obligé de mettre un premier brouillard d'opacité 0 et où on augmente l'opacité au fur et à mesure...
Et bien c'est fini! Ce temps et révolu!
Le code pour afficher un brouillard est:

Code:


      $game_map.fog_name = "001Fog-01" # nom du fog
      $game_map.fog_hue = 0 # ton du fog
      $game_map.fog_opacity = 0 # opacité du fog
      $game_map.fog_blend_type = 0 # type de transparence, 0 = normal
      $game_map.fog_zoom = 200 # zoom
      $game_map.fog_sx = 0 # vitesse en x
      $game_map.fog_sy = 0 # vitesse en y


Donc on a l'opacité! Une fois initialisée, pas besoin de toucher au reste!
Il suffit donc de faire une boucle:

Code:


$compteur = 0 #On initialise la variable à 0
<boucle>
$compteur += 1 #on incrémente la variable
$game_map.fog_opacity = $compteur #on modifie l'opacité
condition: le script : $compteur % 20 == 0 # La condition est donc vraie
                              # toutes les 20 frames
attendre 1 frame
fin de la condition
condition: le script: $compteur == 120 # 120/ 20 = 6, donc 6 secondes au total,
                # la transition, pour atteindre une opacité de 120
sortir de la boucle #donc dès qu'on a atteint l'opacité voulue, on quitte la boucle
fin de la condition
<fin de la boucle>


Voilà voilà, ce sera tout pour ce tuto, je tenais simplement à montrer l'utilité d'un modulo, très utile pour les transition ou les appels à intervalles fixes!

Ah merde, c'était à ça que servait le modulo ? xD
Je n'en savais rien, alors j'avais fait une ligne de commande complexe de soustraction de variables pour y parvenir. x)
Merci du tuto. ;P

De rien, c'était le but du tuto
Pratique aussi pour faire des ia marchant avec des mathématiques, comme le fameux jeu de craies à la fort boyard, qui possède simplement une astuce mathématique ^^!

Bonne idée de démystifier le modulo, que moi-même je ne comprenais pas avant de faire de la programmation.
Alors quand on m'a dit que c'était tout bêtement le reste de la division euclidienne, je me suis dit que c'était beaucoup de prise de tête pour pas grand-chose.
Donc finalement, c'est bien de signaler qu'il s'agit au final d'une notion plutôt simple à comprendre.

J'ai pas vraiment compris les exemples (en dehors des minutes/secondes, qui est un cas classique ; les autres, je les ai un peu survolés) mais bon...

De mon côté, j'avais trouvé un cas d'utilisation intéressant du modulo, mais je sais pas si en ruby il est très intéressant : c'est le passage d'un tableau unidimensionnel à bidimensionnel.

Si j'ai un tableau unidimensionnel T1[]

T1[0]

T1[1]

T1[2]

T1[3]

T1[4]

T1[5]

T1[6]

T1[7]

T1[8]

T1[9]

T1[10]

T1[11]

Et un bidimensionnel T2[][]

T2[0][0]	T2[0][1]	T2[0][2]	T2[0][3]
T2[1][0]	T2[1][1]	T2[1][2]	T2[1][3]
T2[2][0]	T2[2][1]	T2[2][2]	T2[2][3]

En fait, on passe juste de l'un à l'autre en "pliant" ou "dépliant" les lignes.
Pour trouver la correspondance entre les deux tableaux (càd i, x et y tels que T1[i] == T2[y][x] ), on peut trouver les indices :

i = largeur_tableau_bidimensionnel * y + x; connaissant la largeur du tableau bidimensionnel, x et y

x = i % largeur_tableau_bidimensionnel;
y = i / largeur_tableau_bidimensionnel;
Connaissant la largeur et i.

En pratique, ça peut servir pour faire un jeu de cartes, par exemple.
Imaginons :

Coeur	Trèfle	Carreau	Pique
As	As	As	As
2	2	2	2
3	3	3	3
4	4	4	4
...	...	...	...

Pour simplifier, prenons As = 1, Valet = 11, Dame = 12 et Roi = 13.
Au passage, il aurait été plus pratique de faire démarrer chaque série à 0 si on utilise un langage dont les tableaux commencent à partir de l'indice 0, mais bon...

Je peux déplier ça pour faire un paquet de 52 cartes : pour chaque couleur, on a 13 cartes différentes. Il suffit de les mettre bout à bout pour avoir le paquet de cartes. Ainsi on a As de coeur, 2 de coeur, ... , Roi de coeur, As de trèfle, ... , Roi de trèfle, As de carreau, ... , Roi de carreau, As de pique, ... , Roi de pique.
L'intérêt ? Eh bien on peut mélanger de façon plus simple et plus réaliste notre paquet de cartes (mais après, il faut de l'aléatoire et ça c'est autre chose...). Avec le bidimensionnel, ça aurait été plus difficile.

L'autre intérêt, c'est qu'on a notre paquet, tableau unidimensionnel qui contient toutes nos cartes. Eh bien avec seulement l'indice de la carte qu'on choisit, on peut retrouver sa couleur et son numéro.
Au préalable, il faudra associer les couleurs à des nombres : par exemple coeur = 0, trèfle = 1, carreau = 2 et pique = 3.
Et là, on comprend tout d'un seul coup : l'as de coeur est représenté par T[0][1], le 2 de coeur par T[0][2], l'as de trèfle par T[1][1], l'as de pique par T[3][1], le roi de pique par T[3][13]...
Du coup ça revient au problème précédent.

Bon, en pratique, ça peut servir si vous recodez un jeu de cartes (sur RM, je sais pas, ailleurs sans doute), et que vous en avez marre des sempiternels solitaire, freecell et compagnie de Windows.
M'enfin c'était un exemple d'utilisation du modulo comme un autre, et c'était principalement pour ça que j'en ai parlé...

Merci baucoup Garsim pour ce complément ^^!
J'ai quelques points à soulever ^^! Tout d'abbord quelques erreurs dans ton premier tableau, mais ça c'est pas grave ^^
Sinon, pour l'exemple du jeu de carte, oui certes on peut passer en modulo, mais sinon une simple table bidimensionnelle suffit d'un coté la valeur de la carte, de l'autre la couleur, donc de 0 à 12 pour la valeur, et de 0 a 3 pour la couleur. Pourquoi faire ça? Car le modulo ne récupère pas le dividende de la division euclidienne... Seul le reste. Donc pour savoir qu'elle est la couleur, obligation de rajouter une petite fonction, ou une petite ligne.
J'avais fais un début de poker en javascript, avec l'équivalent de 2000 lignes de codes ^^ Faudra que je le finisse un jour, à 90% ce serais bête de l'abandonner ^^!

Larcange a écrit:Tout d'abbord quelques erreurs dans ton premier tableau, mais ça c'est pas grave ^^

Lesquelles ?

Larcange a écrit:Sinon, pour l'exemple du jeu de carte, oui certes on peut passer en modulo, mais sinon une simple table bidimensionnelle suffit d'un coté la valeur de la carte, de l'autre la couleur, donc de 0 à 12 pour la valeur, et de 0 a 3 pour la couleur. Pourquoi faire ça? Car le modulo ne récupère pas le dividende de la division euclidienne... Seul le reste. Donc pour savoir qu'elle est la couleur, obligation de rajouter une petite fonction, ou une petite ligne.

Heuuuu... ben si, le modulo permet de récupérer le numéro, et pour la couleur, on récupère le quotient avec la division euclidienne bien connue de tous.
Ensuite, si je passe par un tableau à une dimension, c'est juste pour faciliter le mélange des cartes en fait. Je me souviens plus s'il peut avoir une autre utilité par contre... moi c'était pour un jeu de blackjack en C que j'ai pas fini non plus. :lol:

Code:


T2[0][0]   T2[0][1]   T2[0][2]   T2[0][3]
T2[1][0]   T2[1][1]   T2[1][2]   T2[0][3]
T2[2][0]   T2[2][1]   T2[2][2]   T2[0][3]


Dejà, en ruby, on met d'abord les x, puis les y ^^
et sinon regarde la dernière colonne, on voit le copié collé =D

Larcange a écrit:

Code:


T2[0][0]   T2[0][1]   T2[0][2]   T2[0][3]
T2[1][0]   T2[1][1]   T2[1][2]   T2[0][3]
T2[2][0]   T2[2][1]   T2[2][2]   T2[0][3]


Dejà, en ruby, on met d'abord les x, puis les y ^^
et sinon regarde la dernière colonne, on voit le copié collé =D

Ah mais c'est le deuxième tableau ça... (à moins que tu ne les indices à 0 ? )
Pour le copié/collé, c'est réglé (c'était inévitable l'erreur, je l'admets...).
Ensuite... bah comme j'ai plus l'habitude des matrices et du C (et que je m'emmêle souvent les pinceaux avec les indices), j'ai fait comme ça, mais ça peut s'adapter. Faut juste savoir auquel des deux (x ou y) le modulo doit être attribué...


Edit pour en-dessous : non, c'est juste un nom complètement bateau que les programmeurs donnent à leurs variables (comme toto, T, tab, et j'en passe...)

T2

Tu veux dire les t2 de terminator ?




==>[]

Flood inutile et qui nuit au lecteur avec ta vieille image.
Je te conseil d'arréter un peu ton flood Slup, sa devient trés chiant et au bout d'un moment t'aura un averto.

D'accord, je vais essaye de me retenir un peu.