Comment mettre en œuvre le moteur à base de tiques simple c ++?

Question

J'écris un jeu de texte et j'ai besoin d'un simple système de combat, comme dans les ILM, vous émettez des commandes, et une fois dans un certain temps « tique » arrive, lorsque toutes ces commandes exécutent, joueur et monstres infligent des dégâts, toutes sortes de choses différentes qui se passe. Comment puis-je mettre ce concept? Je pensais à faire une variable qui contient la dernière fois à cocher, et une fonction seulement met des événements sur pile et quand ce temps est (temps + x) les exécute tous simutaniously. Y at-il plus facile ou plus propre variante de le faire?

Quelle serait la syntaxe possible pour cela?

double lastTickTime;
double currentTime;

void eventsPile(int event, int target)
{
// how do i implement stack of events? And send them to execute() when time is up?
}

void execute(int event, int target)
{
     if ((currentTime - lastTickTime) == 2)
     {
         eventsHandler(event, target);
     }    
     else 
     { // How do I put events on stack?
     }
}

Answer 1

Le problème avec la pile d'action simple est que l'ordre des actions sera probablement fondés sur le temps - celui des types les plus rapides frapper un premier coup. Vous devriez probablement introduire des priorités dans la pile, de sorte que, par exemple, tous les événements mondiaux déclenchent d'abord, puis les événements d'action créatures, mais ces événements d'action sont commandés par un attribut comme l'agilité, ou le niveau. Si une créature a une agilité plus élevé alors qu'il obtient le premier coup.

Answer 2

D'après ce que j'ai vu, la plupart de ces moteurs sont l'événement, plutôt que le temps, sur la base. avec un nouvel être de tick déclenché un certain intervalle après la dernière tick terminée. (Évitant ainsi la plupart du temps la question de ticks plus long que l'intervalle)

Cela simplifie également la mise en œuvre; il vous suffit d'une boucle de jeu qui déclenche un événement de tick, puis sleeps / yields pour l'intervalle requis. Ce qui est trivial .

Il peut en outre être simplifiée par la modélisation du monde comme un arbre, où chaque élément gère les événements qui se propagent (tels que ticks) à leurs enfants. tant que vous éviter / gérer « boucles », cela fonctionne bien (je l'ai fait).

Cela réduit efficacement le système de tick à quelque chose comme ça (psudocode):

while (isRunning) {
    world->tick();
    sleep(interval);
}

Dans la plupart des cas, peu theres besoin d'obtenir beaucoup plus sophistiqué que le réglage de la longueur de la durée précédente.

Toutes les actions des entités individuelles ferait partie de leur propre file d'attente d'action et traitées au cours de leur propre événement « tic ».

Habituellement, les commandes de l'utilisateur serait divisé en « dedans » et « meta » commandes, quoi que ce soit ingame ne ferait que modifier la file d'attente d'action de leur caractère, à traiter dans leur prochain tick, selon la normale pour toute autre entité.

combat à base ronde simple découle naturellement de cette fondation. en temps réel peut être modélisé avec une division plus fine de ticks, avec option « temps mise en commun ».

Answer 3

Utilisez une minuterie exécution toutes les x ms (alors que x est votre Déf), exécuter toutes les actions mises sur la pile dans cette méthode.