Discussion :

[Smeuuh]

Bonjour, j'ai une grande question existencielle.
J'essaie pour le moment de développer un logiciel de Magic (pour ceux qui connaissent, le jeu de cartes). Enfin bon, la particularité du jeu, c'est que les cartes réécrivent les règles. Et yen a 10000 :/
Donc je cherche à modéliser ca, en n'importe quel langage (je suis en C#, mais prêt à changer). J'avais pensé à faire des scripts pour chaque carte, mais comment les interpréter ? Je peux le compiler et l'éxécuter, mais est ce que ca pourra interragir avec les variables du reste ?
Typiquement, ce qu'il me faut, c'est ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int a = 0;
fonction("a = 2");
//a vaut 2

Quelqu'un sait comment faire ca sous n'importe quel langage ? Je pourrais m'en sortir avec la réflexion (écrire un interpréteur et tout), mais je me demande s'il existe une solution plus simple ...
Merci d'avance.

[herve91]

bonsoir,
je pense que c'est une bonne idée que tu te définisses un langage de script pour écrire les règles liées aux cartes. Après, le choix du langage (C# ou autre) n'a que peu d'importance pour compiler et interpréter ton langage, tous les langages un tant soit peu évolués se valent pour faire ça (analyse syntaxique, construction/parcours d'arbre abstrait, génération de code, interprétation).
Par contre, je pense que tu fais une confusion quand tu écris :

int a = 0;
fonction("a = 2");
//a vaut 2

la variable "a" dans l'expression "a = 2" (qui est une variable du langage de script) n'a rien à voir avec la variable "a" de "int a = 0;" (qui est une variable du langage dans lequel tu codes).

[Smeuuh]

Justement, c'est ca que je voudrais, fondre les deux. Surtout que je fais ca en POO. Si c'est plus clair, je voudrais un truc comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Joueur
{
int pointsDeVie = 20;
}
class Principale
{
static void Main()
{
Joueur joueur1 = new Joueur();
fonction("joueur1.pointsDeVie--;");
}
}

En fait, les cartes ca modifie vraiment tout dans le jeu (l'idéal en fait, ca serait de réécrire les fonctions, mais ca je doute que ca soit possible). En plus, de nouvelles cartes sortent à intervalles réguliers. Ca serait bien que je puisse faire un seul programme, et totu faire sur un texte à coté après quoi.
Merci en tout cas d'avoir pris le temps de répondre.

[herve91]

Tu peux faire correspondre une valeur en mémoire aux différents "champs" mentionnés sur les cartes. Par exemple un système de getter/setter par nom :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Entite {
  HashMap champs = new HashMap();

  public Object getValeurChamp(String nomChamp) {
    return champs.get(nomChamp);
  }

  public void setValeurChamp(String nomChamp, Object valeurChamp) {
    champs.put(nomChamp, valeurChamp);
  }
}

[Smeuuh]

Oui, c'est ce que je pensais faire en désespoir de cause. Mais yaurait pas un moyen qui puisse faire le tout plus simplement, le considérer comme du code source quoi ? J'avais essayé de voir ce qui était faisable avec la réflexion, mais j'ai pas vraiment trouvé de trucs aussi simples (quoique avec la réflexion, je peux faire de l'attribution de variables super simplement, mais pas du vrai code quoi)

[herve91]

Oui, c'est ce que je pensais faire en désespoir de cause. Mais yaurait pas un moyen qui puisse faire le tout plus simplement, le considérer comme du code source quoi ?

Je ne comprends pas ce que tu veux dire, du code source ? Tu parles de ce qui est "écrit" sur les cartes ? Si c'est bien ça, en effet c'est du code source qu'il te faudra interpréter (éventuellement après une phase de compilation).

[Smeuuh]

Non non, du "vrai" code source.
Ce que je veux dire, c'est faire qu'une string soit considérée comme du code source. Comme compiler un fichier source, sauf qu'il est à l'intérieur du .exe quoi (il partage le namespace, les variables, etc). Bien évidemment, ca pourrait se faire qu'avec un langage interprété ou en pseudo code (pas du C++ quoi).
M'enfin, si c'est pas possible, je ferai sans, c'est pas trop grave

[sjrd]

Il existe une librairie excellente qui fait exactement ce que tu veux, à savoir faire correspondre des éléments du scripts avec des éléments de ton programme. Mais cette librairie compile du Pascal et est développée pour Delphi. Je crois qu'il doit être possible de la faire fonctionner avec C++ Builder ; mais si es prêt à apprendre n'importe quel langage, et que tu comptes utiliser cette solution, je te conseille de passer à Delphi, d'autant plus que tu peux télécharger gratuitement la version 2005 perso sur DVP.

Cette librairie est Pascal Script de RemObjects :
http://www.remobjects.com/?ps

[Smeuuh]

Merci, c'est exactement ca que je cherche ! (sauf que j'aime pas Pascal et que je n'y connais rien en Delphi )

[DrTopos]

Il y a un langage qui fait exactement ce que tu veux sans ajout d'aucune bibliothèque, c'est LISP. En LISP, tu écris une expression (une donnée) et tu peux immédiatement la considérer comme un programme. Tu peux générer dynamiquement des programmes et les exécuter séance tenante. Le système de macros de LISP est d'ailleurs tout simplement prodigieux, et les C, C++, Pascal, Java, ... sont très loin d'en faire autant. Je pense que 'SCHEME' doit être le clone de LISP le plus simple à utiliser. Pour ton problème ça me paraît tout indiqué. N'oublions pas que LISP est le langage favori de l'intelligence artificielle.

[Smeuuh]

Le LISP a l'air marrant et intéressant. Mais y-a-til une implémentation avec une interface graphique ? Le jeu de cartes en mode console, moyen quoi :/

[Jedai]

Tu as également Perl, Python, Ruby qui disposent tous de la fonction eval() qui permet de faire ce que tu veux... Néanmoins je crois que tu modélises mal ton problème : Les règles de Magic ne changent pas "complètement" à chaque fois que tu poses une carte ! (j'y ai joué pas mal, donc je sais de quoi je parle)
Je pense que tu ferais mieux de modéliser ça par un système de "hooks", autrement dit, tu modélises le flux normal du jeu mais aux moments cruciaux (début d'une phase, pose d'une carte sur la pile, ...) tu fait exécuter une liste de fonctions spécifique (par exemple une liste de fonction de nom hooksAvantPhase). Tu crées des objets cartes qui ont la faculté de rajouter des fonctions à ces listes quand elles sont exécutées, d'en enlever quand on les retire du jeu, etc... Je pense que c'est plutôt ça que tu devrais faire.

--
Jedaï

[DrTopos]

Les règles de Magic ne changent pas "complètement" à chaque fois que tu poses une carte ! (j'y ai joué pas mal, donc je sais de quoi je parle)
Je pense que tu ferais mieux de modéliser ça par un système de "hooks"...

Effectivement si les programmes que tu as à faire ne sont que des listes de fonctions 'primitives', tu n'as pas besoin d'outils très sophistiqués, et l'utilisation de Lisp reviendra à utiliser un marteau-pilon pour écraser une mouche. Ceci dit, Lisp est un langage très à part et très enthousiasmant, et je crois sincèrement qu'on loupe quelque chose de très important (sur le plan de la culture informatique) si on ne le connait pas.

Certains livres sur Lisp insistent sur une notion de programmation dirigée par les données. Ca consiste tout simplement à remplacer certains programmes par des données (qui d'une certaine façon décrivent les opérations à effectuer) et d'écrire seulement un petit interpréteur, qui effectue ces opérations en lisant ces descriptions. C'est un truc qui a été abondamment utilisé en intelligence artificielle, car même s'il diminue les performances, il introduit une grande souplesse, par exemple pour les systèmes qui apprennent pendant leur fonctionnement. Il peut être appliqué avec n'importe quel langage. La méthode que propose Jedaï s'apparente clairement à cette technique, les listes de fonctions étant les données qui dirigent le programme.

[Jedai]

C'est sûr que Lisp est très intéressant, mais un peu déconcertant aussi pour le nouveau venu... En tout cas il peut sans doute faire ce qu'il veut dans le langage de son choix, ce que je décris étant possible dans à peu près tous les langages modernes. Après s'il est curieux, il sait maintenant que Lisp est un langage très puissant qui peut lui faciliter la tâche.

--
Jedaï

[Trap D]

Le LISP a l'air marrant et intéressant. Mais y-a-til une implémentation avec une interface graphique ? Le jeu de cartes en mode console, moyen quoi :/

Il y a Allegro CL, avec une version d'essai.

[Bruno75]

Smeuuh, je crois qu'il suffit d'utiliser la dérivation.

Ton jeu va ressembler à qqch comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Joueur {
  PointsDeVie: int;
  Adversaire: Joueur;
  ResisteAuFeu: bool;
  ...
}

class Carte {
  void UtiliserCarte(PropriétaireCarte: Joueur); virtual; abstract;
}

Ensuite pour chaque carte tu dérives la classe Carte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class CarteBouleDeFeu : public Carte {
 Dégat: Int;
 void UtiliserCarte(UnJoueur: Joueur); override;

  
}

CarteBouleDeFeu::CarteBouleDeFeu {
  Dégat = 2
}

void CarteBouleDeFeu ::UtiliserCarte(PropriétaireCarte: Joueur); {
  if not PropriétaireCarte.Adversaire.ResisteAuFeu then
    Adversaire.PointsDeVie -= Dégat
}

et tu as plus qu'à dériver 10000 fois la classe Carte. Bon courage

[Luc Hermitte]

C'est ingérable par héritage. Avec 'gic, deux cartes séparées c'est un truc, deux cartes combinées (dans un ordre qui peut varier), c'en est un autre.

Il faut passer du côté des scripts, ou du moins avoir un langage pour exprimer toutes les variations de règles et un moteur pour interpréter les résultats finaux.

Tu vas avoir un gros boulot d'isolation des parties communes et des variations apportées par les diverses cartes.

[Bruno75]

C'est ingérable par héritage. Avec 'gic, deux cartes séparées c'est un truc, deux cartes combinées (dans un ordre qui peut varier), c'en est un autre.

Il faut passer du côté des scripts, ou du moins avoir un langage pour exprimer toutes les variations de règles et un moteur pour interpréter les résultats finaux.

Tu vas avoir un gros boulot d'isolation des parties communes et des variations apportées par les diverses cartes.

Effectivement, comme je ne connais pas trop magic, la dérivation était un peu simpliste.

Après comme le précise Luc Hermitte, tout va dépendre du type de règles que l'on rencontre. Quoi qu'il arrive tu auras besoin de les factoriser correctement.

ceci dit le message est vieux d'un mois donc bon ...

[Luc Hermitte]

Effectivement, comme je ne connais pas trop magic, la dérivation était un peu simpliste.

Ce n'est pas une question de simplisme. C'est une question que le couplage induit par de l'héritage est bien trop fort, et ne conviendra pas pour décrire des effets -- ceux récherchés ici.
D'autant que l'élément atomique décrivant un effet, ce n'est pas la carte. La carte tient plus de l'aggrégat.

[Bruno75]

c'est mon français qui est pas bon. Je voulais dire, j'avais une vision trop simpliste des règles qui m'a conduit à penser que la dérivation aurait pu suffire mais effectivement ce n'est pas le cas.

Après on peut faire une classe aggrégat contenant une liste de cartes, avec chaque carte étant une liste dynamique obtenu à partir d'une liste de définition de cartes, chaque définition sachant quoi ajouter à cette liste dynamique.

faudrait avoir le type de règle dans magic pour savoir