Comment coder Time Stop ou Bullet Time dans un jeu?

Je suis en train de développer un jeu de plateforme RPG solo dans XNA 4.0. Je voudrais ajouter une capacité qui ferait arrêter ou ralentir le temps, et que seul le personnage du joueur bouge à la vitesse d'origine (similaire au sort Time Stop de la série Baldur's Gate). Je ne recherche pas une implémentation exacte, plutôt des idées générales et des modèles de conception.

EDIT: Merci à tous pour l'excellente contribution. J'ai trouvé la solution suivante

    public void Update(GameTime gameTime)
        {

            GameTime newGameTime = new GameTime(gameTime.TotalGameTime,
 new TimeSpan(gameTime.ElapsedGameTime.Ticks / DESIRED_TIME_MODIFIER));
            gameTime = newGameTime;

ou quelque chose dans ce sens. De cette façon, je peux définir une heure différente pour le composant joueur et différente pour le reste. Ce n'est certainement pas assez universel pour fonctionner pour un jeu où le temps de déformation comme celui-ci serait un élément central, mais j'espère que cela devrait fonctionner pour ce cas. Je n'aime pas du tout le fait qu'il couvre la boucle de mise à jour principale, mais c'est certainement le moyen le plus simple de le mettre en œuvre. Je suppose que c'est essentiellement la même chose que le tesselode a suggéré, donc je vais lui donner la coche verte :)

Cela pourrait être une mauvaise solution, mais pas nécessairement. Si vous utilisez le temps delta, vous pouvez changer cela pour changer la vitesse de certaines choses.

Par exemple:

player.update(dt)
dt = dt * .5 --half speed
enemy.update(dt)

Bien sûr, cela ne fonctionne que si vous pouvez savoir quand vous mettez à jour l'ennemi plutôt que quelque chose d'autre. Vous pouvez également donner à tout une valeur de vitesse et faire quelque chose comme:

x = x + xspeed * dt * speed

L'utilisation du temps delta (millisecondes qui se sont écoulées depuis la dernière image) peut ne pas être suffisante pour ralentir les ennemis. Des choses comme le taux d'attaque peuvent être implémentées en fonction du dernier temps d'attaque. Bien qu'il ralentisse le mouvement s'il est basé sur le temps, il néglige de ralentir le taux d'attaque, le lancement de sorts et d'autres effets (régénération de la santé, durée des effets des sorts) .. et autres

Si vous voulez ralentir un grand groupe d'éléments de jeu dans une partie solo, vous pouvez créer une deuxième horloge interne pour chaque créature, l'horloge démarre à l'heure actuelle lorsque la créature apparaît. Lorsqu'un sort lent est lancé, à chaque image, l'horloge est incrémentée de x% du temps qui s'est réellement écoulé. Tout comportement de monstre est alors déterminé par son horloge interne. Si différents monstres ont une résistance à ralentir, ils peuvent utiliser leur propre horloge, c'est fondamentalement un entier qui ne nécessite pas beaucoup d'espace ou de calcul.

Lorsque l'effet lent s'arrête, les horloges sont toujours utilisées et sont incrémentées de 100% du temps qui s'est réellement écoulé.

Cela pourrait également fonctionner pour les sorts de hâte.

@Sidar: Je vois deux choix,

1. Horloge interne par créature. Pour savoir si la créature est prête à attaquer à nouveau: enregistrez la dernière fois que chaque attaque a été utilisée + temps de recharge et vérifiez si l'horloge interne est déjà passée à ce moment-là.

2. Un chronomètre par attaque: vous savez combien de temps il faut à l'attaque pour se recharger et vous réglez simplement un chronomètre et soustrayez le temps écoulé * (1-% de ralentissement) à chaque tour.

Personnellement, je préfère éviter de soustraire plusieurs minuteries individuelles et d'utiliser une horloge interne pour économiser sur le temps de traitement et la complexité.

C'est vraiment à la préférence (cela n'affecte pas beaucoup les performances).

Vous pouvez commencer avec une solution simple comme celle exposée par tesselode ou Mr Beast. Mais si vous commencez à mélanger des choses complexes, c'est-à-dire un temps de balle pendant qu'un sort de ralentissement est lancé, vous serez coincé.

Je vous suggère d'implémenter une hiérarchie d'horloge :

.
├── Main clock
│   └── UI clock
│   └── 3D clock
│       ├── GFX clock
│       └── Gameplay clock
│           └── Slowdown spell clock 01
│           └── Slowdown spell clock 02

Tout dans votre jeu doit utiliser les temps delta de l'une des horloges: les effets graphiques s'exécutent sur l'horloge GFX, l'IA et l'animation s'exécutent sur l'horloge de gameplay, les créatures affectées par un sort de ralentissement s'exécutent sur une horloge de sort de ralentissement temporaire, etc. affecter différentes parties de votre hiérarchie: un sort de ralentissement crée et affecte une horloge personnalisée, tandis qu'un temps de balle affectera toute la hiérarchie d'horloge 3D.

Vous avez juste besoin de deux horloges différentes au lieu d'une, une pour l'heure pertinente au gameplay et une "vraie" heure.

currentGameTime = 0;
gameSpeed = 1.0f;
[...]
currentApplicationTime = GetTime():
timeDelta = (currentApplicationTime - lastApplicationTime)*gameSpeed;
currentGameTime += timeDelta;
lastApplicationTime = currentApplicationTime;

Ensuite, vous pouvez simplement changer gameSpeed ​​pour accélérer (> 1) ou ralentir le temps (<1). Pour que le joueur se déplace à une vitesse différente, vérifiez simplement si le temps est ralenti ou non.