Est-ce que le stockage d'itérateurs dans cette classe est imprudent? Sinon, comment parcourir cette séquence?

Question

Attention, c'est une longue question! J'implémente un jeu de cartes Solitaire en C++ sur Win32, et après avoir demandé this question, il devient clair que j'ai besoin d'un peu de conseils concernant la conception de classe réelle plutôt que des détails de mise en œuvre. J'utilise un modèle de contrôleur de vue modèle pour implémenter le jeu. Le modèle est le jeu, les cartes, les colonnes et l'historique des mouvements. La vue est responsable de la peinture à l'écran et le contrôle responsable de la gestion des messages et de la minuterie.

L'aspect du jeu que j'essaye actuellement de mettre en application est l'histoire d'action, qui appartient au Model - je veux pouvoir "défaire" et "refaire" n'importe quel Action.

Je décris un objet Move comme un mouvement atomique d'une seule carte d'un CardPile à un autre. Et j'ai décrit un Action comme consistant en un ou plusieurs Moves. par exemple. un accord sera 10 Moves du Deck à un particulier Column. (Deck et Column sont simplement des spécialisations de CardPile).

Je définis l'action comme une suite de déplacements, et j'ai fourni certaines fonctions à GetCurrentMove() et à Advance() un déplacement lorsqu'il a été effectué.

class Action 
{ 
public: 
    void SetMoves(std::deque<Move> dmoves){ _m_deque = dmoves; } 
    void Advance(); 
    std::deque<Move>::const_iterator GetCurrentMove(); 
private: 
    std::deque<Move> _m_deque; 
    std::deque<Move>::const_iterator currentmove; 
}; 

Lorsque vous traitez (ou la mise en place, ou défaisant), ces Move objets sont données pour une animation. Je dois être en mesure d'accéder à un seul objet Move à la fois. Je récupère le Move, l'analyse en coordonnées x et y puis lance une animation pour déplacer une carte d'un endroit à un autre à l'écran. Lorsque la carte a atteint sa destination, je tire un autre Move de la deque.

J'ai été conseillé par d'autres avec plus d'expérience, de ne pas stocker des itérateurs dans la classe Action. Le STL ne le fait pas et il y a apparemment de bonnes raisons.

Mais ma question est - est-ce que je n'ai pas avoir pour stocker les itérateurs dans la classe Action? Vous voyez à la fois mon modèle et vue besoin d'accéder à l'Move actuel, alors où puis-je stocker cet itérateur qui fait référence à l'actuel Move ... à l'intérieur du contrôleur?

Mon animation de jeu est basé (très large) sur ce modèle:

void control.game_loop(message) 
{ 
    switch(message) 
    { 
     case TIMER: 
     { 
      if(view.CardHasReachedDestination()) 
      { 
      game.AdvanceAnimation(); 
      if(!game.AnimationFinished()) 
       view.Parse(game.GetNextMove()); 
      } 
      view.MoveCardXY(); 
      view.PaintToTheScreen(); 
      controller.StartTheTimerAgain(); 
     } 
    } 
} 

Meilleurs voeux,

BeeBand

Answer 1

Je créerais un modèle de fonction pour animer une action entière, pas seulement un mouvement à la fois.Invoke qui avec début et de fin itérateurs pour l'action qui doit être animé:

template <class iterator> 
void animate_action(iterator first, iterator last) { 
    for (iterator i=first; i!=last; ++i) 
     animate_move(*i); 
} 

Où animate_move est à peu près ce que vous aviez déjà pour montrer l'animation d'un seul mouvement. Vous auriez invoquez cela avec quelque chose comme:

animate_action(action.begin(), action.end()); 

ou pour animer dans l'ordre inverse:

animate_action(action.rbegin(), action.rend()); 

Ceci est (une grande partie de) la raison pour laquelle vous voulez faire animate_action un modèle - de cette façon il ne sait ni ne se soucie de savoir s'il reçoit un itérateur avant ou un inverseur. Edit: D'après les autres commentaires, il semble y avoir quelques alternatives.

Le stand-by norme serait d'utiliser un thread séparé pour gérer le dessin animé, il aurait juste quelque chose comme:

while (current_position != final_position) { 
    draw_card(currrent_position); 
    current_position = next_position(); 
    sleep(timer_period); 
} 

Une autre solution serait plutôt que d'attendre une minuterie au feu, et En demandant l'itérateur actuel à ce moment-là, j'aurais tendance à créer et à mettre en file d'attente un objet représentant chaque mouvement dans l'animation, puis le temporisateur récupèrera et exécutera l'élément suivant dans la file d'attente:

for (int i=0;i<Move.size(); i++) 
    for (int j=0; j<num_positions; j++) 
     enqueue(move, Move[i], position(j)); 

Answer 2

Si vous utilisez une liste au lieu d'un deque, puis les itérateurs pointant à un élément restera valide pour la durée de vie de l'élément.

Si vous faites cela, je ne vois rien de mal à stocker des itérateurs dans ce cas.