Clients now connect and recieve gamestate information

source/client/client.cpp

@@ -71,10 +71,17 @@ int runClient(int argc, char* argv[])
 
     while ( n >= 0 )
     {
-        // Get the message to send
-        printf("Please enter the message: ");
         memset(buffer,0,sizeof(buffer));
-        fgets(buffer,sizeof(buffer)-1,stdin);
+
+        // Receive gamestate
+        if (read(sockfd,buffer,sizeof(buffer)-1) < 0)
+            error("ERROR reading from client");
+
+        std::cout<<buffer<<std::endl;
+
+        // Output orders
+        memset(buffer,0,sizeof(buffer));
+        strcpy(buffer, "ORDER:F id:1\nEND");
 
         // Place a test message into the buffer
         strncpy(buffer,buffer,sizeof(buffer));

source/client/filesystem.cpp

@@ -79,17 +79,13 @@ std::string getGamesDir()
     return dir;
 }
 
-// =====================================================================================================================
-int runFromFilesystem(int argc, char* argv[])
+CTTRTSGame GetGameFromFile( const std::string& filename )
 {
-    std::string gamefile = argv[1];
+    std::string gamefile = filename;
 
     // Default for maps
     std::string ttrts_maps_dir = getMapsDir();
 
-    // Default for games
-    std::string ttrts_games_dir = getGamesDir();
-
     // If file path is not local path and file doesn't exist
     if( gamefile.find("/") == std::string::npos
             && access( gamefile.c_str(), F_OK ) == -1 )
@@ -101,13 +97,11 @@ int runFromFilesystem(int argc, char* argv[])
     if( access( gamefile.c_str(), F_OK ) == -1 )
     {
         std::cerr<<"Error: "<< gamefile <<" file not found"<<std::endl;
-        return -1;
+        return CTTRTSGame(0,0);
     }
 
     std::ifstream file(gamefile);
 
-    std::cout<<"Launching TTRTS with "<<gamefile<<std::endl;
-
     std::string gameDescriptor;
 
     // Reserve the string needed up front
@@ -121,15 +115,27 @@ int runFromFilesystem(int argc, char* argv[])
     if( gameDescriptor.size() == 0 )
     {
         std::cerr<<"Error: failed to read in any information from "<<gamefile<<std::endl;
-        return -1;
+        return CTTRTSGame(0,0);
     }
 
     // Create the game
-    CTTRTSGame game = GetGameFromString(gameDescriptor);
+    return GetGameFromString(gameDescriptor);
+}
+
+// =====================================================================================================================
+int runFromFilesystem(int argc, char* argv[])
+{
+    std::string gamefile = argv[1];
+
+    std::cout<<"Launching TTRTS with "<<gamefile<<std::endl;
+    CTTRTSGame game = GetGameFromFile(gamefile);
 
     // Grab the players involved
     auto players = game.GetPlayers();
 
+    // Default for games
+    std::string ttrts_games_dir = getGamesDir();
+
     // Current game directory
     std::string gameDir = ttrts_games_dir + game.GetName();
 

source/client/filesystem.h

@@ -15,6 +15,8 @@ void WaitForFile( const std::string& name, const std::chrono::milliseconds& time
 
 bool OutputGameStateFile(CTTRTSGame &game, const std::string &gameDir);
 
+CTTRTSGame GetGameFromFile( const std::string& file );
+
 std::string getMapsDir();
 std::string getGamesDir();
 

source/client/server.cpp

@@ -3,6 +3,7 @@
 #include <thread>
 #include <vector>
 #include <iostream>
+#include <mutex>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,35 +15,35 @@
 
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <game.h>
+#include <formatters.h>
 
 #include "net.h"
+#include "filesystem.h"
 
-std::vector<std::thread> gClientThreads;
-
-int clientHandler( sockaddr_in cli_addr, socklen_t clilen, int clientsockfd)
+// Struct for net client info
+struct ClientInfo
 {
-    std::cout<<"Client connected from "<<inet_ntoa(cli_addr.sin_addr)<<std::endl;
+    sockaddr_in cli_addr;
+    int clientsockfd;
+};
 
-    char buffer[1028]; // buffer for socked read
-    memset(buffer,0,sizeof(buffer));
-
-    // loop
-    int n = 0;			// return value for read and write calls
-    while( n >= 0 )
+int waitForOrdersFromClient(const ClientInfo& info, std::mutex& mut, CTTRTSGame& game )
 {
-        // empty the buffer
+    char buffer[1028]; // buffer for orders
     memset(buffer,0,sizeof(buffer));
 
     // Read in the new socket
     // read will block until the client has called write
     // up to the full size of the buffer
-        n = read(clientsockfd,buffer,sizeof(buffer)-1);
-        if (n < 0)
-            error("ERROR reading from socket");
+    if (read(info.clientsockfd,buffer,sizeof(buffer)-1) < 0)
+        error("ERROR reading from client");
 
-        // print the message recieved
-        printf("%s",buffer);
-    }
+    std::cout<<"Recieved orders from "<<inet_ntoa(info.cli_addr.sin_addr)<<std::endl;
+
+    mut.lock();
+    game.IssueOrders(player_t::Red , buffer);
+    mut.unlock();
 
     return 0;
 }
@@ -98,20 +99,26 @@ int runServer(int argc, char* argv[])
     // max is usually set to 5
     listen(sockfd,5);
 
+    // Set up game
+    CTTRTSGame game = GetGameFromFile("Tiny2Player.txt");
+    unsigned int numClients = game.GetPlayers().size();
+
+    //  game mutex
+    std::mutex gameMutex;
+
+    // Set of clients
+    std::vector<ClientInfo> myClients;
+
     std::cout<<"Waiting for clients"<<std::endl;
 
     // Loop while we're connecting the clients
-    bool connectingClients = true;
-    while ( connectingClients )
+    while ( myClients.size() < numClients )
     {
-
         // information for each client
         sockaddr_in cli_addr;   // Client address
-        socklen_t clilen;		// length of client address
         int clientsockfd; 	    // new socket File descriptor
 
-        clilen = sizeof(sockaddr_in);
-
+        socklen_t clilen = sizeof(sockaddr_in);
 
         // accept waits for a connection from a client
         // it returns a new socket file descriptor for this connection
@@ -120,12 +127,54 @@ int runServer(int argc, char* argv[])
         if (clientsockfd < 0)
             error("ERROR on accept");
 
-        std::cout<<"Client recieved"<<std::endl;
-        std::thread clientThread = std::thread(clientHandler,cli_addr,clilen,clientsockfd);
-
-        gClientThreads.push_back(std::move(clientThread));
+        std::cout<<"Client connected from "<<inet_ntoa(cli_addr.sin_addr)<<std::endl;
+        myClients.push_back({cli_addr,clientsockfd});
     }
 
+    std::cout<<"All clients connected"<<std::endl;
+
+    // Loop for each turn
+    while ( !game.GameOver() )
+    {
+        // Grab the current game state string
+        gameMutex.lock();
+        std::string gamestate_string = GetStringFromGame(game);
+        gameMutex.unlock();
+
+        // Send data to clients
+        std::cout<<"Sending clients gamedata"<<std::endl;
+        for (auto client : myClients)
+        {
+            // Write to the socket with the buffer
+            if ( write( client.clientsockfd, gamestate_string.c_str(), gamestate_string.length() ) < 0 )
+                error("ERROR sending to client");
+        }
+
+        // Wait for orders from clients
+        std::cout<<"Waiting for client orders"<<std::endl;
+
+        std::vector<std::thread> clientThreads;
+        for(auto client : myClients)
+        {
+            std::thread clientThread(waitForOrdersFromClient,std::ref(client), std::ref(gameMutex), std::ref(game));
+            clientThreads.push_back(std::move(clientThread));
+        }
+
+        // Join up all the threads
+        for ( std::thread& thread : clientThreads )
+        {
+            thread.join();
+        }
+
+        // Step to the next turn
+        gameMutex.lock();
+        game.SimulateToNextTurn();
+        gameMutex.unlock();
+    }
+
+
+    // end game and disconnect clients
+
     // Return
     return 0;
 }

source/gen/gen.cpp

@@ -33,7 +33,7 @@ int main()
     //------
     {
         CTTRTSGame game(6, 6);
-        game.SetName("Tiny2player");
+        game.SetName("Tiny2Player");
 
         AddUnitToGame( player_t::Red, '<', uvector2(4, 2), game);
         AddUnitToGame( player_t::Red, '<', uvector2(4, 4), game);