Modified manager program, updated website
authorSam Moore <matches@ucc.asn.au>
Wed, 7 Dec 2011 16:00:04 +0000 (00:00 +0800)
committerSam Moore <matches@ucc.asn.au>
Wed, 7 Dec 2011 16:00:04 +0000 (00:00 +0800)
Major changes: Added simple GUI for human players
Setup phase doesn't use GUI yet (uses a default if -g enabled).
Click in the general region of where you want to select/move pieces.

Modified Board::Draw to allow for showing of already revealed pieces,
but not all pieces. Used to make human player GUI nicer (hides AI pieces).

Modified -t switch to allow for "infinite" stall_time
(wait for user to press enter)

Changed website. Removed protocol description and linked to manual.txt.
Added screenshot to make things slightly more exciting.
Updated manual.txt

Minor changes to simulate.py (output)

TODO:
Fix segmentation fault found in manager program
It occurs just before exit. Memory error in the cleanup process?
ANNOYING!

Still have to bring myself to take the time to finish setting up that vm...
Need to talk to a non-hostile wheel member about security. I don't want my vm to take out our network or something.

Preferably I don't even want the vm to be compromised, regardless of the rest of ucc.
So much I don't know about servers/linux...

Need to stop staying up past midnight...

16 files changed:
manager/controller.cpp
manager/controller.h
manager/game.cpp
manager/game.h
manager/human_controller.cpp
manager/human_controller.h
manager/main.cpp
manager/manual.txt
manager/stratego.cpp
manager/stratego.h
samples/asmodeus/basic_python.pyc
samples/basic_python/basic_python.py
samples/basic_python/basic_python.pyc
simulator/simulate.py
web/index.html
web/screenshot.png [new file with mode: 0644]

index e68c1dc..982f0fc 100644 (file)
@@ -158,9 +158,20 @@ MovementResult Controller::MakeMove(string & buffer)
                
        }
 
-       if (Game::theGame->allowIllegalMoves && !Board::LegalResult(moveResult))
-               return MovementResult::OK; //HACK - Illegal results returned as legal!
-       else
-               return moveResult;      
+       if (!Board::LegalResult(moveResult))
+       {
+               if (Game::theGame->allowIllegalMoves)
+                       return MovementResult::OK; //HACK - Illegal results returned as legal! (Move not made)
+               else if (this->HumanController()) //Cut human controllers some slack and let them try again...
+               {
+                       //Yes, checking type of object is "not the C++ way"
+                       //      But sometimes its bloody useful to know!!!
+                       Message("Bad move: \'" + buffer + "\' <- Please try again!");
+                       buffer = "";
+                       return this->MakeMove(buffer);
+               }
+       }
+
+       return moveResult;      
 
 }
index 24f0c0d..55c233d 100644 (file)
@@ -19,7 +19,7 @@ class Controller
 
                MovementResult MakeMove(std::string & buffer);
 
-
+               virtual bool HumanController() const {return false;} //Hacky... overrides in human_controller... avoids having to use run time type info
 
                void Message(const std::string & buffer) {Message(buffer.c_str());}
                virtual void Message(const char * string) = 0;
index b4fcc62..ce655d7 100644 (file)
@@ -404,14 +404,34 @@ MovementResult Game::Play()
        MovementResult result = MovementResult::OK;
        turnCount = 1;
        string buffer;
+
+       Piece::Colour toReveal = reveal;
+       
+       
        
 
 
        red->Message("START");
-       //logMessage("START\n");
+       
+
+
        while (!Board::HaltResult(result) && (turnCount < maxTurns || maxTurns < 0))
        {
+               if (red->HumanController())
+                       toReveal = Piece::RED;
+               if (printBoard)
+               {
+                       system("clear");
+                       if (turnCount == 0)
+                               fprintf(stdout, "START:\n");
+                       else
+                               fprintf(stdout, "%d BLUE:\n", turnCount);
+                       theBoard.PrintPretty(stdout, toReveal);
+                       fprintf(stdout, "\n\n");
+               }
 
+               if (graphicsEnabled)
+                       theBoard.Draw(toReveal);
                
                turn = Piece::RED;
                logMessage( "%d RED: ", turnCount);
@@ -421,16 +441,25 @@ MovementResult Game::Play()
                logMessage( "%s\n", buffer.c_str());
                if (Board::HaltResult(result))
                        break;
-               if (graphicsEnabled)
-                       theBoard.Draw(reveal);
+
+               if (stallTime > 0)
+                       Wait(stallTime);
+               else
+                       ReadUserCommand();
+
+               if (blue->HumanController())
+                       toReveal = Piece::BLUE;
                if (printBoard)
                {
                        system("clear");
                        fprintf(stdout, "%d RED:\n", turnCount);
-                       theBoard.PrintPretty(stdout, reveal);
+                       theBoard.PrintPretty(stdout, toReveal);
                        fprintf(stdout, "\n\n");
                }
-               Wait(stallTime);
+               if (graphicsEnabled)
+                       theBoard.Draw(toReveal);
+
+               
                
                turn = Piece::BLUE;
                logMessage( "%d BLU: ", turnCount);
@@ -444,18 +473,13 @@ MovementResult Game::Play()
 
                
 
-               if (graphicsEnabled)
-                       theBoard.Draw(reveal);
-               if (printBoard)
-               {
-                       system("clear");
-                       fprintf(stdout, "%d BLUE:\n", turnCount);
-                       theBoard.PrintPretty(stdout, reveal);
-                       fprintf(stdout, "\n\n");
-               }
-
-               Wait(stallTime);
                
+
+               if (stallTime > 0)
+                       Wait(stallTime);
+               else
+                       ReadUserCommand();
+       
                if (theBoard.MobilePieces(Piece::BOTH) == 0)
                        result = MovementResult::DRAW;
 
@@ -493,6 +517,20 @@ int Game::logMessage(const char * format, ...)
        return result;
 }
 
+/**
+ * Waits for a user command
+ * Currently ignores the command.
+ */
+void Game::ReadUserCommand()
+{
+       fprintf(stdout, "Waiting for user to press enter...\n");
+       string command("");
+       for (char c = fgetc(stdin); c != '\n' && (int)(c) != EOF; c = fgetc(stdin))
+       {
+               command += c;
+       }
+}
+
 MovementResult FileController::QuerySetup(const char * opponentName, std::string setup[])
 {
 
@@ -538,3 +576,5 @@ MovementResult FileController::QueryMove(std::string & buffer)
        buffer = string(s);
        return MovementResult::OK;
 }
+
+
index 48926ea..1212b89 100644 (file)
@@ -27,7 +27,7 @@ class Game
                
 
                static void HandleBrokenPipe(int signal);
-               
+               void ReadUserCommand();
                
                const Piece::Colour Turn() const {return turn;}
                void ForceTurn(const Piece::Colour & newTurn) {turn = newTurn;}
@@ -53,7 +53,8 @@ class Game
        private:
                FILE * log;
                
-               Piece::Colour reveal;
+       public:
+               const Piece::Colour reveal;
                int turnCount;
 
                static bool gameCreated;
index 5e3e176..bf43e8d 100644 (file)
@@ -13,23 +13,83 @@ MovementResult Human_Controller::QuerySetup(const char * opponentName, string se
        if (!shownMessage)
        {
                if (graphicsEnabled)
-                       fprintf(stderr, "GUI not yet supported! Please use CLI\n");
-               fprintf(stdout,"Enter %d x %d Setup grid\n", Game::theGame->theBoard.Width(), 4);
-               fprintf(stdout,"Please enter one line at a time, using the following allowed characters:\n");
-               for (Piece::Type rank = Piece::FLAG; rank <= Piece::BOMB; rank = Piece::Type((int)(rank) + 1))
+                       fprintf(stdout, "WARNING: GUI not fully supported. You will be forced to use the default setup.\n");
+               else
                {
-                       fprintf(stdout,"%c x %d\n", Piece::tokens[(int)rank], Piece::maxUnits[(int)rank]);
-               }
-               fprintf(stdout, "You must place at least the Flag (%c). Use '%c' for empty squares.\n", Piece::tokens[(int)Piece::FLAG], Piece::tokens[(int)Piece::NOTHING]);
-               fprintf(stdout, "NOTE: Player RED occupies the top four rows, and BLUE occupies the bottom four rows.\n");
+                       fprintf(stdout,"Enter %d x %d Setup grid\n", Game::theGame->theBoard.Width(), 4);
+                       fprintf(stdout,"Please enter one line at a time.\n");
+                       fprintf(stdout, "You must place at least the Flag (%c). Use '%c' for empty squares.\n", Piece::tokens[(int)Piece::FLAG], Piece::tokens[(int)Piece::NOTHING]);
+               
+                       switch (colour)
+                       {
+                               case Piece::RED:
+                                       fprintf(stdout, "You are RED and occupy the top 4 rows of the board.\n");
+                                       fprintf(stdout, "NOTE: Enter \"DEFAULT\" to use the setup:\n");
+                                       fprintf(stdout, "FB8sB479B8\nBB31555583\n6724898974\n967B669999\n");
+                                       break;
+                               case Piece::BLUE:
+                                       fprintf(stdout, "You are BLUE and occupy the bottom 4 rows of the board.\n");
+                                       fprintf(stdout, "NOTE: Enter \"DEFAULT\" to use the setup:\n");
+                                       fprintf(stdout, "967B669999\n6724898974\nBB31555583\nFB8sB479B8\n");
+                                       break;
+                               default:
+                                       fprintf(stdout, "WARNING: Unknown colour error! Please exit the game.\n");
+                                       break;
+                       }       
+               }       
                
                shownMessage = true;
        }
-               
-       
+
+       if (graphicsEnabled)
+       {
+               switch(colour)
+               {
+                       case Piece::RED:
+                               setup[0] = "FB8sB479B8"; 
+                               setup[1] = "BB31555583";
+                               setup[2] = "6724898974";
+                               setup[3] = "967B669999";
+                               break;
+                       case Piece::BLUE:
+                               setup[0] = "967B669999";
+                               setup[1] = "6724898974";
+                               setup[2] = "BB31555583";
+                               setup[3] = "FB8sB479B8";
+                               break;
+                       default:
+                               assert(false);
+                               break;
+                       }
+               return MovementResult::OK;
+       }
 
        for (int y = 0; y < 4; ++y)
+       {
                cin >> setup[y];
+               if (y == 0 && setup[0] == "DEFAULT")
+               {
+                       switch(colour)
+                       {
+                               case Piece::RED:
+                                       setup[0] = "FB8sB479B8"; 
+                                       setup[1] = "BB31555583";
+                                       setup[2] = "6724898974";
+                                       setup[3] = "967B669999";
+                                       break;
+                               case Piece::BLUE:
+                                       setup[0] = "967B669999";
+                                       setup[1] = "6724898974";
+                                       setup[2] = "BB31555583";
+                                       setup[3] = "FB8sB479B8";
+                                       break;
+                               default:
+                                       assert(false);
+                                       break;
+                       }
+                       break;
+               }
+       }
        assert(cin.get() == '\n');
        
        return MovementResult::OK;
@@ -40,20 +100,78 @@ MovementResult Human_Controller::QueryMove(string & buffer)
        static bool shownMessage = false;
        if (!shownMessage)
        {
-               if (graphicsEnabled)
-                       fprintf(stderr, "GUI not yet supported! Please use the CLI\n");
-               fprintf(stdout, "Please enter your move in the format:\n X Y DIRECTION [MULTIPLIER=1]\n");
-               fprintf(stdout, "Where X and Y indicate the coordinates of the piece to move;\n DIRECTION is one of UP, DOWN, LEFT or RIGHT\n and MULTIPLIER is optional (and only valid for scouts (%c))\n", Piece::tokens[(int)(Piece::SCOUT)]);
+               if (!graphicsEnabled)
+               {
+                       fprintf(stdout, "Please enter your move in the format:\n X Y DIRECTION [MULTIPLIER=1]\n");
+                       fprintf(stdout, "Where X and Y indicate the coordinates of the piece to move;\n DIRECTION is one of UP, DOWN, LEFT or RIGHT\n and MULTIPLIER is optional (and only valid for scouts (%c))\n", Piece::tokens[(int)(Piece::SCOUT)]);
+                       
+               }
                shownMessage = true;
        }
 
        
 
+       if (graphicsEnabled)
+       {
+               fprintf(stdout, "Click to move!\n");
+               SDL_Event event; int mouseClick = 0;
 
-       buffer.clear();
-       for (char in = fgetc(stdin); in != '\n'; in = fgetc(stdin))
+               int x[] = {-1, -1}; int y[] = {-1, -1};
+               while (mouseClick < 2)
+               {
+                       
+                       while (SDL_PollEvent(&event))
+                       {
+                               switch (event.type)
+                               {
+                                       case SDL_QUIT:
+                                               Game::theGame->logMessage("Exit called by human player!\n");
+                                               exit(EXIT_SUCCESS);
+                                               break;
+                                       case SDL_MOUSEBUTTONDOWN:
+                                       switch (event.button.button)
+                                       {
+                                               case SDL_BUTTON_LEFT:
+                                                       SDL_GetMouseState(&x[mouseClick], &y[mouseClick]);
+                                                       x[mouseClick] /= 32; y[mouseClick] /= 32; //Adjust based on graphics grid size
+                                                       if (mouseClick == 0)
+                                                       {
+                                                               stringstream s("");
+                                                               s << x[0] << " " << y[0] << " ";
+                                                               buffer += s.str();
+                                                       }
+                                                       else if (mouseClick == 1)
+                                                       {
+                                                               int xDist = x[1] - x[0];
+                                                               int yDist = y[1] - y[0];
+                                                               if (abs(xDist) > abs(yDist))
+                                                               {
+                                                                       if (xDist < 0)
+                                                                               buffer += "LEFT";
+                                                                       else
+                                                                               buffer += "RIGHT";
+                                                               }
+                                                               else if (yDist < 0)
+                                                                       buffer += "UP";
+                                                               else
+                                                                       buffer += "DOWN";
+                                                       }
+                                                       mouseClick++;
+                                                       break;
+                                       }
+                                       break;
+                               }
+                       }
+               }
+               fprintf(stdout, "Move complete!\n");
+       }
+       else
        {
-               buffer += in;
+               buffer.clear();
+               for (char in = fgetc(stdin); in != '\n'; in = fgetc(stdin))
+               {
+                       buffer += in;
+               }
        }
        
        
index 6d5292e..b2069fc 100644 (file)
@@ -12,9 +12,10 @@ class Human_Controller : public Controller
                Human_Controller(const Piece::Colour & newColour, const bool enableGraphics) : Controller(newColour, "human"), graphicsEnabled(enableGraphics) {}
                virtual ~Human_Controller() {}
 
+               virtual bool HumanController() const {return true;}
                virtual MovementResult QuerySetup(const char * opponentName, std::string setup[]);
                virtual MovementResult QueryMove(std::string & buffer); 
-               virtual void Message(const char * message) {fprintf(stderr, "Recieved message \"%s\" from manager.\n", message);}
+               virtual void Message(const char * message) {fprintf(stderr, "%s\n", message);}
        
        private:
                const bool graphicsEnabled;
index 44f8fd3..1fe32bc 100644 (file)
@@ -75,7 +75,10 @@ Piece::Colour SetupGame(int argc, char ** argv)
                                                fprintf(stderr, "ARGUMENT_ERROR - Expected timeout value after -t switch!\n");
                                                exit(EXIT_FAILURE);
                                        }
-                                       timeout = atof(argv[ii+1]);
+                                       if (strcmp(argv[ii+1], "inf") == 0)
+                                               timeout = -1;
+                                       else
+                                               timeout = atof(argv[ii+1]);
                                        ++ii;
                                        break;
                                case 'g':
index e7a15d1..3237241 100644 (file)
@@ -19,38 +19,48 @@ DESCRIPTION
                If set to "human", stratego will request the user to make moves for the Red player using stdin.
                NOTES
                        1. There is no plan to support AI programs named "human". Deal with it.
-                       2. As of writing, human players must use stdin. A graphical interface may be added later.
+                       2. The graphical interface for human players is... basic. Deal with it.
 
        blue_player
                As red_player, except for controlling the Blue player.
        
 OPTIONS
        -g
-               By default, graphics are disabled. If the -g switch is present, stratego will draw the game as it is played using OpenGL
+               By default, graphics are disabled. If the -g switch is present, stratego will draw the game as it is played using SDL/OpenGL
+               
        -p
                By default, even if graphics are disabled, the board state is not printed. If -p is present, the board will be printed to stdout.
                If the system supports colour, the characters will be in colour.
-               If -p and -g are both present you will see both behaviours (overkill)!
+               Yes, If -p and -g are both present you will see both behaviours (overkill)!
        -i
                By default, stratego will exit if a move which is deemed "illegal" is made. If the -i switch is present, illegal moves will be ignored.
                That is, the move will not be made (effectively the player making the illegal move loses a turn).
+
+               NOTE: If -i is not given and a human player accidentally(?) makes an illegal move, they will be asked to make a different move. The game will continue.
+               This is intended to prevent fits of rage due to the horrible graphical interface causing humans to make illegal moves.
        -r
                By default, the identities of all pieces are shown. If the -r switch is present, and graphics are enabled, red pieces will be disguised.
                If graphics are disabled, the -r switch has no effect.
+
+               Pieces which have previously taken part in combat (and survived) will be revealed.
        -b
                As -r, except blue pieces will be disguised.
-               NOTE: Both -r and -b may be used.
+               NOTE: Both -r and -b may be used together.
        -o
-               By default, stratego is silent. If the -o switch is present, the result of each move is printed to a file. If output_file is "stdout"
-               then stdout will be used instead of a text file.
+               By default, stratego does not log moves. If the -o switch is present, the result of each move is printed to a file. 
+               If output_file is "stdout" then stdout will be used instead of a text file.
        -t
                By default, stratego executes moves as fast as they are recieved. If the -t switch is present, a delay of stall_time will be introduced
                between each move.
-
+               
+               If stall_time is negative or "inf", stratego will wait for the user to press enter before moving to the next move.
+               
+               It is tentatively planned to allow the user to enter various commands to alter the game or proceed to specified turns.
+               However this is slightly complicated. So it might never be done.
        -m
                By default, the game is declared a Draw after 5000 turns have ellapsed.
                Use this option to change the maximum number of turns.
-               To play for an infinite number of turns, supply "inf" as max_number.
+               To play for an infinite number of turns, supply "inf" as max_number. This is not recommended for obvious reasons.
 
        -f
                By default, stratego requires red_player and blue_player to enact a game.
@@ -107,6 +117,10 @@ PROTOCOL
 
                RESPONSE: 4 lines, each of length BOARD_WIDTH, of characters. Each character represents a piece. The characters are shown above.
 
+               RED's pieces are placed at the top of the board, and BLUE's pieces are placed at the bottom.
+
+               An AI program does not have to place all 40 pieces, but must at least place the flag ('F').
+
        2. TURN
                QUERY:  START | CONFIRMATION
                        BOARD_STATE
@@ -127,23 +141,25 @@ PROTOCOL
                        The AI program should print "NO_MOVE" if it is unable to determine a move.
                        This will typically occur when the only pieces belonging to the AI program are Bombs and the Flag.
 
-               CONFIRMATION: X Y DIRECTION [MULTIPLIER=1] OUTCOME | NO_MOVE | QUIT RESULT
+               CONFIRMATION: X Y DIRECTION [MULTIPLIER=1] OUTCOME | NO_MOVE {OK | ILLEGAL} | QUIT [RESULT]
+
                        OUTCOME may be either OK, ILLEGAL, KILLS or DIES
                                OK - Move was successful
                                ILLEGAL - Move was not allowed. If stratego was not started with the -i switch, the game will end.
                                KILLS ATTACKER_RANK DEFENDER_RANK - The piece moved into an occupied square and killed the defender.
                                DIES ATTACKER_RANK DEFENDER_RANK - The piece moved into an occupied square and was killed by the defender.
 
-                       A confirmation of "NO_MOVE" occurs when the AI program made no move for a legitimate reason.
+                       Most turns will be confirmed with: "X Y DIRECTION [MULTIPLIER=1] OUTCOME"
+
+                       A confirmation of "NO_MOVE OK" occurs when the AI program made no move for a legitimate reason.
                        "NO_MOVE ILLEGAL" is printed if the AI program made no move for an illegitimate reason.
 
                        If both AI programs successively make a "NO_MOVE" response, then the game will end.
                        The player with the highest piece value will win, or a draw will be declared if the values are equal.
 
-
        3. END GAME
                If the CONFIRMATION line is of the form:
-                       QUIT RESULT
+                       QUIT [RESULT]
                Then the game is about to end.
        
                If present, RESULT will be a direct copy of the message to stdout described in the EXIT/OUTPUT section below.
@@ -190,7 +206,11 @@ EXIT/OUTPUT
        
 
 BUGS
-       There are no known bugs at this time. However, stratego is still a work in progress. Report a bug to the AUTHOR (see below).
+       WARNING:
+       stratego has been observed to segfault occassionally after the end of a game. It is not yet known what is causing these errors.
+       They appear to occur most often when the result is a draw, however they have been observed to occur under all exit conditions except the Illegal case. The result is still printed to stdout. However this bug _must_ be fixed before stratego can be used by simulation scripts.       
+
+       stratego is still a work in progress. Report another bug to the AUTHOR (see below).
 
 AUTHORS
        Sam Moore (for the UCC Programming Competition 2012) <matches@ucc.asn.au>
index ed38e35..f2df0ff 100644 (file)
@@ -202,7 +202,7 @@ void Board::PrintPretty(FILE * stream, const Piece::Colour & reveal)
  * Draw the board state to graphics
  * @param reveal - Pieces matching this colour will be revealed. All others will be shown as blank coloured squares.
  */
-void Board::Draw(const Piece::Colour & reveal)
+void Board::Draw(const Piece::Colour & reveal, bool showRevealed)
 {
        if (!Graphics::Initialised())
        {
@@ -223,7 +223,8 @@ void Board::Draw(const Piece::Colour & reveal)
                                //Don't display anything
 
                        }
-                       else if (piece->colour != Piece::NONE && (piece->colour == reveal || reveal == Piece::BOTH))
+                       else if ((piece->colour != Piece::NONE && (piece->colour == reveal || reveal == Piece::BOTH))
+                                       || (piece->beenRevealed && showRevealed))
                        {
                                //Display the piece
                                Piece::textures[(int)(piece->type)].DrawColour(x*32,y*32,0,1, Piece::GetGraphicsColour(piece->colour));
@@ -360,6 +361,9 @@ MovementResult Board::MovePiece(int x, int y, const Direction & direction, int m
        }
        else if (defender->colour != target->colour)
        {
+               defender->beenRevealed = true;
+               target->beenRevealed = true;
+
                Piece::Type defenderType = defender->type;
                Piece::Type attackerType = target->type;
 
index 929f870..fe73aa1 100644 (file)
@@ -108,7 +108,7 @@ class Board
                void Print(FILE * stream, const Piece::Colour & reveal=Piece::BOTH); //Print board
                void PrintPretty(FILE * stream, const Piece::Colour & reveal=Piece::BOTH); //Print board using colour
                
-               void Draw(const Piece::Colour & reveal=Piece::BOTH); //Draw board
+               void Draw(const Piece::Colour & reveal=Piece::BOTH, bool showRevealed = true); //Draw board
                
 
                bool AddPiece(int x, int y, const Piece::Type & newType, const Piece::Colour & newColour); //Add piece to board
index bca3a0a..cfd6565 100644 (file)
Binary files a/samples/asmodeus/basic_python.pyc and b/samples/asmodeus/basic_python.pyc differ
index be88d56..cf024e8 100644 (file)
@@ -87,6 +87,8 @@ class BasicAI:
                """ Implements Setup part of protocol. Always uses the same setup. Override to create custom setups """
                #sys.stderr.write("BasicAI Setup here...\n");
                setup = sys.stdin.readline().split(' ')
+               if len(setup) != 4:
+                       sys.stderr.write("BasicAI setup fails, expected 4 tokens, got " + str(len(setup)) + " "+str(setup) + "\n")
                self.colour = setup[0]
                self.opponentName = setup[1]
                self.width = int(setup[2])
index 4c201ef..06aca7f 100644 (file)
Binary files a/samples/basic_python/basic_python.pyc and b/samples/basic_python/basic_python.pyc differ
index 60320d9..32f2b42 100755 (executable)
@@ -84,7 +84,7 @@ if len(agents) == 0:
 if verbose:
        print "Total: " + str(len(agents)) + " valid agents found (From "+str(len(agentNames))+" possibilities)"
        print ""
-       print "Commencing ROUND " + str(roundNumber) + " combat! ("+str(nGames)+" games per pairing)"
+       print "Commencing ROUND " + str(roundNumber) + " combat! This could take a while... ("+str(nGames)+" games per pairing * " + str(len(agents) * len(agents)-1) + " pairings = " + str((len(agents) * len(agents)-1) * nGames) + " games)"
 
 
 normalGames = 0
index c5205d6..d181a14 100644 (file)
 <body>
 
 <h1> Quick Details</h1>
+<h2> git </h2>
 <p> The git repository is listed on <a href="http://git.ucc.asn.au/"/>The UCC git page</a> as "progcomp2012.git" </p>
+<p> <a href="http://git.ucc.asn.au/?p=progcomp2012.git;a=summary"/>Direct Link Here</a></p>
+
+<h2> Mailing List </h2>
 <p> We will use the same mailing list as last year (progcomp). </p>
-<p> </p>
-<p> There is a #progcomp irc channel on the ucc irc server where you can ask questions or help with setting things up. </p>
+
+<h2> irc channel </h2>
+<p> There is a #progcomp irc channel on the ucc irc server (irc.ucc.asn.au) where you can ask questions or help with setting things up. </p>
+
+<h2> Programming Competition VM </h2>
+<p> I am in the process of learning how to set up a VM for this competition. Please be patient. </p>
 
 <h1> Stratego </h1>
 <p> <a href="http://www.edcollins.com/stratego/"/>This site</a> explains what Stratego is. </p>
-<p> I have never played this game. But it sounds cool. So naturally I decided to make a competition based on it. </p>
-<p> My original idea was to force people to write AI for <a href="http://matches.ucc.asn.au/Astral"/>Astral</a>, but then I realised that that was a terrible idea. </p>
 
-<p> There is in fact, already a <a href="http://www.strategousa.org/wiki/index.php/2010_Computer_Stratego_World_Championship"/>World Stratego Championship</a>. However, you have to use Metaforge. Using stdin/stdout will probably make it slightly easier for us. And its better to work out how to do these things ourselves. </p>
+<p> Short Version: It is a board game in which all pieces have a value that is, initially, unknown to the opponent player. The objective is to destroy all enemy pieces, or capture the enemy "Flag". Pieces with higher values destroy pieces with lower values. There are several special pieces/rules. </p>
+
 
-<h2> Programming Competition </h2>
+<h1> Programming Competition </h1>
 <p> Create an AI to play Stratego. </p>
-<p> Yes, I <i> know </i> people are inherently lazy and won't be bothered to do this. But so far in setting this up I have learn quite a lot about inter-process communication, so thats good. </p>
 <p> Programs are written independently and interface through stdin/stdout with a manager program, which queries them on setup and moves. </p>
+
 <h3> The Manager Program </h3>
-<p> The manager program takes two executable paths, one to each of the AI programs to pit against each other. <p>
-<p> It first requests each program to print the setup of its pieces to stdout. Then the programs take turns (Red, then blue, etc) to move one piece. </p>
-<p> The first program is Red (top of the board), the second is Blue (bottom of the board). </p>
-<p> The manager program now has switches to enable/disable graphics and set the move speed of the match. </p>
-<p> Use "-g" to enable graphics (by default disabled) and "-t TIMEOUT" to set the move speed (default 0 (as fast as possible)). </p>
-<p> <b> This program now has a <a href="http://matches.ucc.asn.au/progcomp2012/manager/manual.txt"/>manual page</a> </b> </p>
-
-<h2> Messaging Protocol and Rules </h2>
-<p> <b> The rules are now also available in the <a href="http://matches.ucc.asn.au/progcomp2012/manager/manual.txt"/>manual page</a> of the manager program </b> </p>
-<h3> Setup </h3>
-<h4> Query </h4>
-<p> The manager program prints one line in the following format to each program: </p>
-<p>    COLOUR OPPONENT BOARD_WIDTH BOARD_HEIGHT </p>
-<p> At the moment BOARD_WIDTH and BOARD_HEIGHT are always 14. The arguments are followed by a newline. </p>
-<p> OPPONENT will be the identity of the opposing AI program. </p>
-<h4> Response </h4>
-<p> The AI program queried must print <i>four</i> (4) lines containing its initial setup. Each character represents a unit or empty space. The characters are as follows: </p>
+<p> The manager program provides the protocol for two seperate AI to play a game of stratego. It has the imaginative name of 'stratego', but I will probably refer to it as 'the manager program' or 'stratego' with absolutely no consistency. </p>
+<p> It also aims to assist with AI design by providing options for graphical or terminal output and saving/reading games from files </p>
 <p> </p>
-
-<p><b>Warning:</b> I have changed the characters from mostly letters to mostly digits, indicating the actual worth of a piece</p>
-<table border="1">
-<tr> <th>Name</th> <th>Character</th>  <th> Number </th> <th> Notes </th> </tr>
-<tr> <td>Marshal</td> <td>1</td>  <td>1</td> <td> Dies if attacked by the Spy </td> </tr>
-<tr> <td>General</td> <td>2</td>  <td>1</td> <td> </td> </tr>
-<tr> <td>Colonel</td> <td>3</td>  <td>2</td> <td> </td> </tr>
-<tr> <td>Major</td> <td>4</td> <td>3</td> <td> </td> </tr>
-<tr> <td>Captain</td> <td>5</td> <td>4</td> <td> </td> </tr>
-<tr> <td>Lietenant</td> <td>6</td> <td>4</td> <td> </td> </tr>
-<tr> <td>Sergeant</td> <td>7</td> <td>4</td> <td> </td> </tr>
-<tr> <td>Miner</td> <td>8</td> <td>5</td> <td> Defuses Bombs and survives. </td> </tr>
-<tr> <td>Scout</td> <td>9</td> <td>8</td> <td> May move any number of times in a single direction. </td> </tr>
-<tr> <td>Spy </td> <td>s</td> <td>1</td> <td> If the Spy attacks the Marshal, the Marshal is destroyed. </td> </tr>
-<tr> <td>Bomb</td> <td>B</td> <td>6</td> <td> Immobile. Destroys both self and any unit that attacks the Bomb. </td> </tr>
-<tr> <td>Flag</td> <td>F</td> <td>1</td> <td> Immobile. Capture the opponent's flag to win. </td> </tr>
-<tr> <td>Unoccupied</td> <td>.</td> <td> </td> </tr> 
-<tr> <td>Obstacle</td> <td>*</td> <td> </td> </tr>
+<p> Human players are also supported, although the interface is minimal, as this feature is meant for testing. </p>
+<p> If you just want to play a game, without having to write your own AI, try <a href="http://www.probe.imersatz.com/"/>Probe</a> </p>
+
+<h4> Screenshot </h4>
+<img border="0" src="screenshot.png" alt="Graphical output of 'stratego' manager program." title="Graphical output of 'stratego' manager program. Options '-g' for graphics and '-b' to hide Blue pieces that have not taken part in combat yet. Red and Blue are both linked to the 'asmodeus' AI. Taken with scrot on 7/12/11." width="327" height="344" />
+
+<h3> Protocol </h3>
+<p> For the sake of simplicity and keeping things in one place, the protocol is now entirely described in the <a href="http://matches.ucc.asn.au/progcomp2012/manager/manual.txt"/>manual page</a> of the manager program. All updates to the protocol will be reflected in that file. </p>
+
+
+<p> <b> Warning:</b> The accuracy of the above file depends on how recently I pulled it from git. To ensure you get the latest version, find it under "manager/manual.txt" in the <a href="http://git.ucc.asn.au/?p=progcomp2012.git;a=summary"/>git repository</a> </p>
+
+<h2> Long Term Scoring </h2>
+<p> <b> WARNING: Work in progress </b> </p>
+<p> It is currently planned to store all the AIs on a virtual machine, and periodically run a script to play a round robin </p>
+<p> The scores for each round and the total scores will be recorded from the start to the end of the competition. </p>
+<p> The competition will run over a period of weeks (depending on general enthusiasm...), and competitors will be able to alter their programs except during the periods in which the script is running. </p>
+<p> The following categories will be used when determining the final winners:</p>
+<p> <ol>
+       <li> Total score</li>
+       <li> Number of rounds won</li>
+       </ol> </p>
+
+<h2> Sample AI Programs </h2>
+<p> <b> WARNING: Work in progress </b> </p>
+<p> The following sample programs are currently available (and in a working state - refer to the git repository): </p>
+<table border="0">
+<tr> <th>Name</th> <th>Language</th> <th> Moves </th> <th> Considers... </th> </tr>
+<tr> <td>basic_python</td> <td>Python</td> <td>Randomised</td> </tr>
+<tr> <td>basic_cpp</td> <td>C++</td> <td>Randomised</td> </tr>
+<tr> <td>asmodeus</td> <td>Python</td> <td>Scored</td> <td>Path finding, known combat results, piece values</td> </th> 
 </table> 
-<p> The AI program can't place any obstacles, and must at least place the Flag for its setup to be valid. </p>
-<p> RED will always occupy the top four rows of the board, and BLUE occupies the bottom four rows. </p>
-
-<p> All pieces except the Scout, Bomb and Flag can move 1 square horizontally or vertically (not diagonally). </p>
-<p> When two pieces of different ranks encounter each other, the piece with the highest rank (lowest numbered rank!) is the victor, unless a special rule applies. </p>
-<p> When two pieces of <i>equal</i> rank encounter each other, the victor is randomly chosen </p>
-<p> Pieces of the same colour may <i>not</i> pass through the same squares </p>
-
-<h3> Turns </h3>
-<h4> Query </h4>
-<p> RED starts the game. The manager queries RED to make the <i>first</i> move by printing: </p>
-<p>    START </p>
-<p> Followed by a WIDTH*HEIGHT grid. '*' or '#' characters are used to indicate positions of unknown (BLUE/RED) enemy units. </p>
-
-<h4> Response </h4>
-<p> The AI program must respond with a <i> single </i> line of the following form: </p>
-<p>    X Y DIRECTION [MULTIPLIER]</p>
-<p> Where X and Y represent valid co-ordinates, upon which there is a piece of the AI program's colour. </p>
-<p> DIRECTION must be either "UP", "DOWN", "LEFT", or "RIGHT", and is, obviously, the way the piece is supposed to move </p>
-<p> MULTIPLIER is optional, and should only be given if the AI program is moving a Scout. Scouts may move multiple times in the same direction if possible. </p>
-<p> </p>
-
-<h4> Outcome </h4>
-<p> The manager program will indicate the result of a move by responding with: </p>
-<p>    X Y DIRECTION [MULTIPLIER] OUTCOME </p>
-<p> Where X, Y, DIRECTION and MULTIPLIER are as above. </p>
-<p> OUTCOME signals the result of the turn, and will be one of the following: </p>
-<table border="1">
-       <tr> <th> OUTCOME </th> <th> Description </th>  </tr>
-       <tr> <td> OK </td> <td> The piece was successfully moved, nothing eventful happened </td> </tr>
-       <tr> <td> FLAG </td> <td> The piece moved onto the opposing Flag; the game will end shortly </td> </tr>
-       <tr> <td> KILLS RANK1 RANK2 </td> <td> The piece landed on a square occupied by an enemy, and destroyed it, moving into the square </td> </tr>
-       <tr> <td> DIES RANK1 RANK2</td> <td> The piece landed on a square occupied by an enemy, and was destroyed. The piece is removed from the board. </td> </tr>
-       <tr> <td> BOTHDIE RANK1 RANK2</td> <td> The piece landed on a square occupied by an enemy, and <i>both</i> pieces were destroyed. </td> </tr>
-       <tr> <td> ILLEGAL </td> <td> The moving player attempted to make an illegal move, and has hence lost the game. The game will end shortly. </td> </tr>
-</table>
-<p> If printed, RANK1 and RANK2 indicate the ranks of the moved piece and the defending piece (the piece who occupied the destination square) respectively. </p>
-<p> Originally RANK1 and RANK2 were never printed, but when I actually tried to write an AI myself I got very annoyed at this restriction... indicating it was probably a bad idea :P </p>
-               
-
-<h4> Additional Turns </h4>
-<p> The Outcome of each turn is printed to <i>both</i> AI programs. </p>
-<p> The state of the board is then printed to BLUE, who makes a move, then the process repeats. </p>
+<p> It is planned to implement the equivelants of these samples in C++ and Python at least, possibly other languages later. </p>
 
-<p> </p>
-
-<h4> Overview </h4>
-<p> This is a description of the signals the AI programs recieve, in order:
-<ol>
-       <li> Previous turn's outcome (other player's move) OR "START" if it is the first turn </li>
-       <li> A BOARD_WIDTH*BOARD_HEIGHT grid indicating the board state, with the AI program's own pieces revealed </li>
-       <li> After the AI program makes a move, the outcome is printed to it, and the other program, which continues from step 1 </li>
-</ol>
-<p> I am considering removing Step 2, since <i>all</i> information needed for an AI to keep the board state is contained in the initial board state and then the movement result messages </p>
-
-<h3> End Game </h3>
-<h4> Query </h4>
-<p> At the end of the game, the manager program outputs the following: </p>
-<p>    VICTORY </p>
-<p> To the winning AI program, and </p>
-<p>    DEFEAT </p>
-<p> To the losing program. </p>
-<p> Both programs then have 2 seconds to exit succesfully, or the manager will kill them. </p>
-<h3> Invalid Responses and Timeouts </h3>
-<p> If any program fails to respond correctly, or gives an invalid move, or does not respond within 1 second, it will lose by default. </p>
-<p> In this case, the message </p>
-<p>    ILLEGAL </p>
-<p> will be sent to the malfunctioning program, and </p>
-<p>    DEFAULT </p>
-<p> to the other program </p>
-<p> Both programs then have 2 seconds to exit succesfully, or the manager will kill them. </p>
-
-<h2> Modifications/Clarifications to Rules </h2>
-<p> Refer to <a href="http://www.edcollins.com/stratego/"/>This site</a> for the original rules again </p>
-<p> Currently, the pieces taking part in the combat are not revealed; only the outcome of the combat is revealed. In a human game, the pieces would normally be revealed. I am planning to reveal the pieces, since not revealing pieces significantly reduces the value of low ranked pieces (normally used for working out enemy piece values). </p>
-<p> It is up to the AI program to keep track of pieces. The manager program will only reveal the identity of the AI program's own pieces; the other player's pieces will be marked with * or # characters. </p>
-<p> In a traditional game, two pieces of equal value will both be destroyed in combat. Currently, only one piece is destroyed and the outcome is randomly chosen. </p>
-
-<h2> Example Programs </h2>
-<h3>"Dummy" AI</h3>
-<p> Dummy randomly moves pieces. It attempts to not make illegal moves (although sometimes it still does). </p>
-<h3>"Forfax" AI</h3>
-<p> Forfax iterates through all possible moves and allocates a score between 0 and 1 to each move based on how desirable the move is. It then selects the highest scoring move. </p>
-<p> Forfax is pretty terrible, but can beat the Dummy AI <i>most</i> of the time. </p>
-<p> It is possible Forfax can be greatly improved by altering the scoring algorithms. </p>
-<p> Since we don't want the Sample AIs to beat every entrance, I'm not really going to try and improve Forfax unless I get bored. </p>
-<p> If you are writing an AI in C++, Forfax already contains a lot of useful functions. </p>
-
-<h2> Longterm Scoring </h2>
-<p> I haven't started a system for pairing AI's and keeping track of scores and winners etc yet </p>
-<p> I'll probably have a bash script that chooses who will play, and stores all the scores in files. I've done this before for a BrainF*** based "survival of the fittest" style thing, so I can probably recycle it </p>
-<p> </p>
-<p> I believe it will make things more interesting if programs are allowed to keep state of who they have played, and the various tactics used. </p>
-<p> Its kind of hard to implement this... at the moment programs are killed every time a game finishes</p>
-<p> Perhaps it will be easier if each program is allowed access to one directory, where it can create and read files? </p>
-<p> This would allow me to keep the manager program which actually plays the games seperate from the program for scoring and matching of opponents </p>
-<p> There'd probably be security issues with that though. </p>
+<p> <b>Last webpage update: 7/12/11</b></p>
 </body>
 
 </html>
diff --git a/web/screenshot.png b/web/screenshot.png
new file mode 100644 (file)
index 0000000..276d892
Binary files /dev/null and b/web/screenshot.png differ

UCC git Repository :: git.ucc.asn.au