Multiplayer framework in place (can now connect multiple clients and view them in game)

Fixed some bugs with multiplayer
Changed from refptr<map<U8, Player> > to map<U8, refptr<player> >

src/client/Client-gl.cc

@@ -1,4 +1,3 @@
-
 #include <math.h>
 #include <iostream>
 #include GL_INCLUDE_FILE
@@ -216,16 +215,21 @@ void Client::redraw()
 {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    double dir_x = cos(m_player->direction);
-    double dir_y = sin(m_player->direction);
+    double dir_x = cos(m_players[current_player]->direction);
+    double dir_y = sin(m_players[current_player]->direction);
     m_modelview.load_identity();
     m_modelview.look_at(
-            m_player->x - dir_x * 25, m_player->y - dir_y * 25, 30,
-            m_player->x, m_player->y, 20,
+            m_players[current_player]->x - dir_x * 25, m_players[current_player]->y - dir_y * 25, 30,
+            m_players[current_player]->x, m_players[current_player]->y, 20,
             0, 0, 1);
 
     // TODO: call draw_player() for each networked player
-    draw_player(m_player);
+    for(std::map<sf::Uint8, refptr<Player> >::iterator piter = m_players.begin(); piter != m_players.end(); piter++)
+    {
+        draw_player(piter->second);
+    }
+
+
     draw_map();
     draw_sky();
     draw_lava();
@@ -357,8 +361,8 @@ void Client::draw_overlay()
     proj.ortho(-span, span, -span, span, -1, 1);
     proj.to_uniform(m_overlay_program.uniform("projection"));
     GLMatrix modelview;
-    modelview.rotate(90 - m_player->direction * 180 / M_PI, 0, 0, 1);
-    modelview.translate(-m_player->x, -m_player->y, 0);
+    modelview.rotate(90 - m_players[current_player]->direction * 180 / M_PI, 0, 0, 1);
+    modelview.translate(-m_players[current_player]->x, -m_players[current_player]->y, 0);
     m_overlay_hex_attributes.bind();
     m_overlay_hex_indices.bind();
     glEnableVertexAttribArray(0);
@@ -409,8 +413,8 @@ void Client::draw_overlay()
     GLMatrix::Identity.to_uniform(
             m_overlay_hover_program.uniform("projection"));
     modelview.load_identity();
-    modelview.translate(m_player->hover - 1, 0, 0);
-    modelview.scale(m_player->hover * 2, 2.0, 1.0);
+    modelview.translate(m_players[current_player]->hover - 1, 0, 0);
+    modelview.scale(m_players[current_player]->hover * 2, 2.0, 1.0);
     modelview.to_uniform(m_overlay_hover_program.uniform("modelview"));
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
@@ -450,8 +454,8 @@ void Client::draw_sky()
     m_sky_attributes.bind();
     m_projection.to_uniform(m_sky_program.uniform("projection"));
     m_modelview.push();
-    m_modelview.translate(m_player->x, m_player->y, 0);
-    m_modelview.rotate(m_player->direction * 180.0 / M_PI, 0, 0, 1);
+    m_modelview.translate(m_players[current_player]->x, m_players[current_player]->y, 0);
+    m_modelview.rotate(m_players[current_player]->direction * 180.0 / M_PI, 0, 0, 1);
     m_modelview.to_uniform(m_sky_program.uniform("modelview"));
     m_modelview.pop();
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,

src/client/Client.cc

@@ -1,12 +1,15 @@
 #include <math.h>
 #include "Client.h"
 #include "Types.h"
+#include "Timer.h"
 
 Client::Client()
 {
     m_net_client = new Network();
     m_net_client->Create(59243, "127.0.0.1"); // Just connect to local host for now - testing
     client_has_focus = true;
+    m_players.clear();
+    current_player = 0;
 }
 
 Client::~Client()
@@ -15,16 +18,16 @@ Client::~Client()
 }
 
 
-void Client::run(bool fullscreen, int width, int height)
+void Client::run(bool fullscreen, int width, int height, std::string pname)
 {
+    Timer client_timer;
+    client_timer.Init();
+    current_player_name = pname;
     if (!create_window(fullscreen, width, height))
         return;
-    m_player = new Player();
-    m_player->x = 0;
-    m_player->y = 0;
-    m_player->direction = M_PI_2;
     m_clock.restart();
     sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
+
     double last_time = 0.0;
     while (m_window->isOpen())
     {
@@ -63,8 +66,16 @@ void Client::run(bool fullscreen, int width, int height)
             }
         }
 
+        // Time must be updated before any messages are sent
+        // Especially guaranteed messages, since the time needs to be
+        // non zero.
+        client_timer.Update();
+
         update(elapsed_time);
-        redraw();
+        if(m_players.size() > 0)
+        {
+            redraw();
+        }
         last_time = current_time;
 
         // temporary for now.  otherwise this thread consumed way too processing
@@ -74,81 +85,150 @@ void Client::run(bool fullscreen, int width, int height)
 
 void Client::update(double elapsed_time)
 {
-    static sf::Uint8 w_pressed_prev = KEY_NOT_PRESSED;
-    static sf::Uint8 a_pressed_prev = KEY_NOT_PRESSED;
-    static sf::Uint8 s_pressed_prev = KEY_NOT_PRESSED;
-    static sf::Uint8 d_pressed_prev = KEY_NOT_PRESSED;
-    static sf::Int32 rel_mouse_movement_prev = 0;
-
+    static bool registered_player = false;
     sf::Packet client_packet;
 
+
     m_net_client->Receive();
     client_packet.clear();
     // Handle all received data (only really want the latest)
     while(m_net_client->getData(client_packet))
     {
-        // Update player position as calculated from the server.
-        client_packet >> m_player->direction;
-        client_packet >> m_player->x;
-        client_packet >> m_player->y;
+        sf::Uint8 packet_type;
+        client_packet >> packet_type;
+        switch(packet_type)
+        {
+            case PLAYER_CONNECT:
+            {
+                sf::Uint8 pindex;
+                std::string name = "";
+                client_packet >> pindex;
+                client_packet >> name;
+                // Should be a much better way of doing this.
+                // Perhaps generate a random number
+                if(name == current_player_name)
+                {
+                    current_player = pindex;
+                }
+
+                // Create a new player if one does not exist.
+                if(m_players.end() == m_players.find(pindex))
+                {
+                    refptr<Player> p = new Player();
+                    p->name = name;
+                    client_packet >> p->direction;
+                    client_packet >> p->x;
+                    client_packet >> p->y;
+                    m_players[pindex] = p;
+                }
+                break;
+            }
+            case PLAYER_UPDATE:
+            {
+                sf::Uint8 player_index;
+                // Update player position as calculated from the server.
+                client_packet >> player_index;
+                if(m_players.end() != m_players.find(player_index))
+                {
+                    client_packet >> m_players[player_index]->direction;
+                    client_packet >> m_players[player_index]->x;
+                    client_packet >> m_players[player_index]->y;
+                }
+                break;
+            }
+            case PLAYER_DISCONNECT:
+            {
+                // This will remove the player once the disconnect algorithm is implemented
+                break;
+            }
+            case PLAYER_DEATH:
+            {
+                // This will set a death flag in the player struct.
+                break;
+            }
+            default :
+            {
+                // Eat the packet
+                break;
+            }
+        }
     }
 
     // For now, we are going to do a very crude shove data into
     // packet from keyboard and mouse events.
     // TODO:  Clean this up and make it more robust
-    client_packet.clear();
-
-    sf::Uint8 w_pressed = KEY_NOT_PRESSED;
-    sf::Uint8 a_pressed = KEY_NOT_PRESSED;
-    sf::Uint8 s_pressed = KEY_NOT_PRESSED;
-    sf::Uint8 d_pressed = KEY_NOT_PRESSED;
-    sf::Int32 rel_mouse_movement = 0;
-
-    // This is a fix so that the mouse will not move outside the window and
-    // cause the user to click on another program.
-    // Note:  Does not work well with fast movement.
-    if(client_has_focus)
+    if(m_players.size() > 0)
     {
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
+        sf::Uint8 w_pressed = KEY_NOT_PRESSED;
+        sf::Uint8 a_pressed = KEY_NOT_PRESSED;
+        sf::Uint8 s_pressed = KEY_NOT_PRESSED;
+        sf::Uint8 d_pressed = KEY_NOT_PRESSED;
+        sf::Int32 rel_mouse_movement = 0;
+
+        // This is a fix so that the mouse will not move outside the window and
+        // cause the user to click on another program.
+        // Note:  Does not work well with fast movement.
+        if(client_has_focus)
         {
-            a_pressed = KEY_PRESSED;
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
+            {
+                a_pressed = KEY_PRESSED;
+            }
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
+            {
+                d_pressed = KEY_PRESSED;
+            }
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
+            {
+                w_pressed = KEY_PRESSED;
+            }
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
+            {
+                s_pressed = KEY_PRESSED;
+            }
+            rel_mouse_movement = sf::Mouse::getPosition(*m_window).x - m_width / 2;
+            sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
+
+        // Send an update to the server if something has changed
+        if((m_players[current_player]->w_pressed != w_pressed) ||
+           (m_players[current_player]->a_pressed != a_pressed) ||
+           (m_players[current_player]->s_pressed != s_pressed) ||
+           (m_players[current_player]->d_pressed != d_pressed) ||
+           (m_players[current_player]->rel_mouse_movement !=  rel_mouse_movement))
         {
-            d_pressed = KEY_PRESSED;
+            sf::Uint8 packet_type = PLAYER_UPDATE;
+            client_packet.clear();
+            client_packet << packet_type;
+            client_packet << current_player;
+            client_packet << w_pressed;
+            client_packet << a_pressed;
+            client_packet << s_pressed;
+            client_packet << d_pressed;
+            client_packet << rel_mouse_movement;
+
+            m_net_client->sendData(client_packet);
+
+            m_players[current_player]->w_pressed = w_pressed;
+            m_players[current_player]->a_pressed = a_pressed;
+            m_players[current_player]->s_pressed = s_pressed;
+            m_players[current_player]->d_pressed = d_pressed;
+            m_players[current_player]->rel_mouse_movement =  rel_mouse_movement;
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
-        {
-            w_pressed = KEY_PRESSED;
-        }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
-        {
-            s_pressed = KEY_PRESSED;
-        }
-        rel_mouse_movement = sf::Mouse::getPosition(*m_window).x - m_width / 2;
-        sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
     }
-
-    // Send an update to the server if something has changed
-    if((w_pressed_prev != w_pressed) ||
-       (a_pressed_prev != a_pressed) ||
-       (s_pressed_prev != s_pressed) ||
-       (d_pressed_prev != d_pressed) ||
-       (rel_mouse_movement_prev !=  rel_mouse_movement))
+    else if(!registered_player)
     {
-        client_packet << w_pressed;
-        client_packet << a_pressed;
-        client_packet << s_pressed;
-        client_packet << d_pressed;
-        client_packet << rel_mouse_movement;
-
-        m_net_client->sendData(client_packet);
-
-        w_pressed_prev = w_pressed;
-        a_pressed_prev = a_pressed;
-        s_pressed_prev = s_pressed;
-        d_pressed_prev = d_pressed;
-        rel_mouse_movement_prev =  rel_mouse_movement;
+        sf::Uint8 packet_type = PLAYER_CONNECT;
+        client_packet.clear();
+        client_packet << packet_type;
+        client_packet << current_player;
+        client_packet << current_player_name;
+        m_net_client->sendData(client_packet, true);
+        registered_player = true;
+    }
+    else
+    {
+        // Do nothing.
     }
     m_net_client->Transmit();
 }

src/client/Client.h

@@ -1,4 +1,3 @@
-
 #ifndef CLIENT_H
 #define CLIENT_H
 
@@ -18,7 +17,7 @@ class Client
     public:
         Client();
         ~Client();
-        void run(bool fullscreen, int width, int height);
+        void run(bool fullscreen, int width, int height, std::string pname);
     protected:
         bool create_window(bool fullscreen, int width, int height);
         bool initgl();
@@ -34,7 +33,9 @@ class Client
         refptr<sf::Window> m_window;
         sf::Clock m_clock;
         Map m_map;
-        refptr<Player> m_player;
+        sf::Uint8 current_player;
+        std::string current_player_name;
+        std::map<sf::Uint8, refptr<Player> > m_players;
         int m_width;
         int m_height;
         GLProgram m_obj_program;

src/client/main.cc

@@ -1,4 +1,3 @@
-
 #include <stdlib.h>
 #include <getopt.h>
 #include "Client.h"
@@ -8,11 +7,13 @@ int main(int argc, char *argv[])
     bool fullscreen = false;
     int width = 1200;
     int height = 900;
+    std::string player_name = "Player";
 
     struct option longopts[] = {
         {"fullscreen", no_argument, NULL, 'f'},
         {"height", required_argument, NULL, 'h'},
         {"width", required_argument, NULL, 'w'},
+        {"name", required_argument, NULL, 'n'},
         {NULL, 0, NULL, 0}
     };
     for (;;)
@@ -31,12 +32,15 @@ int main(int argc, char *argv[])
             case 'w':
                 width = atoi(optarg);
                 break;
+            case 'n':
+                player_name = std::string(optarg);
+                break;
         }
     }
 
     Client client;
 
-    client.run(fullscreen, width, height);
+    client.run(fullscreen, width, height, player_name);
 
     return 0;
 }