Tous les modèles pour la modélisation des jeux de société?

il semble que ce soit une de 2 mois vieux thread que j'ai juste remarqué que maintenant, mais ce que le diable. J'ai conçu et développé le gameplay cadre d'une activité commerciale, réseau de conseil de jeu avant. Nous avons eu une expérience très agréable de travailler avec elle.

Votre jeu peut probablement être dans une (à proximité) quantité infinie d'états en raison de la permutation des choses comme la façon dont beaucoup d'argent au joueur, combien d'argent le joueur B a, et etc... Donc, je suis sûr que vous voulez rester à l'écart de l'état des machines.

L'idée derrière notre cadre pour représenter l'état de la partie en tant que structure avec tous les champs de données qui, ensemble, fournissent le jeu complet de l'état (c'est à dire: si vous voulez enregistrer le jeu sur le disque, vous écrivez que la structure).

Nous avons utilisé le Modèle De Commande représenter l'ensemble de la validité des actions de jeu un joueur pouvait faire. Ici, serait un exemple d'action:

class RollDice : public Action
{
  public:
  RollDice(int player);

  virtual void Apply(GameState& gameState) const; //Apply the action to the gamestate, modifying the gamestate
  virtual bool IsLegal(const GameState& gameState) const; //Returns true if this is a legal action
};

Donc, vous voyez que, pour décider si un déplacement est valide, vous pouvez la construire, et puis d'appeler sa IsLegal fonction, en passant dans le jeu actuel de l'état. Si elle est valide, et le joueur confirme l'action, vous pouvez appeler l'application de fonction pour réellement modifier l'état de la partie. En veillant à ce que votre jeu de code ne peut modifier le jeu de l'état par la création et le dépôt légal des Actions (donc, en d'autres termes, l'Action::Appliquez de la famille de méthodes est la seule chose à modifier directement l'état de la partie), puis de vous assurer que votre état de jeu ne sera jamais nulle. En outre, en utilisant le modèle de commande, vous faites, il est possible de sérialiser vos joueur mouvements souhaités et de les envoyer sur un réseau à être exécuté sur un autre joueur de jeu d'états.

Il a fini par être une chasse aux sorcières avec ce système qui s'est avéré avoir un assez élégant. Parfois, les actions de deux ou plusieurs phases. Par exemple, le joueur peut poser sur une propriété de Monopole et doit maintenant prendre une nouvelle décision. Quel est l'état de la partie entre le moment où le joueur de lancer les dés, et avant de se décider à acheter une propriété ou pas? Nous avons géré des situations de ce genre en mettant en scène un "Contexte d'Action" membre de notre état de jeu. Le contexte d'action devrait normalement être nulle, indiquant que le jeu n'est pas actuellement dans toute spéciale de l'état. Lorsque le joueur lance les dés et les jets de dés, l'action est appliquée à l'état de la partie, il se rendra compte que le joueur a atterri sur une des nations unies appartenant à la propriété, et peut créer un nouveau "PlayerDecideToPurchaseProperty" contexte d'action qui contient l'indice du lecteur que nous sommes en attente d'une décision. Au moment où le RollDice l'opération est terminée, notre jeu de l'etat déclare qu'il est actuellement en attente pour le joueur spécifié décider d'acheter une propriété n'est pas. Il est maintenant facile pour toutes les autres actions " IsLegal méthode de fausse déclaration, à l'exception du "BuyProperty" et "PassPropertyPurchaseOpportunity" actions, qui sont seulement juridique, lorsque l'état de la partie a de la "PlayerDecideToPurchaseProperty" contexte d'action.

Grâce à l'utilisation de contextes d'action, il n'y a jamais un seul point dans la durée de vie du jeu de plateau où le jeu de la structure de l'état n'est pas complètement représentent EXACTEMENT ce qui se passe dans le jeu à ce point dans le temps. C'est un très souhaitable de propriété de votre jeu de plateau de système. Il sera beaucoup plus facile pour vous d'écrire du code, quand vous pouvez trouver tout ce que vous voulez savoir sur ce qui se passe dans le jeu par l'examen d'une seule structure.

En outre, elle étend très bien pour les environnements réseau, où les clients peuvent soumettre leurs actions sur un réseau à une machine hôte, qui peut s'appliquer à l'action de l'hôte "officielle" de l'état de jeu, et puis l'écho de cette action à tous les autres clients d'avoir à l'appliquer à leur répliqué jeu d'états.

J'espère que ce n'était concise et utile.

Je viens de terminer la conception et la mise en œuvre d'un état de jeu basé sur l'utilisation du polymorphisme.

À l'aide d'une base de classe abstraite appelée GamePhase qui dispose d'une méthode

abstract public GamePhase turn();

Ce que cela signifie, c'est tous les GamePhase objet contient l'état actuel du jeu, et un appel à turn() regarde son état actuel et retourne le prochain GamePhase.

Chaque béton GamePhase a des constructeurs qui détiennent le ensemble état de jeu. Chaque turn() méthode a un peu les règles du jeu à l'intérieur. Tout ceci permet de répartir les règles, il maintient le lien entre les règles de la proximité. Le résultat final de chaque turn() est juste de la création de la prochaine GamePhase et en le passant dans l'état complet dans la prochaine phase.

Cela permet turn() d'être très flexible. En fonction de votre jeu à un état donné peut s'étendre à beaucoup de différents types de phases. Cela forme un graphique de toutes les phases de jeu.

Au plus haut niveau, le code pour le lecteur c'est très simple:

GamePhase state = ...initial phase
while(true) {
    //read the state, do some ui work
    state = state.turn();
}

Cela est extrêmement utile car je peux maintenant créer facilement tout état/phase de jeu pour les tests

Maintenant pour répondre à la deuxième partie de votre question, comment cela fonctionne dans le mode multijoueur? Dans certains GamePhases qui nécessitent la saisie de l'utilisateur, un appel de turn() serait de demander à l'actuel Player leur Strategy compte tenu de l'état/de la phase. Strategy est juste une interface de toutes les décisions possibles d'un Player peut faire. Cette configuration permet également Strategy à être mis en œuvre par l'IA!

Aussi Andrew Haut a dit:

Votre jeu peut probablement être dans une (à proximité) quantité infinie d'états en raison de la permutation des choses comme la façon dont beaucoup d'argent au joueur, combien d'argent le joueur B a, et etc... Donc, je suis sûr que vous voulez rester à l'écart de l'état des machines.

Je pense que cette déclaration est très trompeur, s'il est vrai qu'il y a beaucoup de jeu différents états, il y a seulement quelques phases de jeu. Pour gérer son exemple, il serait est un paramètre entier pour les constructeurs de mes béton GamePhases.

Monopole

Exemple de certains GamePhases serait:

• GameStarts
• PlayerRolls
• PlayerLandsOnProperty (FreeParking, GoToJail, Go, etc)
• PlayerTrades
• PlayerPurchasesProperty
• PlayerPurchasesHouses
• PlayerPurchasesHotels
• PlayerPaysRent
• PlayerBankrupts
• (Toutes les Chance et caisse de Communauté de cartes)

Et de certains états dans la base GamePhase sont:

• Liste des Joueurs
• Joueur actuel (qui est à son tour)
• L'Argent du joueur/de la Propriété
• Maisons/Hôtels sur les Propriétés
• De La Position Du Joueur

Et puis certaines phases d'enregistrer leur propre etat, en tant que de besoin, par exemple PlayerRolls serait d'enregistrer le nombre de fois qu'un joueur a rouler consécutives doubles. Une fois que nous quittons la PlayerRolls phase, nous nous moquons de rouleaux consécutifs plus.

Beaucoup de phases peuvent être réutilisés et liés ensemble. Par exemple, le GamePhase CommunityChestAdvanceToGo serait de créer la prochaine phase PlayerLandsOnGo avec l'état actuel et de le retourner. Dans le constructeur de PlayerLandsOnGo l'actuel joueur serait déplacé d'Aller et de leur argent serait incrémenté de $200.

Une grande partie des matériaux que je peux trouver en ligne sont des listes de références bibliographiques. La section des publications de Jeu De Modèles De Conception a des liens vers des versions PDF des articles et des thèses. Beaucoup ressemblent à des études universitaires comme Les Modèles de conception pour les Jeux. Il y a aussi au moins un livre disponible sur Amazon, Les modèles dans la Conception de Jeu.

Je suis d'accord avec Pyrolistical réponse et je préfère sa façon de faire les choses (j'ai juste écrémé autres réponses si).

Par coïncidence, j'ai aussi utilisé son "GamePhase" de nommage. Fondamentalement, ce que je ferais dans le cas d'un tour par tour jeu de plateau est votre GameState classe contient un objet de l'abstrait GamePhase comme mentionné par Pyrolistical.

Permet de dire que le jeu d'états sont les suivants:

1. Rouleau
2. Déplacer
3. Acheter, de Ne pas acheter
4. Prison

Vous pourriez avoir en béton les classes dérivées pour chaque état. Ont des fonctions virtuelles au moins pour:

StartPhase();
EndPhase();
Action();

Dans le StartPhase() fonction vous pouvez définir toutes les valeurs initiales d'un état par exemple la désactivation de l'autre joueur de l'entrée et ainsi de suite.

Lorsque roll.EndPhase() est appelée alors assurez-vous que le GamePhase pointeur est défini pour l'état suivant.

phase = new MovePhase();
phase.StartPhase();

Dans ce MovePhase::StartPhase (), vous auriez, par exemple, définir le du joueur actif mouvements restants pour le montant transféré dans la phase précédente.

Maintenant avec ce modèle en place, vous pouvez trier vos "3 double x = prison" problème à l'intérieur de la phase de Roulis. Le RollPhase classe peut gérer son propre état. Par exemple

GameState state; //Set in constructor.
Die die;         //Only relevant to the roll phase.
int doublesRemainingBeforeJail;
StartPhase()
{
    die = new Die();
    doublesRemainingBeforeJail = 3;
}

Action()
{
    if(doublesRemainingBeforeJail<=0)
    {
       state.phase = new JailPhase(); //JailPhase::StartPhase(){set moves to 0};            
       state.phase.StartPhase();
       return;
    }

    int die1 = die.Roll();
    int die2 = die.Roll();

    if(die1 == die2)
    {
       --doublesRemainingBeforeJail;
       state.activePlayer.AddMovesRemaining(die1 + die2);
       Action(); //Roll again.
    }

    state.activePlayer.AddMovesRemaining(die1 + die2);
    this.EndPhase(); //Continue to moving phase. Player has X moves remaining.
}

Je diffèrent de Pyrolistical dans lequel il devrait y avoir une phase de tout, y compris lorsque le joueur arrive sur la Communauté de la poitrine ou de quelque chose. Je serait en mesure de gérer tout cela dans le MovePhase. C'est parce que si vous avez trop d'étapes, le joueur sera très probablement se sentir trop "guidé". Par exemple, si il y a une phase où le joueur ne peut acheter des propriétés et alors SEULEMENT acheter les hôtels et alors SEULEMENT acheter des maisons, l'un de ses semblables il n'y a pas de liberté. Il suffit de claquer toutes ces pièces dans un BuyPhase et de donner au joueur la liberté d'acheter tout ce qu'il veut. Le BuyPhase classe peut assez facilement gérer ses achats juridique.

Enfin, nous allons aborder le terrain de jeu. Si un tableau 2D est très bien, que je vous recommande d'avoir une tuile graphique (où une tuile est une position sur la carte). Dans le cas de monoppoly il serait plutôt une liste à double liaison. Ensuite, chaque tuile aurait un :

1. previousTile
2. nextTile

De sorte qu'il serait beaucoup plus facile de faire quelque chose comme:

While(movesRemaining>0)
  AdvanceTo(currentTile.nextTile);

La AdvanceTo fonction permet de gérer votre étape par étape, des animations ou ce que vous voulez. Et aussi décrémenter mouvements restants de cours.

RS Conley Conseils sur le Pattern observer pour l'interface graphique est bonne.

Je n'ai pas posté beaucoup de temps avant. Espérons que cela aide quelqu'un.