Cosmetic changes, some minor refactoring.

src/network/protocols/connect_to_server.cpp

@@ -38,31 +38,36 @@
 #endif
 
 // ----------------------------------------------------------------------------
-
+/** Quick join/
-ConnectToServer::ConnectToServer() :
+ */
-    Protocol(NULL, PROTOCOL_CONNECTION)
+ConnectToServer::ConnectToServer() : Protocol(NULL, PROTOCOL_CONNECTION)
 {
     m_server_id  = 0;
+    m_host_id    = 0;
     m_quick_join = true;
     m_state      = NONE;
-}
+}   // ConnectToServer()
 
 // ----------------------------------------------------------------------------
-
+/** Specify server to connect to.
-ConnectToServer::ConnectToServer(uint32_t server_id, uint32_t host_id) :
+ *  \param server_id Id of server to connect to.
-    Protocol(NULL, PROTOCOL_CONNECTION)
+ *  \param host_id Id of host.
+ */
+ConnectToServer::ConnectToServer(uint32_t server_id, uint32_t host_id)
+               : Protocol(NULL, PROTOCOL_CONNECTION)
 {
     m_server_id  = server_id;
     m_host_id    = host_id;
     m_quick_join = false;
     m_state      = NONE;
-}
+}   // ConnectToServer(server, host)
 
 // ----------------------------------------------------------------------------
-
+/** Destructor. 
+ */
 ConnectToServer::~ConnectToServer()
 {
-}
+}   // ~ConnectToServer
 
 // ----------------------------------------------------------------------------
 
@@ -75,20 +80,18 @@ bool ConnectToServer::notifyEventAsynchronous(Event* event)
         m_state = CONNECTED; // we received a message, we are connected
     }
     return true;
-}
+}   // notifyEventAsynchronous
 
 // ----------------------------------------------------------------------------
-
 void ConnectToServer::setup()
 {
-    Log::info("ConnectToServer", "SETUPP");
+    Log::info("ConnectToServer", "SETUP");
     m_state = NONE;
     m_server_address.clear();
     m_current_protocol_id = 0;
-}
+}   // setup
 
 // ----------------------------------------------------------------------------
-
 void ConnectToServer::asynchronousUpdate()
 {
     switch(m_state)
@@ -96,87 +99,161 @@ void ConnectToServer::asynchronousUpdate()
         case NONE:
         {
             Log::info("ConnectToServer", "Protocol starting");
-            m_current_protocol_id = m_listener->requestStart(new GetPublicAddress());
+            m_current_protocol_id =
+                m_listener->requestStart(new GetPublicAddress());
             m_state = GETTING_SELF_ADDRESS;
             break;
         }
         case GETTING_SELF_ADDRESS:
-            if (m_listener->getProtocolState(m_current_protocol_id)
+            if (m_listener->getProtocolState(m_current_protocol_id) ==
-            == PROTOCOL_STATE_TERMINATED) // now we know the public addr
+                PROTOCOL_STATE_TERMINATED) // now we know the public addr
             {
                 m_state = SHOWING_SELF_ADDRESS;
-                m_current_protocol_id = m_listener->requestStart(new ShowPublicAddress());
+                m_current_protocol_id =
+                    m_listener->requestStart(new ShowPublicAddress());
                 Log::info("ConnectToServer", "Public address known");
-                /*
-                if (m_quick_join)
-                    m_current_protocol_id = m_listener->requestStart(new QuickJoinProtocol(&m_server_address, &m_server_id));
-                else
-                    m_current_protocol_id = m_listener->requestStart(new GetPeerAddress(m_server_id, &m_server_address));*/
             }
             break;
         case SHOWING_SELF_ADDRESS:
-            if (m_listener->getProtocolState(m_current_protocol_id)
+            if (m_listener->getProtocolState(m_current_protocol_id) ==
-            == PROTOCOL_STATE_TERMINATED) // now our public address is in the database
+                PROTOCOL_STATE_TERMINATED)
             {
+                // now our public address is in the database
                 Log::info("ConnectToServer", "Public address shown");
                 if (m_quick_join)
                 {
-                    m_current_protocol_id = m_listener->requestStart(new QuickJoinProtocol(&m_server_address, &m_server_id));
+                    m_current_protocol_id = m_listener->requestStart(
+                            new QuickJoinProtocol(&m_server_address,
+                                                  &m_server_id)      );
                     m_state = REQUESTING_CONNECTION;
                 }
                 else
                 {
-                    m_current_protocol_id = m_listener->requestStart(new GetPeerAddress(m_host_id, &m_server_address));
+                    m_current_protocol_id = m_listener->requestStart(
+                            new GetPeerAddress(m_host_id,
+                                               &m_server_address)    );
                     m_state = GETTING_SERVER_ADDRESS;
                 }
             }
             break;
         case GETTING_SERVER_ADDRESS:
-            if (m_listener->getProtocolState(m_current_protocol_id)
+            if (m_listener->getProtocolState(m_current_protocol_id) ==
-            == PROTOCOL_STATE_TERMINATED) // we know the server address
+                PROTOCOL_STATE_TERMINATED) // we know the server address
             {
                 Log::info("ConnectToServer", "Server's address known");
                 // we're in the same lan (same public ip address) !!
                 if (m_server_address.getIP() ==
                     NetworkManager::getInstance()->getPublicAddress().getIP())
+                {
                     Log::info("ConnectToServer",
                               "Server appears to be in the same LAN.");
+                }
                 m_state = REQUESTING_CONNECTION;
                 m_current_protocol_id = 
-                    m_listener->requestStart(new RequestConnection(m_server_id));
+                    m_listener->requestStart(
+                                           new RequestConnection(m_server_id));
             }
             break;
         case REQUESTING_CONNECTION:
-            if (m_listener->getProtocolState(m_current_protocol_id)
+            if (m_listener->getProtocolState(m_current_protocol_id) ==
-            == PROTOCOL_STATE_TERMINATED) // server knows we wanna connect
+                PROTOCOL_STATE_TERMINATED)
             {
+                // Server knows we want to connect
                 Log::info("ConnectToServer", "Connection request made");
                 if (m_server_address.getIP() == 0 ||
                     m_server_address.getPort() == 0  )
-                { // server data not correct, hide address and stop
+                { 
+                    // server data not correct, hide address and stop
                     m_state = HIDING_ADDRESS;
                     Log::error("ConnectToServer", "Server address is %s",
                                m_server_address.toString().c_str());
-                    m_current_protocol_id = m_listener->requestStart(new HidePublicAddress());
+                    m_current_protocol_id = 
+                        m_listener->requestStart(new HidePublicAddress());
                     return;
                 }
-                // we're in the same lan (same public ip address) !!
+                if (m_server_address.getIP() == NetworkManager::getInstance()
-                if (m_server_address.getIP() ==
+                                                ->getPublicAddress().getIP())
-                    NetworkManager::getInstance()->getPublicAddress().getIP())
                 {
-                    // just send a broadcast packet, the client will know our ip address and will connect
+                    // we're in the same lan (same public ip address) !!
+                    handleSameLAN();
+                }
+                else
+                {
+                    m_state = CONNECTING;
+                    m_current_protocol_id = m_listener->requestStart(
+                               new PingProtocol(m_server_address, 2.0));
+                }
+            }
+            break;
+        case CONNECTING: // waiting the server to answer our connection
+            {
+                static double timer = 0;
+                if (StkTime::getRealTime() > timer+5.0) // every 5 seconds
+                {
+                    timer = StkTime::getRealTime();
+                    NetworkManager::getInstance()->connect(m_server_address);
+                    Log::info("ConnectToServer", "Trying to connect to %s",
+                              m_server_address.toString().c_str());
+                }
+                break;
+            }
+        case CONNECTED:
+        {
+            Log::info("ConnectToServer", "Connected");
+            // Kill the ping protocol because we're connected
+            m_listener->requestTerminate(
+                               m_listener->getProtocol(m_current_protocol_id));
+            m_current_protocol_id = 
+                             m_listener->requestStart(new HidePublicAddress());
+            ClientNetworkManager::getInstance()->setConnected(true);
+            m_state = HIDING_ADDRESS;
+            break;
+        }
+        case HIDING_ADDRESS:
+            if (m_listener->getProtocolState(m_current_protocol_id)
+                == PROTOCOL_STATE_TERMINATED) // we have hidden our address
+            {
+                Log::info("ConnectToServer", "Address hidden");
+                m_state = DONE;
+                // lobby room protocol if we're connected only
+                if (ClientNetworkManager::getInstance()->isConnected())
+                {
+                    m_listener->requestStart(
+                                new ClientLobbyRoomProtocol(m_server_address));
+                }
+            }
+            break;
+        case DONE:
+            m_listener->requestTerminate(this);
+            m_state = EXITING;
+            break;
+        case EXITING:
+            break;
+    }
+}
+
+// ----------------------------------------------------------------------------
+/** Called when the server is on the same LAN. It uses broadcast to
+ *  find and conntect to the server.
+ */
+void ConnectToServer::handleSameLAN()
+{
+    // just send a broadcast packet, the client will know our 
+    // ip address and will connect
     STKHost* host = NetworkManager::getInstance()->getHost();
     host->stopListening(); // stop the listening
-                    TransportAddress sender;
 
     TransportAddress broadcast_address;
     broadcast_address.setIP(-1); // 255.255.255.255
-                        broadcast_address.setPort(7321); // 0b10101100000101101101111111111111; // for test
+    broadcast_address.setPort(7321);
     char data2[] = "aloha_stk\0";
     host->sendRawPacket((uint8_t*)(data2), 10, broadcast_address);
 
     Log::info("ConnectToServer", "Waiting broadcast message.");
-                    const uint8_t* received_data = host->receiveRawPacket(&sender); // get the sender
+
+    TransportAddress sender;
+    // get the sender
+    const uint8_t* received_data = host->receiveRawPacket(&sender);
 
     host->startListening(); // start listening again
     const char data[] = "aloha_stk\0";
@@ -185,7 +262,8 @@ void ConnectToServer::asynchronousUpdate()
         Log::info("ConnectToServer", "LAN Server found : %s",
                    sender.toString().c_str());
 #ifndef WIN32
-                        // just check if the ip is ours : if so, then just use localhost (127.0.0.1)
+        // just check if the ip is ours : if so, 
+        // then just use localhost (127.0.0.1)
         struct ifaddrs *ifap, *ifa;
         struct sockaddr_in *sa;
         getifaddrs(&ifap); // get the info
@@ -239,53 +317,4 @@ void ConnectToServer::asynchronousUpdate()
         m_server_address.copy(sender);
         m_state = CONNECTING;
     }
-                }
+}  // handleSameLAN
-                else
-                {
-                    m_state = CONNECTING;
-                    m_current_protocol_id = m_listener->requestStart(new PingProtocol(m_server_address, 2.0));
-                }
-            }
-            break;
-        case CONNECTING: // waiting the server to answer our connection
-            {
-                static double timer = 0;
-                if (StkTime::getRealTime() > timer+5.0) // every 5 seconds
-                {
-                    timer = StkTime::getRealTime();
-                    NetworkManager::getInstance()->connect(m_server_address);
-                    Log::info("ConnectToServer", "Trying to connect to %s",
-                              m_server_address.toString().c_str());
-                }
-                break;
-            }
-        case CONNECTED:
-        {
-            Log::info("ConnectToServer", "Connected");
-            m_listener->requestTerminate( m_listener->getProtocol(m_current_protocol_id)); // kill the ping protocol because we're connected
-            m_current_protocol_id = m_listener->requestStart(new HidePublicAddress());
-            ClientNetworkManager::getInstance()->setConnected(true);
-            m_state = HIDING_ADDRESS;
-            break;
-        }
-        case HIDING_ADDRESS:
-            if (m_listener->getProtocolState(m_current_protocol_id)
-            == PROTOCOL_STATE_TERMINATED) // we have hidden our address
-            {
-                Log::info("ConnectToServer", "Address hidden");
-                m_state = DONE;
-                if (ClientNetworkManager::getInstance()->isConnected()) // lobby room protocol if we're connected only
-                    m_listener->requestStart(new ClientLobbyRoomProtocol(m_server_address));
-            }
-            break;
-        case DONE:
-            m_listener->requestTerminate(this);
-            m_state = EXITING;
-            break;
-        case EXITING:
-            break;
-    }
-}
-
-// ----------------------------------------------------------------------------
-

src/network/protocols/connect_to_server.hpp

@@ -21,28 +21,19 @@
 
 #include "network/protocol.hpp"
 #include "network/types.hpp"
+#include "utils/cpp2011.hpp"
 #include <string>
 
 class ConnectToServer : public Protocol, public CallbackObject
 {
-    public:
+private:
-        ConnectToServer(); //!< Quick join
-        ConnectToServer(uint32_t server_id, uint32_t host_id); //!< Specify server id
-        virtual ~ConnectToServer();
-
-        virtual bool notifyEventAsynchronous(Event* event);
-        virtual void setup();
-        virtual void update() {}
-        virtual void asynchronousUpdate();
-
-    protected:
     TransportAddress m_server_address;
     uint32_t m_server_id;
     uint32_t m_host_id;
     uint32_t m_current_protocol_id;
     bool m_quick_join;
 
-        enum STATE
+    enum State
     {
         NONE,
         GETTING_SELF_ADDRESS,
@@ -55,7 +46,21 @@ class ConnectToServer : public Protocol, public CallbackObject
         DONE,
         EXITING
     };
-        STATE m_state;
+    /** State for finite state machine. */
-};
+    State m_state;
+
+    void handleSameLAN();
+
+public:
+    ConnectToServer();
+    ConnectToServer(uint32_t server_id, uint32_t host_id);
+    virtual ~ConnectToServer();
+
+    virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
+    virtual void setup() OVERRIDE;
+    virtual void asynchronousUpdate();
+    virtual void update() OVERRIDE {}
+
+};   // class ConnectToServer
 
 #endif // CONNECT_TO_SERVER_HPP