Bonjour,
j'ai passé ma journée d'hier à écrire un petit programme pour retrouver l'ambiance de WarGames.
 
Mon objectif est de programmer le serveur Wopr et un client de connexion si besoin.
Comme mes connaissances sont minimes en informatique, je viens vous demander comment vous procéderiez ?
Quel technique/technologie exploiter ? ... Etc.
Comment organiser mon projet ? ... Etc.
Je souhaite réaliser ce projet de manière réaliste.
Merci.
 
 
Le résultat d'hier :

Ou F1..F5 permet de changer de niveau d'alerte.

Projet sympa
Mais tu veux faire quoi après ? Gérer l'IA du WOPR sur une partie d'échec, faire jouer le wopr contre lui même au morpion, ...  
 

 
L'objectif est de développer une I.A. forte... Pourquoi ? ... J'ai rien d'autre à faire et puis, j'aimerais avoir l'avis un spécialiste sur le comportement à adopter par la concience en présence d'une telle intelligence, ... Quasi parfaite. (c'est pas simple ... Si ?)
 
Bref, WarGames est pour moi un passage pour apprendre à développer un environnement pour L'I.A et L'I.A elle même.
 
Soit, jouer au échec n'est pas exclue. Quant à faire jouer le Wopr contre lui même, ce ne sera que dans le but de lui enseigner que : "A strange game. The only winning move is not to play.".
 
Et faire avancer la science, c'est pas exclu non plus.
 
En espérant avoir répondu à la question.
 

Hello !    
 
Un screenshot pour introduire...

 
 
Les specifications avec Ada :
Listes des fichiers :
src/lib/WarGames/wargames.ads
src/lib/WarGames/wargames-norad.ads
src/lib/WarGames/wargames-norad-console.ads
src/lib/WarGames/wargames-wopr.ads
 
Sources :

package WarGames is
   pragma Pure (WarGames);
end WarGames;
package WarGames.NORAD is
 
   type T_LertCon is (DEFCON_1,
                      DEFCON_2,
                      DEFCON_3,
                      DEFCON_4,
                      DEFCON_5,
                      AD_EMERGENCY,
                      D_EMERGENCY,
                      NO_EMERGENCY);
   subtype T_Defcon is T_LertCon range DEFCON_1..DEFCON_5;
   subtype T_EmergCon is T_LertCon range AD_EMERGENCY..NO_EMERGENCY;
   task LertCon_Ctrl is
      entry DefSet(New_Condition : in T_DefCon);
      entry DefGet(New_Condition : out T_DefCon);
      entry EmergSet(New_Condition : in T_EmergCon);
      entry EmergGet(New_Condition : out T_EmergCon);
      entry Halt;
   end LertCon_Ctrl;
private
   DefCon : T_DefCon := DEFCON_5;
   EmergCon : T_EmergCon := NO_EMERGENCY;
end WarGames.NORAD;
package WarGames.NORAD.Console is
   procedure Main;
end WarGames.NORAD.Console;
 
package WarGames.WOPR is      
   procedure Main;      
end WarGames.WOPR;

 
Bon tout reste à faire, mais j'ai quand même pas mal hésité pour établir la dépendance des paquetages.
Alors justement, quelqu'un en pense quelque chose ?

Ah, oui, alors, en fait, j'ai fait dépendre le WOPR du NORAD et non l'inverse.
Après j'ai fait une machine abstraite nommé Armament.Weapon. mais je l'ai pas intégré tout de suite.

ADA est un bon langage. Maintenant c'est pas le plus évident à appréhender, surtout en ce qui concerne le réseau...  
 
La gestion d'une IA sur une partie de morpion est assez simple. C'est nettement plus compliqué sur une partie d'échec, surtout en ce qui concerne le principe même du WOPR est l'apprentissage par renforcement.
 

 
Je postais ce code plus pour le fun qu'autre chose.
 
Après j'ai aucune idée de solution pour le moment.

J'attaque la lecture : http://www.cs.ualberta.ca/%7Esutto [...] -book.html

Bonjour, ...
J'ai un peu lu, mais, j'ai surtout beaucoup réfléchi.
Alors, je ne sais encore si je je vais résoudre le problème par le renforcement. C'est pas exclue.
 
Pour le moment, tout ce que j'ai, c'est "un joueur qui doit être en mesure de jouer seul à un ensemble de jeu". C'est ma formulation de mon premier problème.
En réalité comme ensemble de jeu, je pense au jeux combinatoire dont le tablier est de forme rectangulaire.
Avec ce qui suit j'espère pouvoir résoudre des jeux comme, les dames, les échecs, le morpion, et puissance 4. J'ai oublié "la bataille navale"
Pour faire ça j'ai commencé à spécifier les classes jeux et jeu respectivement dans les paquetage np-games et np.games-game.
Avec Ada ça donnes ça :
 

package Np is
end Np;

package Np.Games is
   type T_Player is (Left, Right);
   type T_Piece is new Positive;
   type Piece_Access is access all T_Piece;
   type T_Apron is array (Positive range <>,
                          Positive range <> ) of Piece_Access;
   type T_Option is access procedure (Apron : in out T_Apron);
   type T_Init_Procedure is access procedure (Apron : out T_Apron);
   type T_Owner_function is access function (Piece : T_Piece) return T_Player;
   type T_Games(Name : access String;
                Piece : T_Piece;
                Apron : access T_Apron;
                Init  : T_Init_Procedure;
                Owner : T_Owner_Function) is abstract tagged null record;
   type Games_Access is access all T_Games'Class;
   type T_Game_Set is array (Positive range <> ) of Games_Access;
end Np.Games;

generic
   Name      : String;
   Num_Piece : T_Piece;
   Apron     : access T_Apron;   
   Init      : T_Init_Procedure;
   Owner     : T_Owner_Function;
package Np.Games.Game is   
   type T_Option_Set is array (T_Piece range 1..Num_Piece) of T_Option;
   type T_Game(Options : access T_Option_Set) is 
     new T_Games(new String ' (Name),
         Num_Piece,
         Apron,
         Init,
         Owner) with null record;
end Np.Games.Game;

 
 
 
Utilisation
 

with Np.Games.Game;
use Np.Games;
package Np.Chess is
   Chess_Apron : access T_Apron := new T_apron(1..8, 1..8);
   procedure Chess_Init(Apron : out T_Apron);
   function Chess_Owner(Piece : in T_Piece) return T_Player;
   package Chess is new Game("Chess",
                             12,
                             Chess_Apron,
                             Chess_Init'Access,
                             Chess_Owner'access);
 
   use Chess;
   Chess_Option_Set : access T_Option_Set:= new T_Option_Set;
end Np.Chess;

(normalement l'utilisation de games-game ce fait dans le corp.) En fait non.
 
 
Main :

with Np.Chess;
use Np.Chess;
procedure Main is
   use Chess;
   Chess : T_Game(Chess_Option_Set);
begin
 
   null;
end Main;

 
 
Donc, c'est pas gros, mais déjà là, j'espérais avoir confirmation que c'est en bonne voie.
Peut-on en juger ? Merci pour votre aide.

Bonjour,
 
Question du jour : Comment baser une partie de Global Thermonuclear War sur l'apprentissage par renforcement ?    
 
Je prend toutes les idées !

Question plus précise.... Bien que les idées générales soient intéressantes....
 
Je souhaite réaliser un jeu sur le thème de WarGames.
J'ai le concept principale : recherche de cible/défense de territoire.
Je dois gérer une partie en selon 5 phases itérative en boucle.
A l'image du DoD of US, je défini 5 niveau d'alertes (Defcon) conduisant à une action particulière.
J'ai déjà défini les 5 niveau comme suit :
Defcon 5 : maintien de la paix
Defcon 4 : detection et création de missiles.
Defcon 3 : detection des cibles ennemies et ciblage des missiles
Defcon 2 : detection de l'armement des missiles ennemis et armement des missiles.
Defcon 1 : tirs des missiles.
 
Avec ça, (j'ai pas plus), je dois élaborer un algorithme d'attaque et de défense.
Une attaque consisterais en une exploration automatique de territoires ennemis.
En Defcon 5, je devrais décider si j'attaque ou pas et passer en Defcon 4 automatiquement.
En Defcon 4, je devrais créer des missiles positionnés stratégiquement et passer en Defcon 3 automatiquement.
En defcon 3, je devrais définir les cibles de mes missiles; soit pour découvrir une zone du territoire, soit pour me défendre, et passer en Defcon 2 automatiquement.
En defcon 2 : je devrais décider de l'armement des missiles et passer en Defcon 1 automatiquement.
En defcon 1 : tirer les missile après une recherche de clef d'annulation ou de validation de procédure. Et repasser en Defcon 5.
Mais c'est pas simple. Enfin, je suis limité.    
Voilà, si vous avez un avis sur la question...
Merci.
 
 

Nan j'ai pas d'avis sur la question.
Je pense que ta barre il faut la mettre à gauche ou flottante.

 
A merci. Je la met en bas finalement. J'aimais bien à gauche, mais je préfère en bas, avec l'info sur Defcon à gauche quand même : http://www.jovalise.net/data/Xborg_2_2012.jpg

Je préfère à gauche, mais c'est peut-etre parce que tes trucs sont vides.
Tu l'as trouvé où le defcon 12345? c'est joli

Dans Wikipedia.

Nan mais le widget avec les boutons en dégradé sur les bords

 
Ben c'est une image que j'ai trouvé dans les liens Wikipedia sur Defcon !

Je m'intéresse en premier lieu aux jeux où il y a autant de chance de gagner en tant qu'attaquant qu'en tant que défendant.
J'ai était tuyauté sur le jeu Pierre-Feuille-Ciseaux : http://fr.wikipedia.org/wiki/Pierre-feuille-ciseaux
Et je suis tombé sur Théorème du minimax de von Neumann : http://fr.wikipedia.org/wiki/Th%C3 [...] on_Neumann
Cependant, malgré l'effort que je fais pour comprendre j'y arraive pas, soit ces trop concis, soit c'est trop long.
 
Voici ce que je voudrais faire : je voudrais décider d'une stratégie parmi 3 (attaque, défense, nulle) selon si je gagne au jeu contre moi même, si je perd ou si il y a partie nulle. est-ce possible ?
Est-ce possible par l'apprentissage par renforcement ou autre (précision à faire) de faire en sorte d'apprendre à jouer une partie nulle grâce à des parties de jeu de pierre feuille ciseaux, ou un autre ?
 
Merci pour vos réponse.

On va aller plus vite, je te file la solution : le gagnant est celui qui ne joue pas  

Oublie pas d'installer une backdoor qui s'ouvre avec le mot de passe "Joshua"  

edit : tiens, un peu de lecture : http://en.wikipedia.org/wiki/Zero%E2%80%93sum_game

Ben nan, si tu joues pas tu peux pas gagner. Enfin, il me semble.

Je peux pas. J'écris pas joshua et je construis pas le Wopr, enfin presque pas.
J'ai déjà implémenté le rappel automatique.    

 
Merci, un comment peut-être ?

Bonjour, je cherche une bibliothèque qui me permettrait d'afficher la carte du monde en point par point en mode console sur Gnu/Linux.
Je doit pouvoir afficher du texte également, enfin, avoir une gestion complète de l'écran.
 
 
Pour avoir les même effet que dans WarGames.
 
Je reprends le projet.  

Pour manipuler un terminal directement tu peux utiliser les séquences d'échappement vt100 ou vt220. Par exemple:

printf("\x1B[H\x1B[1mHello world\x1B[0m\n" );

Pour imprimer "Hello world" en caractère gras.
 
Il y a une tétrachiée de séquences (c.f google "vt100 sequence" ). Tu peux utiliser la lib http://www.gnu.org/s/ncurses pour faire abstraction de tout ce bordel (en général déjà installé sur la plupart des distrib linux).
 
Si tu veux convertir une image bitmap en un truc affichable dans un terminal (anti-aliasing via ASCII-art + séquence vt100), tu peux utiliser:
http://caca.zoy.org/wiki/libcaca
 
(oui, le nom n'est pas un hasard, son auteur, Sam Hocevar, est un habitué de ce genre de jeux de mot pourri, mais cette lib fait plutôt un bon boulot). Si tu veux du vraiment du point par point, va falloir utiliser autre chose qu'un émulateur de terminal vt100/220.
 
Après tu peux toujours faire joujou avec les caractère unicodes du style :
http://en.wikipedia.org/wiki/Box_drawing_characters
http://en.wikipedia.org/wiki/Block_Elements
http://en.wikipedia.org/wiki/Unicode_Geometric_Shapes
 
Pour afficher autre chose que du texte.

Merci tpierron, je regarderais la libcaca, je connais un peu ncurses, j'ai déjà fait des trucs avec?
 
Mon truc ça donne ça pour le moment Mais je crois que j'ai que du texte à afficher sur un terminal.
 

 
 
 
Merci en tout cas pour les liens.

ca y est ? il est fini ? Comment on fait pour jouer dessus ?

Jovalise, c'est comme La Cinq, c'est fini. Il s'est ban à vie vu ses propos lors de son dernier retour il y a quelques jours sur le topic blabla prog.
 
Et puis si tu suis un peu les topics du bonhomme, tu sais qu'il ne termine jamais ses projets mais ça l'empêche pas d'en commencer des nouveaux, toujours plus obscures les uns que les autres

oui mais c'est comme Yoyo Tchikita, caÿ drole

Oh il reviendra bien un jour où l'autre avec un nouveau pseudo

Peut-être mais tu feras quoi vu que t'as dit ban@life ? Parce que son style rédactionnel et les sujets de ses topics sont très caractéristiques. Du coup s'il revient avec un autre pseudo, il va te faire reconnaître direct. Vu la personnalité du bonhomme, c'est pas facile à cacher

C'est surtout le seul du forum qui fait de l'Ada ;-)

Non, y'a eroge aussi
Ca a pas dû être facile d'avoir pour seul interlocuteur Jovalise sur ses topics

On verra quelle sera sa nouvelle personnalité... S'il est aussi agressif et con que ces derniers mois, il repartira. S'il est un peu plus sympa, je ferai un effort

C'est bon Jovalise, tu peux revenir  

Jovalise, le vrai, le pseudo "vanilla" était sympa. Perché mais sympa.
J'ai l'impression que chaque nouveau pseudo a marqué une étape dans sa descente

Je pense avoir connu qu'à partir de Jovalise. Vanilla, ça me dit rien, comme ça.
A chaque changement de pseudo, l'image associée au profil changeait aussi. Si la dernière image, une photo d'un homme, était lui, effectivement, ça a été une sacrée descente. La photo faisait limite peur

Non mais j'utilise le terme vanilla pour désigner le jovalise legacy, le pseudo "jovalise" quoi

Oui après à chaque fork on a baissé en qualité

C'est clair... Jovalise, c'est comme les virus : à chaque nouvelle mutation, il devient plus chiant

QUi sait, peut-être que dans quelques siècles, son travail sera reconnu et passera pour un génie et les gens de cette époques se diront à propos de nous : "mais quelle bande de cons de ne pas avoir compris un génie pareil !..."   .................. Non, je déconne, aucune chance !

Jovalise c'est quand même l'homme le plus proche de passer avec succès le test de Turing, on ne sait plus si on échange avec une machine ou un homme à la fin.  
 
Attendez, ce n'est pas dans ce sens que fonctionne le test ?

Perso, sur la fin, j'en étais à me demander si je causais pas à un programme qui choisissait des mots random dans le dico et les alignait pour tenter de faire des phrases Je le comprenais de moins en moins.