Horloge analogique

Sujet: Horloge analogique Lun 6 Sep 2010 - 23:40

Bonjour tout le monde.

Je vous propose un module qui permet d'afficher dans votre jeu une horloge analogique, comme ça :

(Bon, il ne tient qu'à vous d'avoir un rendu moins brouillon clin d'oeil

)

Vous pouvez le télécharger ici !

A. Définition des fonctions :

Spoiler:

B. Utilisation des fonctions :

Spoiler:

L'utilisation est un peu particulière, mais cela pour permettre une plus grande flexibilté.

Comme vous avez pu le remarquer, les fonctions retournent des Dynamic Sprites.
L'idée est la suivante : on veut, par cette fonction, obtenir une image (sous forme de Dynamic Sprite, donc) qui représente l'heure qu'on lui a renseignée, de manière analogique (des aiguilles sur un cadran).

La première fonction Horloge.Create permet d'obtenir une Dynamic Sprite fort simple, où l'aiguille des minutes et l'aiguille des heures sont de simples traits d'un pixel de large, de la couleur et de la taille spécifiée.

Exemples :

Code:

DynamicSprite* reveil = Horloge.Create(22,30,10,20);

aura pour effet de stocker une image dans la variable reveil qui représentera une aiguille de 10 pixels de long pour les heures, pointant vers le haut à gauche (22 heures) ainsi qu'une aiguille de 20 pixels de long pour les minutes, pointant vers le bas (30 minutes) ; le tout d'une épaisseur de 1 pixel, en noir sur un fond transparent.
Si j'avais voulu spécifier une épaisseur et une couleur pour les heures ainsi que pour les minutes, il suffisait de les passer en cinquième, sixième, septième et huitième arguments. De même, pour obtenir une couleur de fond, il fallait la passer en neuvième argument. Voici comment obtenir la même image que précédemment, avec cette fois une aiguille des heures verte (index 2) de 3 pixels d'épaisseur, une aiguille des minutes rouge (index 4) de 5 pixels d'épaisseur et un fond blanc (index 15) :

Code:

DynamicSprite* reveil = Horloge.Create(22,30,10,20,3,5,2,4,15);
La deuxième fonction Horloge.CreateFromSprite permet d'obtenir une Dynamic Sprite plus élaborée, où l'aiguille des minutes et l'aiguille des heures correspondent à des sprites que vous spécifiez. Ces sprites doivent représenter des aiguilles pointant vers le haut pour la cohérence de la rotation. Vous pouvez également, si vous le désirez, spécifier une sprite représentant le fond du cadran en dernier argument. A défaut, le fond sera transparent.

Exemples :

Code:

DynamicSprite* reveil = Horloge.CreateFromSprite(22,30,60,61,62);

aura pour effet de stocker une image dans la variable reveil qui représentera la sprite 60 de votre projet pointant vers 22h, la sprite 61 de votre projet pointant vers 30min par-dessus la sprite 62 de votre projet. Attention toutefois, cette fonction est d'autant plus lente que les sprites sont de dimensions importantes, il faut donc éviter d'y recourir trop souvent.

C. Exemple d'utilisation :

Spoiler:

Voici le script d'une pièce où j'affiche un cadran analogique en "temps réel" :

Code:: int looping = 9; // Cette variable permettra
// de ne mettre à jour l'horloge que tous
// les 10 cycles de jeu, ce qui évitera
// de faire ramer le processeur
DynamicSprite* horloge; // La sprite qui représentera le cadran,
// hors de toute fonction pour ne pas
// s'effacer lorsque la fonction où on
// appelle Horloge.CreateFromSprite est terminée.

// S'exécute à chaque cycle de jeu
function room_RepExec()
{

if (looping == 10) { // Ne sera validée que tous les 10 cycles de jeu

DateTime *dt = DateTime.Now; // dt représente le moment présent

// On passe l'heure et les minutes actuelles
// et on utilise les sprites 61 et 62 pour les aiguilles,
// la 63 pour le fond. La sprite sera stockée dans horloge,
// qui demeure tant qu'on est dans la pièce.
horloge = Horloge.CreateFromSprites(dt.Hour, dt.Minute, 61, 62, 63);

// La propriété Graphic nous permet de redéfinir
// l'image associée à l'objet Reveil.
oReveil.Graphic = horloge.Graphic;

looping = 0; // On remet le compteur à 0

}

else looping++; // On incrémente looping à chaque cycle de jeu

}

Explications :

Puisque l'horloge n'affiche que les minutes et les heures, pas besoin de la mettre à jour à chaque cycle de jeu ! Ma variable looping est là pour ça : je ne mets mon horloge à jour que tous les 10 cycles. Heureusement car la fonction que j'appelle (Horloge.CreateFromSprites) est un peu gourmande : elle effectue une rotation des sprites, ce qui est une opération relativement lente, surtout si ces sprites sont grandes.

Je crée une DynamicSprite horloge en haut du script, hors des fonctions, puisque je veux qu'elle reste affichée tout le temps qu'on reste dans la pièce.
Ensuite, dans RepExec (s'exécute à chaque tour de jeu dans la pièce), tous les 10 cycles de jeu, j'appelle ma fameuse fonction Horloge.CreateFromSprite.
Cette fonction retourne une DynamicSprite que j'associe à horloge pour qu'elle reste toujours active. Puis je remplace l'image associée à l'objet oReveil par l'image correspondant à horloge. L'idée consiste donc à remplacer l'image d'un objet se trouvant dans la pièce (par exemple, mais on peut aussi si l'on veut utiliser un calque d'image) par le slot d'image correspondant à la sprite retournée.

Voilà, n'hésitez pas à signaler tout bug, à demander des explications et à approter vos commentaires et suggestions !

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Sujet: Re: Horloge analogique Mar 7 Sep 2010 - 6:42

Intéressant tout ça sourire

_________________
Mon profil Facebook!
Mon site avec tous mes jeux, vidéos, illustrations etc
Mon Discord

Sujet: Re: Horloge analogique Mar 7 Sep 2010 - 7:54

Bonne idée ! :

:

Sujet: Re: Horloge analogique Mar 7 Sep 2010 - 8:27

excellent
c est un truc dont j aurais besoin un jour

Sujet: Re: Horloge analogique Mer 8 Sep 2010 - 15:31

J'ai mis à jour le fichier pour quelques améliorations :

L'aiguille des heures se déplace continuellement selon les minutes, non plus d'heure en heure
Ajout du paramètre d'épaisseur des traits pour Horloge.Create
Rotation plus exacte des aiguilles dans Horloge.Create
Diminution du risque de bug lors de la rotation dans Horloge.CreateFromSprite (vous pouvez désormais passer 25h80 ou -11h-40, cela affichera 1h20 -- mais pas 2h20).

Voilà, j'attends vos éventuels commentaires et suggestions ^^

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Sujet: Re: Horloge analogique Mer 8 Sep 2010 - 18:28

c'est super intéressant et wouaaa mais vous avez pas mal à la tête de faire des trucs compliqué comme ça ? en tout cas chapeau ça peut être utile suivant le projet .

Par contre dans tout les jeux auquel j'ai pu joué (outre les simulations de vie) on remarque que le temps est toujours en suspension ou erroné comme les jeux de cartoon ou l'aiguille va plus vite que son ombre .
A moins de l'utiliser comme un minuteur avec des jeux qui suis le cours du temps , ça peut être très intéressant mais loin de ma portée (j'imagine déjà les page de script à marqué j'en ai la nausée !!)

Sujet: Re: Horloge analogique Mer 8 Sep 2010 - 19:18

L'idée c'est justement de pouvoir l'utiliser comme on veut : soit pour un temps fictif, soit pour le temps réel (c'est l'utilisation que j'en fais dans l'exemple avec la ligne DateTime *dt = DateTime.Now).

En fait j'ai fait ça d'abord parce que je fais un petit projet où l'aspect doit changer selon que l'on y joue le jour ou la nuit (temps réel, donc). Et vu que dans une pièce j'avais placé un réveil, je me suis dit "autant faire correspondre l'heure affichée à l'heure réelle".

Sinon je me suis amusé à faire un petit script, très simple, qui permet de modifier l'heure affichée en tournant la roulette de la souris : ça donne un effet assez marrant

mikeeen2d a écrit:: j'imagine déjà les page de script à marqué j'en ai la nausée !!

Et non, justement, c'est vraiment pas très compliqué : clin d'oeil

:

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Sujet: Re: Horloge analogique Jeu 9 Sep 2010 - 17:17

Comment te remercier pour ce travail que j'utiliserais un jour.

Une sucette?

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

Bonjour !

Je découvre ce post au bon moment, car je me questionnais à propos de créer une horloge en temps réel sourire

J'espère que quelques gens survolent encore cet endroit ! sourire

Je me demandais, du coup c'est possible de faire que quand on arrive en room 7, l'horloge tourne (grâce au repeteadly execute), puis lorsqu'on quitte la room 7 et qu'on arrive par exemple en room 6, l'horloge est toujours là mais "arrêtée" ? Et en appuyant un bouton qui pourrait simuler une nuit de sommeil, l'horloge a avancé de par exemple 8H30, mais reste statique ?

Exemple plus concret : dans la room 6 l'horloge est statique, dans la room 7 l'horloge tourne grâce au repeteadly execute :

- on est en room 6, l'horloge affiche 8H30. On clique sur "passer la nuit". Petit GUI qui montre un dessin de nuit jolie (!), on l'enlève puis l'horloge affiche 16H45. Toujour statique cependant. On clique sur un hotspot, puis on va en room 7, avec au passage un petit temps écoulé (le temps d'enfiler son pantalon et d'aller en expedition), il est désormais 17H30.

- arrivée en room 7 : là l'horloge affiche 17H30, et le repeteadly execute continue de faire tourner l'horloge, cette fois en temps réel. L'expédition se termine à 22H45, on quitte la room 7.

- lorsqu'on quitte la room 7 , l'horloge se fige donc à 22H45, et revenu en room 6, elle affiche 22H45. Il faudra ensuite passer la nuit et refaire la même chose etc...

Ce genre de choses seraient donc possibles ?

Et possible aussi de faire que l'horloge qui tourne soit en temps accéléré ? Par exemple : 10 minutes en temps réel = 1H pour l'horloge ?

Ce que tu décris est tout à fait possible : ce module ne s'occupe que du rendu visuel de l'horloge, c'est à toi de gérer l'écoulement du temps. L'exemple dans le premier poste esquive le problème en utilisant directement le temps du système (dt.Hour et dt.Minute), mais dans ton cas tu peux utiliser une variable globale que tu modifies à l'envie. Mettons que ta variable globale s'appelle tempsactuel et qu'elle aille de 0 jusqu'à 1440 (= 24*60), alors tu peux modifier la ligne 23 pour quelque chose dans ce style-là :

Code:: int heures = tempsactuel / 60, minutes = tempsactuel % 60;
horloge = Horloge.CreateFromSprites(heures, minutes, 61, 62, 63);

En ce qui concerne la gestion du temps lui-même, il va te falloir passer par des repeatedly_execute et tout le tintouin. Pour ton exemple de 10 minutes en temps réel = 1H pour l'horloge, il "suffit" d'incrémenter tempsactuel tous les N cycles de jeu (en fonction de ton FPS, donc)

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

OK, merci pour la réponse !

En fait, j'ai une question du coup pour les FPS : quand je crée un compteur de FPS, c'est jamais vraiment régulier (même si ça fait pas des bonds entre le lent et le fluide bien sûr). Ce qui implique que la gestion du temps serait irrégulière ?

Typiquement, si le jeu rame un peu, la précision de l'échelle du temps "dans le jeu" sera perturbée ? Ou alors le compte de l'heure sera indépendant du rendu visuel ?

Enfin, je sais pas si je suis clair... :S

EDIT : aussi, que signifie :

Code:: int minutes = tempsactuel % 60

?!?

Oui, si tu calcules ton temps en terme de cycles de jeu, et si ton FPS est pas constant, t'auras un temps irrégulier. Si tu veux quelque chose de plus constant, plutôt qu'incrémenter "bêtement" tous les N cycles, tu peux plutôt vérifier le temps système pour voir combien de temps s'est écoulé depuis le dernier cycle de vérification et incrémenter en proportion

L'opérateur % c'est "modulo", ça te retourne le reste de la division. Donc tempsactuel % 60 ça va te donner combien il te reste après avoir divisé tempsactuel par 60, c'est-à-dire donc le nombre de minutes (le nombre d'heures étant la partie entière du résultat de la division par 60).

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

OK, effectivement si c'est plus "sûr", alors, je préfère sourire

Du coup, comment on vérifie le temps système et comment on scripte cela ? Je ne connais pas ce genre de choses, mais si c'est "mieux" que les FPS, alors pourquoi pas !

Baguettator a écrit:: Du coup, comment on vérifie le temps système et comment on scripte cela ?

Comme illustré dans l'exemple du premier message, tu peux utiliser l'objet DateTime

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

Ah ok je comprends mieux à quoi ça correspond !

C'est vrai que mon jeu n'étant pas quelque chose d'animé (pas de persos qui bougent ou d'images en animation), le compteur FPS montre que le jeu oscille entre 36 et 40 FPS. C'est peut-être pas si grave ? Je ne sais pas si on peut avoir vraiment un vrai 40 FPS constant ?

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

Du coup, j'ai testé rapidement, ça marche d'enfer ! J'ai juste un problème : la sprite du "cadran" est rognée légèrement, je ne sais pas à cause de quoi... Une raison à cela ?

Il me semble que la taille de l'horloge correspond à un carré dont le côté est 2 fois la hauteur de la plus haute image entre celle de l'aiguille des heures et celle de l'aiguille des minutes, donc si ton fond est plus grand que ça il sera rogné

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

OK, je vais regarder ça !

J'ai codé dans le repeteadly execute du global script quelque chose comme ça :

Code:: tempsaccel++;

if (tempsaccel == 600)
{
tempsactuel++;
tempsaccel=0;
}

if (tempsactuel==1440)
{
tempsactuel=0;
}

Selon mes prédictions, ça devrait permettre de faire que le temps va 4 fois plus vite : 15 secondes = 1 minute. A 40 FPS : 15 secondes = 600 cycles de jeu, donc tous les 600 cycles, tempsactuel gagne 1, ça veut dire 1 minute "in game". Quand tempsactuel = 1440, c'est minuit pile (24 heures), donc on réinitialise. Et c'est reparti.

J'ai vu juste ?

Ça me parait juste oui

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

Re !

Alors aussi j'ai voulu te signaler que j'ai eu parfois des crashs avec l'horloge, ça disait quelque chose du genre "la rotation peut pas être de plus de 359 degrés".

Si jamais ça se représente, je noterai bien le problème, peut-être que c'est juste dû à un script que j'avais mal fait (ma valeur de tempsactuel allait au-dessus de 1440, donc au-delà de 24H pour l'horloge)...

Donc si a priori personne ne s'est jamais plaint, tout doit bien fonctionner, et ça doit être de mon côté grand sourire

Cliqueur Amateur Nombre de messages : 232 Date d'inscription : 21/05/2020

Bonjour Kitai,

Je reviens vers toi, car j'ai eu à nouveau des problèmes avec ce module de l'horloge.

Effectivement, j'ai une erreur qui me dit :

"in Horloge.asc line 73
from room 7, line 601

Error : DynamicSprite.Rotate : invalid angle (must be 1 - 359)"

cela arrive de temps en temps. Je n'arrive pas à en trouver la source, et j'imagine que le problème ne vient pas du module.

Comme dit plus haut, je passe par une variable tempsactuel pour compter le temps, et une variable tempsaccel qui fait évoluer tempsactuel à une certaine proportion par rapport au temps réel (4 fois plus vite).

Voici mon script qui gère l'horloge :

Code:: function room_RepExec()
{

if (IsGamePaused() ==0)
{
if (looping == 10) { // Ne sera validée que tous les 10 cycles de jeu

DateTime *dt = DateTime.Now; // dt représente le moment présent (A PRIORI CETTE LIGNE SERT PLUS A RIEN VU QUE J'UTILISE tempsactuel POUR SUIVRE LE TEMPS)

// On passe l'heure et les minutes actuelles
// et on utilise les sprites 61 et 62 pour les aiguilles,
// la 63 pour le fond. La sprite sera stockée dans horloge,
// qui demeure tant qu'on est dans la pièce.
int heures = tempsactuel / 60, minutes = tempsactuel % 60;
horloge = Horloge.CreateFromSprites(heures, minutes, 1888, 1890, 1891); // naturellement c'est celle-ci la ligne 601

// La propriété Graphic nous permet de redéfinir
// l'image associée à l'objet Reveil.
oReveil.Graphic = horloge.Graphic;

looping = 0; // On remet le compteur à 0

}

else looping++; // On incrémente looping à chaque cycle de jeu

tempsaccel++;

if (tempsaccel >= 600)
{
tempsactuel++;
tempsaccel=0;

if (tempsactuel==60) Eventhoraire(6);
if (tempsactuel==120) Eventhoraire(6);
if (tempsactuel==180) Eventhoraire(6);
if (tempsactuel==240) Eventhoraire(6);
if (tempsactuel==300) Eventhoraire(1);
if (tempsactuel==360) Eventhoraire(1);
if (tempsactuel==420) Eventhoraire(1);
if (tempsactuel==480) Eventhoraire(1);
if (tempsactuel==540) Eventhoraire(2);
if (tempsactuel==600) Eventhoraire(2);
if (tempsactuel==660) Eventhoraire(2);
if (tempsactuel==720) Eventhoraire(2);
if (tempsactuel==780) Eventhoraire(3);
if (tempsactuel==840) Eventhoraire(3);
if (tempsactuel==900) Eventhoraire(3);
if (tempsactuel==960) Eventhoraire(3);
if (tempsactuel==1020) Eventhoraire(4);
if (tempsactuel==1080) Eventhoraire(4);
if (tempsactuel==1140) Eventhoraire(4);
if (tempsactuel==1200) Eventhoraire(4);
if (tempsactuel==1260) Eventhoraire(5);
if (tempsactuel==1320) Eventhoraire(5);
if (tempsactuel==1380) Eventhoraire(5);
if (tempsactuel==1440) Eventhoraire(5);

if (tempsactuel==60 || tempsactuel==780) aClocher_1h.Play();
if (tempsactuel==120 || tempsactuel==840) aClocher_2h.Play();
if (tempsactuel==180 || tempsactuel==900) aClocher_3h.Play();
if (tempsactuel==240 || tempsactuel==960) aClocher_4h.Play();
if (tempsactuel==300 || tempsactuel==1020) aClocher_5h.Play();
if (tempsactuel==360 || tempsactuel==1080) aClocher_6h.Play();
if (tempsactuel==420 || tempsactuel==1140) aClocher_7h.Play();
if (tempsactuel==480 || tempsactuel==1200) aClocher_8h.Play();
if (tempsactuel==540 || tempsactuel==1260) aClocher_9h.Play();
if (tempsactuel==600 || tempsactuel==1320) aClocher_10h.Play();
if (tempsactuel==660 || tempsactuel==1380) aClocher_11h.Play();
if (tempsactuel==720 || tempsactuel==1440) aClocher_12h.Play();
}

if (tempsactuel==1440) tempsactuel=0; // si c'est 24H, on dit que c'est 0H (la meme chose)
if (tempsactuel>1440) tempsactuel=tempsactuel - 1440; // si jamais ça passe au-dessus, on fait comme si on recommençait un jour nouveau à partir de 0H
}

Je me demande si le problème vient pas du fait que ma sécurité de "si tempsactuel dépasse 1440 alors on lui soustrait 1440 pour lui donner la valeur correcte" est placée en-dessous de la mise à jour de la sprite. Quand j'arrive dans cette room, juste avant d'y arriver j'ajoute une valeur aléatoire à tempsactuel (pour simuler un temps écoulé pendant le voyage), et peut-être que parfois tempsactuel dépasse 1440. La sprite de l'horloge est mise à jour avant le fade-in et pendant le repeteadly execute, mais j'ai l'impression que le crash arrive avant le fade-in. Peut-être je dois mettre cette sécurité avant le fade-in ?

En tout cas, aucun moyen que le problème vienne de ton script, a priori ? J'imagine que ça a été testé et retesté sourire

C'est possible que le problème vienne de l'ordre d'excécution, comme tu décris.

Essaie d'enlever tes deux derniers ifs (lignes 74 et 75 dans le bloc de code de ton message) et insère ça dans la ligne 3 (vide dans le bloc de code de ton message) :

Code:: tempsactuel = tempsactuel % 1440;

De cette façon tu seras sûr que tempsactuel n'atteint ni ne dépasse jamais 1440, et donc heures ne pourra jamais dépasser 23

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !

Sujet: Re: Horloge analogique Ven 6 Nov 2020 - 18:39

Salut Kitai !

Désolé, mais j'ai encore des soucis avec cette horloge... toujours un plantage à un moment. Je comprends pas pourquoi, bien que j'aie respecté tes indications avec les modulos etc...

Voici le code de mon "Repet execute" de la room7, là où il y a l'horloge :

Code:: // S'exécute à chaque cycle de jeu
function room_RepExec()
{
tempsactuel = tempsactuel % 1440;

if (IsGamePaused() ==0)
{
if (looping == 10) { // Ne sera validée que tous les 10 cycles de jeu

int heures = tempsactuel / 60, minutes = tempsactuel % 60;
horloge = Horloge.CreateFromSprites(heures, minutes, 1888, 1890, 1891); // Evidemment c'est ici que le bug a lieu, lorsque c'est midi/minuit pile on dirait.

oReveil.Graphic = horloge.Graphic;

looping = 0; // On remet le compteur à 0

}

else looping++; // On incrémente looping à chaque cycle de jeu

tempsaccel++;

if (tempsaccel >= 600)
{
  tempsactuel++;
  tempsaccel=0;

  if (tempsactuel==60) Eventhoraire(6);
  if (tempsactuel==120) Eventhoraire(6);
  if (tempsactuel==180) Eventhoraire(6);
  if (tempsactuel==240) Eventhoraire(6);
  if (tempsactuel==300) Eventhoraire(1);
  if (tempsactuel==360) Eventhoraire(1);
  if (tempsactuel==420) Eventhoraire(1);
  if (tempsactuel==480) Eventhoraire(1);
  if (tempsactuel==540) Eventhoraire(2);
  if (tempsactuel==600) Eventhoraire(2);
  if (tempsactuel==660) Eventhoraire(2);
  if (tempsactuel==720) Eventhoraire(2);
  if (tempsactuel==780) Eventhoraire(3);
  if (tempsactuel==840) Eventhoraire(3);
  if (tempsactuel==900) Eventhoraire(3);
  if (tempsactuel==960) Eventhoraire(3);
  if (tempsactuel==1020) Eventhoraire(4);
  if (tempsactuel==1080) Eventhoraire(4);
  if (tempsactuel==1140) Eventhoraire(4);
  if (tempsactuel==1200) Eventhoraire(4);
  if (tempsactuel==1260) Eventhoraire(5);
  if (tempsactuel==1320) Eventhoraire(5);
  if (tempsactuel==1380) Eventhoraire(5);
  if (tempsactuel==1440) Eventhoraire(5);

  if (tempsactuel==60 || tempsactuel==780) aClocher_1h.Play();
  if (tempsactuel==120 || tempsactuel==840) aClocher_2h.Play();
  if (tempsactuel==180 || tempsactuel==900) aClocher_3h.Play();
  if (tempsactuel==240 || tempsactuel==960) aClocher_4h.Play();
  if (tempsactuel==300 || tempsactuel==1020) aClocher_5h.Play();
  if (tempsactuel==360 || tempsactuel==1080) aClocher_6h.Play();
  if (tempsactuel==420 || tempsactuel==1140) aClocher_7h.Play();
  if (tempsactuel==480 || tempsactuel==1200) aClocher_8h.Play();
  if (tempsactuel==540 || tempsactuel==1260) aClocher_9h.Play();
  if (tempsactuel==600 || tempsactuel==1320) aClocher_10h.Play();
  if (tempsactuel==660 || tempsactuel==1380) aClocher_11h.Play();
  if (tempsactuel==720 || tempsactuel==1440) aClocher_12h.Play();
}

if (tempsactuel==1440) tempsactuel=0;
if (tempsactuel>1440) tempsactuel=tempsactuel - 1440;
}

Voici un screen shot lors du bug (on dirait que c'est 11H58, je ne sais pas, je vais faire un truc pour faire bouger l'heure avec une touche ou avec la mollette de la souris pour vérifier précisément).

https://ibb.co/2sjpq1w

Une idée ? clin d'oeil

EDIT 2 : l'erreur dans le script de l'horloge est sur cette ligne :

Code:: he2.Rotate((h % 12) * 30 + (m % 60) / 2 + 1); // On tourne (+1 car Rotate ne supporte pas la valeur 0)
mi2.Rotate((m % 60) * 6 + 1); // De même, on module pour ne pas dépasser 359

Si je comprends bien, tempsactuel (la variable qui compte le temps) ne doit pas être égale à 1440 ni à 0. L'erreur ne vient-elle pas que dans mon cas, tempsactuel peut être égal à 0 ? (notamment dans le cas où tempsactuel=1440, moi je le remets à 0. C'est peut-être ça qui va pas ?)

EDIT 3 : je viens de tester : le jeu plante quand j'arrive à tempsactuel=1438. Donc quand il est 11H58, effectivement.

EDIT 4 : le jeu plante aussi à tempsactuel=1439. Mais pas à tempsactuel=1440. Incroyable !

Sujet: Re: Horloge analogique Ven 6 Nov 2020 - 19:24

Alors, je pense que le problème vient vraiment du script de l'horloge, car cela plante lorsqu'il est 11H58 ou 11H59, indépendamment du fait qu'il est près de midi ou près de minuit. Les autres changements d'heure sont fonctionnels sans souci par contre.

Ou alors : le fait d'être passé par un temps accéléré a fait que j'ai écrit une fausse manip ?

Est-ce pas un problème que des divisions font des chiffres à virgule, et que du coup certains résultats sont "arrondis" par AGS car dans le script on ne manipule que des "int" (je n'ai pas vu de float).

Sujet: Re: Horloge analogique Ven 6 Nov 2020 - 19:59

Essaie de remplacer par ces lignes, voir si ça résoud le problème :

Code:: he2.Rotate( (((h % 12) * 30 + (m % 60) / 2) % 359) + 1 );
mi2.Rotate( (((m % 60) * 6) % 359) + 1 );

Et oui, tu as raison : lorsqu'il est 11h58, h%12 vaut 11, et m%60 vaut 58, 58/2 vaut 29, donc (h%12)*30 + (h%60)/2 vaut 330 + 29 = 359, +1 = 360, et Rotate n'accepte pas 360 comme valeur. Même chose pour 11h59, comme tu dis 59/2 est arrondi à 29, donc on se retrouve dans la même situation qu'avec 58.

_________________
Ga is Ga
Vous pouvez consulter l'aide d'AGS 3.2 en français et contribuer à la traduction et à l'amélioration si le cœur vous en dit !