start ChessServer and remove basic redundant examples

modules/Archimedes-Modules/Calculator/Calculator.cpp

@@ -44,89 +44,208 @@ void Calculator::run() {
 
 }
         
-std::string calculate(std::string equation) {
-    std::stringstream s(equation);
+void Calculator::index(std::string equation, std::unordered_map<unsigned int, std::string>& nodes) {
+    unsigned int idx = 0;
+
+    nodes.clear();
+
+    const static std::string operators[] = {
+        "(",
+        ")",
+        "^",
+        "*",
+        "/",
+        "+",
+        "-"
+    };
+
+    for(const std::string& s : operators) {
+
+        while(equation.find(s, idx) != std::string::npos) {
+            int next = equation.find(s, idx);
+            nodes[next] = equation.substr(next, s.length());
+            idx = next + s.length();
+        }
+        idx = 0;
+    }
+
+
+    // -3+8*6-(8+4)^9/5
+    for(unsigned int i = 0; i < equation.length(); i++) {
+        static unsigned int begin = 0, end = 0;
+        if(nodes.find(i) == nodes.end()) {
+            if(nodes.find(i - 1) != nodes.end() || i == 0) {
+                //first digit of expression
+                begin = i;
+            }
+            if(nodes.find(i + 1) != nodes.end() || i == equation.length() - 1) {
+                //character after last digit of expression
+                end = i + 1;
+                nodes[begin] = equation.substr(begin, end - begin);
+                nodes[end - 1] = equation.substr(begin, end - begin);
+            }
+        }
+    }
+}
+
+double Calculator::evaluate(std::string equation, std::unordered_map<char, std::string>& evalStr) {
+
+    char op = '^';
+
+    while(equation.find(op) == std::string::npos) {
+        switch(op) {
+            case '^':
+                op = '*';
+                break;
+            case '*':
+                op = '/';
+                break;
+            case '/':
+                op = '+';
+                break;
+            case '+':
+                op = '-';
+                break;
+            case '-':
+                //no operator
+                if(evalStr.find(equation.front()) != evalStr.end()) {
+                    return evaluate(evalStr[equation.front()], evalStr);
+                } else {
+                    return std::stod(equation);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    //op is now the appropriate operator
+
+    //if either term is a placeholder, evaluate and substitute.
+    double a, b;
+    if(evalStr.find(equation.front()) != evalStr.end()) {
+        a = evaluate(evalStr[equation.front()], evalStr);
+    } else {
+        if(equation.find(op) == 0 && op == '-') {
+            a = 0;
+        } else {
+            a = std::stod(equation.substr(0, equation.find(op)));
+        }
+    }
+
+    if(evalStr.find(equation.back()) != evalStr.end()) {
+        b = evaluate(evalStr[equation.back()], evalStr);
+    } else {
+        b = std::stod(equation.substr(equation.find(op) + 1));
+    }
+    switch(op) {
+        case '^':
+            return pow(a, b);
+        case '*':
+            return a * b;
+        case '/':
+            return a / b;
+        case '+':
+            return a + b;
+        case '-':
+            return a - b;
+        default:
+            break;
+    }
+}
+
+std::string Calculator::calculate(std::string equation) {
     
     //PEMDAS
-    while(equation.find('(') != std::string::npos) {
-        if(equation.find(')') == std::string::npos) {
-            return "error";
-        }
-
-        int start = equation.find_last_of('(');
-        int end = equation.find_first_of(')', start);
-
-        std::string insert = calculate(equation.substr(start + 1, end - 1));
-
-        equation.replace(start, end, insert.c_str());
-
+    while(equation.find(' ') != std::string::npos) {
+        equation.erase(equation.find(' '), 1);
+    }
+    while(equation.find('\t') != std::string::npos) {
+        equation.erase(equation.find('\t'), 1);
+    }
+    while(equation.find('\n') != std::string::npos) {
+        equation.erase(equation.find('\n'), 1);
     }
 
-    while(equation.find('^') != std::string::npos) {
+    std::unordered_map<unsigned int, std::string> nodes;
+    std::unordered_map<char, std::string> evalStr;
+    std::string eval = "a";
+
+    unsigned int idx = 0;
+
+    index(equation, nodes);
+
+    idx = 0;
+
+    // ()
+    while(equation.find(')', idx) != std::string::npos) {
+        int end = equation.find(')');
+        int begin = equation.rfind('(', end);
+        evalStr[eval.front()] = calculate(equation.substr(begin + 1, (end - begin) - 1));
+        equation.replace(begin, (end - begin) + 1, eval);
+        eval.front()++;
+        idx = end + 1;
+    }
+    idx = 0;
+    index(equation, nodes);
+    // ^
+    while(equation.find('^', idx) != std::string::npos) {
         int mid = equation.find('^');
-        int start = equation.rfind(' ', mid - 1);
-        int end = equation.find(' ', mid + 1);
-        double base = stod(equation.substr(start + 1, mid - 1));
-        double exp = stod(equation.substr(mid + 1, end - 1));
-
-        std::string insert = std::to_string(pow(base, exp));
-        
-        equation.replace(start, end, insert.c_str());
-
+        int begin = equation.find(nodes[mid - 1] + nodes[mid]);
+        int end = equation.find(nodes[mid] + nodes[mid + 1], begin) + (nodes[mid] + nodes[mid + 1]).length();
+        evalStr[eval.front()] = equation.substr(begin, end - begin);
+        equation.replace(begin, end - begin, eval);
+        eval.front()++;
+        idx = end + 1;
     }
-    while(equation.find('*') != std::string::npos) {
-        int mid = equation.find('*');
-        int start = equation.rfind(' ', mid - 1);
-        int end = equation.find(' ', mid + 1);
-        double a = stod(equation.substr(start + 1, mid - 1));
-        double b = stod(equation.substr(mid + 1, end - 1));
-        
-        std::string insert = std::to_string(a * b);
-        
-        equation.replace(start, end, insert.c_str());
-
-    }
-    while(equation.find('/') != std::string::npos) {
-        int mid = equation.find('/');
-        int start = equation.rfind(' ', mid - 1);
-        int end = equation.find(' ', mid + 1);
-        double a = stod(equation.substr(start + 1, mid - 1));
-        double b = stod(equation.substr(mid + 1, end - 1));
-        
-        std::string insert = std::to_string(a / b);
-        
-        equation.replace(start, end, insert.c_str());
-
-    }
-    while(equation.find('+') != std::string::npos) {
-        int mid = equation.find('+');
-        int start = equation.rfind(' ', mid - 1);
-        int end = equation.find(' ', mid + 1);
-        double a = stod(equation.substr(start + 1, mid - 1));
-        double b = stod(equation.substr(mid + 1, end - 1));
-        
-        std::string insert = std::to_string(a + b);
-        
-        equation.replace(start, end, insert.c_str());
-
-    }
-    while(equation.find('-') != std::string::npos) {
-        int mid = equation.find('-');
-        int start = equation.rfind(' ', mid - 1);
-        if(start == std::string::npos) {
-            break;
+    idx = 0;
+    index(equation, nodes);
+    // * or /
+    while(equation.find('*', idx) != std::string::npos || equation.find('/', idx) != std::string::npos) {
+        if(equation.find('*', idx) < equation.find('/', idx) && equation.find('*', idx) != std::string::npos) {
+            int mid = equation.find('*');
+            int begin = equation.find(nodes[mid - 1] + nodes[mid]);
+            int end = equation.find(nodes[mid] + nodes[mid + 1], begin) + (nodes[mid] + nodes[mid + 1]).length();
+            evalStr[eval.front()] = equation.substr(begin, end - begin);
+            equation.replace(begin, end - begin, eval);
+            eval.front()++;
+            idx = end + 1;
+        } else if(equation.find('/', idx) != std::string::npos) {
+            int mid = equation.find('/');
+            int begin = equation.find(nodes[mid - 1] + nodes[mid]);
+            int end = equation.find(nodes[mid] + nodes[mid + 1], begin) + (nodes[mid] + nodes[mid + 1]).length();
+            evalStr[eval.front()] = equation.substr(begin, end - begin);
+            equation.replace(begin, end - begin, eval);
+            eval.front()++;
+            idx = end + 1;
+        }
+    }
+    idx = 0;
+    index(equation, nodes);
+    // + or -
+    while(equation.find('+', idx) != std::string::npos || equation.find('-', idx) != std::string::npos) {
+        if(equation.find('+', idx) < equation.find('-', idx) && equation.find('+', idx) != std::string::npos) {
+            int mid = equation.find('+');
+            int begin = equation.find(nodes[mid - 1] + nodes[mid]);
+            int end = equation.find(nodes[mid] + nodes[mid + 1], begin) + (nodes[mid] + nodes[mid + 1]).length();
+            evalStr[eval.front()] = equation.substr(begin, end - begin);
+            equation.replace(begin, end - begin, eval);
+            eval.front()++;
+            idx = end + 1;
+        } else if(equation.find('-', idx) != std::string::npos) {
+            int mid = equation.find('-');
+            int begin = mid;
+            if(nodes.find(mid - 1) != nodes.end()) {
+                begin = equation.find(nodes[mid - 1] + nodes[mid]);
+            }
+            int end = equation.find(nodes[mid] + nodes[mid + 1], begin) + (nodes[mid] + nodes[mid + 1]).length();
+            evalStr[eval.front()] = equation.substr(begin, end - begin);
+            equation.replace(begin, end - begin, eval);
+            eval.front()++;
+            idx = end + 1;
         }
-        int end = equation.find(' ', mid + 1);
-        double a = stod(equation.substr(start + 1, mid - 1));
-        double b = stod(equation.substr(mid + 1, end - 1));
-        
-        std::string insert = std::to_string(a - b);
-        
-        equation.replace(start, end, insert.c_str());
-
     }
     
-    return equation;
+    return std::to_string(evaluate(equation, evalStr));
 }
 
 
@@ -145,21 +264,21 @@ void Calculator::basicCalculator() {
             ImGui::BeginGroup();
             {
                 if(ImGui::Button("AC")) {
-                    s += " + ";
+                    s.clear();
                 }
-                if(ImGui::Button("()")) {
-
-                    if(parenthesis) {
-                        s += " ( ";
-                    } else {
-                        s += " ) ";
-                    }
-
-                    parenthesis = !parenthesis;
+                ImGui::SameLine();
+                if(ImGui::Button("(")) {
+                    s += " ( ";
                 }
-                if(ImGui::Button("Gr")) {
-                    graphing = true;
+                ImGui::SameLine();
+                if(ImGui::Button(")")) {
+                    s += " ) ";
                 }
+                ImGui::SameLine();
+                if(ImGui::Button("^")) {
+                    s += " ^ ";
+                }
+                ImGui::SameLine();
                 if(ImGui::Button("=")) {
                     s = calculate(s);
                 }
@@ -190,15 +309,17 @@ void Calculator::basicCalculator() {
                 }
                 ImGui::SameLine();
                 if(ImGui::Button("del")) {
-                    if(s.back() == ' ') {
-                        s.pop_back();
-                        if(s.back() == '(' || s.back() == ')') {
-                            parenthesis = !parenthesis;
+                    if(!s.empty()) {
+                        if(s.back() == ' ') {
+                            s.pop_back();
+                            if(s.back() == '(' || s.back() == ')') {
+                                parenthesis = !parenthesis;
+                            }
+                            s.pop_back();
+                            s.pop_back();
+                        } else {
+                            s.pop_back();
                         }
-                        s.pop_back();
-                        s.pop_back();
-                    } else {
-                        s.pop_back();
                     }
                 }
             }

modules/Archimedes-Modules/Calculator/Calculator.h

@@ -22,8 +22,11 @@ class Calculator : public Archimedes::Module {
         void basicCalculator();
 
         std::string calculate(std::string);
+        double evaluate(std::string, std::unordered_map<char, std::string>&);
+        void index(std::string, std::unordered_map<unsigned int, std::string>&);
 
         void graphingCalculator();
+
 };
 
 #ifdef CALCULATOR_DYNAMIC

modules/Archimedes-Modules/ChatVoice/ChatClientVoice/ChatClientVoice.cpp

@@ -84,7 +84,8 @@ void ChatClientVoice::run() {
         if(cm->isRunning() && cm->isConnected()) {
             
             if(ImGui::Button("Disconnect") && cm->isRunning()) {
-                cm->stopClient();
+                cm->sendReliable("srvcmd1", strlen("srvcmd1"));
+                //cm->stopClient();
             }
         
         } else {
@@ -105,11 +106,16 @@ void ChatClientVoice::run() {
             ImGui::SameLine();
 
             if(ImGui::Button("send")) {
-                s.insert(s.begin(), 'o');
-                s.insert(s.begin(), ' ');
-                s.insert(s.begin(), '0');
-                s.insert(s.begin(), 'a');
-                cm->sendReliable(s.c_str(), (uint32) s.length());
+                if(s == "/quit") {
+                    cm->sendReliable("srvcmd1", strlen("srvcmd1"));
+                    cm->stopClient();
+                } else if(s == "/shutdown") {
+                    cm->sendReliable("srvcmd2", strlen("srvcmd2"));
+                    //cm->stopClient();
+                } else {
+                    s.insert(0, "client");
+                    cm->sendReliable(s.c_str(), (uint32) s.length());
+                }
                 s.clear();
             }
         }
@@ -130,9 +136,6 @@ void ChatClientVoice::run() {
             SDL_ClearAudioStream(mic);
             SDL_ResumeAudioStreamDevice(mic);
             SDL_SetAudioStreamGain(mic, micVol);
-        } else if(!cm->isConnected()) {
-            SDL_PauseAudioStreamDevice(mic);
-            SDL_ClearAudioStream(mic);
         }
 
         if(!SDL_AudioStreamDevicePaused(speaker)) {
@@ -141,10 +144,6 @@ void ChatClientVoice::run() {
             SDL_ClearAudioStream(speaker);
             SDL_ResumeAudioStreamDevice(speaker);
             SDL_SetAudioStreamGain(speaker, speakerVol);
-        } else if(!cm->isConnected()) {
-            SDL_PauseAudioStreamDevice(speaker);
-            SDL_ClearAudioStream(speaker);
-
         }
 
         static int avail = 0;
@@ -152,9 +151,10 @@ void ChatClientVoice::run() {
         if(micTest) {
 
             avail = SDL_min(len, SDL_GetAudioStreamAvailable(mic));
-            avail = SDL_GetAudioStreamData(mic, buf, avail);
-
-            SDL_PutAudioStreamData(speaker, buf, avail);
+            if(avail > 10) {
+                avail = SDL_GetAudioStreamData(mic, buf, avail);
+                SDL_PutAudioStreamData(speaker, buf, avail);
+            }
 
         } else if(cm->isConnected()){
             // if not testing, send to server.
@@ -176,6 +176,7 @@ void ChatClientVoice::run() {
 bool ChatClientVoice::onEvent(const Archimedes::Event& event) {
 
     unsigned int type = app->getEventType(event);
+    static ClientModule* cm; 
     
     /*if(type == app->getEventType("DataSentEvent")) {
         //we did this?
@@ -186,19 +187,49 @@ bool ChatClientVoice::onEvent(const Archimedes::Event& event) {
     
         Archimedes::DataRecievedEvent& e = (Archimedes::DataRecievedEvent&) event;
         
+        { cm = (ClientModule*) moduleInstances[ClientModule()]; }
+
         static std::string s; 
 
-        if(((char*)e.msg->m_pData)[0] == 'a' && ((char*)e.msg->m_pData)[1] == '0' && ((char*)e.msg->m_pData)[2] == ' ' && ((char*)e.msg->m_pData)[3] == 'o') {
-            s = std::string((const char*)e.msg->m_pData + 4, e.msg->m_cbSize - 4);
+        if(std::string((const char*)e.msg->m_pData, 6) == "client") {
+            s = std::string((const char*)e.msg->m_pData + 6, e.msg->m_cbSize - 6);
 
             messages += "\n\n" + s;
-        } else {
+        } else if(std::string((const char*)e.msg->m_pData, 6) == "server") {
+            s = std::string((const char*)e.msg->m_pData + 6, e.msg->m_cbSize - 6);
+
+            int serverCode = stoi(s);
+
+            switch(serverCode) {
+                case 0:
+                    //start voice
+                    SDL_ClearAudioStream(mic);
+                    SDL_ClearAudioStream(speaker);
+                    SDL_ResumeAudioStreamDevice(mic);
+                    SDL_ResumeAudioStreamDevice(speaker);
+                    break;
+                case 1:
+                    //stop voice and clear
+                    SDL_PauseAudioStreamDevice(mic);
+                    SDL_PauseAudioStreamDevice(speaker);
+                    SDL_ClearAudioStream(mic);
+                    SDL_ClearAudioStream(speaker);
+                    break;
+                case 2:
+                    //disconnect
+                    cm->stopClient();
+                    break;
+                default:
+                    break;
+            }
+
+        } else /*if(std::string((const char*)e.msg->m_pData, 6) == "audio:")*/ {
             s = "audio data";
 
             SDL_PutAudioStreamData(speaker, e.msg->m_pData, e.msg->m_cbSize);
         }
 
-        std::cerr << "Client Recieved: " << s << std::endl;
+        //std::cerr << "Client Recieved: " << s << std::endl;
 
         return true;
     } else if(type == app->getEventType("ConnectionStatusChangedEvent")) {
@@ -230,11 +261,6 @@ bool ChatClientVoice::onEvent(const Archimedes::Event& event) {
 
             case k_ESteamNetworkingConnectionState_Connected:
                 //OnConnect
-                SDL_ClearAudioStream(mic);
-                SDL_ClearAudioStream(speaker);
-                SDL_ResumeAudioStreamDevice(mic);
-                SDL_ResumeAudioStreamDevice(speaker);
-
                 break;
 
             default:

modules/Archimedes-Modules/ChatVoice/ChatServerVoice/ChatServerVoice.cpp

@@ -12,7 +12,7 @@ bool ChatServerVoice::onEvent(const Archimedes::Event& event) {
 
     unsigned int type = app->getEventType(event);
 
-
+    static ServerModule* sm; 
     /*if(type == app->getEventType("DataSentEvent")) {
         //we did this?
         return true;
@@ -20,30 +20,48 @@ bool ChatServerVoice::onEvent(const Archimedes::Event& event) {
     
     if(type == app->getEventType(Archimedes::DataRecievedEvent())) {
     
-        static ServerModule* sm; { sm = (ServerModule*) moduleInstances[ServerModule()]; }
+        { sm = (ServerModule*) moduleInstances[ServerModule()]; }
+
 
         Archimedes::DataRecievedEvent& e = (Archimedes::DataRecievedEvent&) event;
         static std::string s; 
         
-        if(((char*)e.msg->m_pData)[0] == 'a' && ((char*)e.msg->m_pData)[1] == '0' && ((char*)e.msg->m_pData)[2] == ' ' && ((char*)e.msg->m_pData)[3] == 'o') {
-            s = std::string((const char*)e.msg->m_pData + 4, e.msg->m_cbSize - 4);
-
-            if(s == "/quit") {
-                sm->disconnectClient(e.msg->m_conn);
-            } else if(s == "/shutdown") {
-                sm->stopServer();
-                app->end();
-            }
+        if(std::string((const char*)e.msg->m_pData, 6) == "client") {
+            s = std::string((const char*)e.msg->m_pData + 6, e.msg->m_cbSize - 6);
             
             for(auto& it : sm->getClients()) {
             if(it.first != e.msg->m_conn)
                 sm->sendReliable(it.first, e.msg->m_pData, e.msg->m_cbSize);
             else
-                sm->sendReliable(e.msg->m_conn, "a0 o\nMessage sent\n", strlen("a0 o\nMessage sent\n"));
+                sm->sendReliable(e.msg->m_conn, "client\nMessage sent\n", strlen("client\nMessage sent\n"));
             }
 
 
-        } else {
+        } else if(std::string((const char*)e.msg->m_pData, 6) == "srvcmd") {
+            s = std::string((const char*)e.msg->m_pData + 6, e.msg->m_cbSize - 6);
+
+            int cmdCode = stoi(s);
+
+            switch(cmdCode) {
+                case 0:
+                    break;
+                case 1:
+                    //disconnect
+                    sm->disconnectClient(e.msg->m_conn);
+                    break;
+                case 2:
+                    for(auto& it : sm->getClients()) {
+                        sm->sendReliable(it.first, "server2", strlen("server2"));
+                    }                   
+                    sm->stopServer();
+                    app->end();
+                    break;
+                    
+                default:
+                    break;
+            }
+
+        } else /*if(std::string((const char*)e.msg->m_pData, 6) == "audio:")*/ {
             s = "audio data";
 
             for(auto& it : sm->getClients()) {
@@ -52,17 +70,62 @@ bool ChatServerVoice::onEvent(const Archimedes::Event& event) {
             }
         }
 
-        std::cerr << "Server Recieved: " << s << std::endl;
+        //std::cerr << "Server Recieved: " << s << std::endl;
 
         return true;
 
-    } /*else if(type == app->getEventType("ConnectionStatusChangedEvent")) {
+    } else if(type == app->getEventType("ConnectionStatusChangedEvent")) {
         
-        //Archimedes::ConnectionStatusChangedEvent& e = (Archimedes::ConnectionStatusChangedEvent&) event;
+        Archimedes::ConnectionStatusChangedEvent& e = (Archimedes::ConnectionStatusChangedEvent&) event;
+
+        { sm = (ServerModule*) moduleInstances[ServerModule()]; }
+        
+        unsigned int numClients;
+        (void)sm->getClients(&numClients);
+
+        switch(e.info->m_info.m_eState) {
+            
+            case k_ESteamNetworkingConnectionState_None:
+                // NOTE: We will get callbacks here when we destroy connections.  You can ignore these.
+                break;
+
+            case k_ESteamNetworkingConnectionState_ClosedByPeer:
+            case k_ESteamNetworkingConnectionState_ProblemDetectedLocally:
+                {
+                    if(numClients < 2) {
+                        for(auto& it : sm->getClients()) {
+                            sm->sendReliable(it.first, "server1", strlen("server1"));
+                        }                   
+                    }
+                    break;
+                }
+
+            case k_ESteamNetworkingConnectionState_Connecting:
+                {
+                    break;
+                }
+
+            case k_ESteamNetworkingConnectionState_Connected:
+                //OnConnect
+                
+                if(numClients == 2) {
+                    for(auto& it : sm->getClients()) {
+                        sm->sendReliable(it.first, "server0", strlen("server0"));
+                    }                   
+                } else if(numClients > 2) {
+                    
+                    sm->sendReliable(e.info->m_hConn, "server0", strlen("server0"));
+                }
+                break;
+
+            default:
+                // Silences -Wswitch
+                break;
+        }
 
         return false;
 
-    }*/
+    }
 
     return false;
 }

modules/Archimedes-Modules/Chess/ChessServer/ChessServer.cpp

@@ -0,0 +1,46 @@
+#include "ChessServer.h"
+
+void ChessServer::onLoad() {
+    ServerModule* sm = (ServerModule*) moduleInstances[ServerModule()];
+
+    sm->startServer(9932);
+}
+
+//void ChessServer::run() {}
+
+bool ChessServer::onEvent(const Archimedes::Event& event) {
+
+    unsigned int type = app->getEventType(event);
+
+
+    /*if(type == app->getEventType("DataSentEvent")) {
+        //we did this?
+        return true;
+    } else */
+    
+    if(type == app->getEventType(Archimedes::DataRecievedEvent())) {
+    
+        static ServerModule* sm; { sm = (ServerModule*) moduleInstances[ServerModule()]; }
+
+        Archimedes::DataRecievedEvent& e = (Archimedes::DataRecievedEvent&) event;
+
+        static std::string s; s = std::string((const char*)e.msg->m_pData, e.msg->m_cbSize);
+
+        
+        for(auto& it : sm->getClients()) {
+            if(it.first != e.msg->m_conn)
+                sm->sendReliable(it.first, s.c_str(), s.length());
+        }
+
+        return true;
+
+    } /*else if(type == app->getEventType("ConnectionStatusChangedEvent")) {
+        
+        //Archimedes::ConnectionStatusChangedEvent& e = (Archimedes::ConnectionStatusChangedEvent&) event;
+
+        return false;
+
+    }*/
+
+    return false;
+}

modules/Archimedes-Modules/Chess/ChessServer/ChessServer.h

@@ -0,0 +1,34 @@
+#include "Archimedes.h"
+
+#include "modules/ServerModule/ServerModule.h"
+
+class ChessServer : public Archimedes::Module {
+
+    public:
+
+        ChessServer(Archimedes::App* a, void* h) : Module(a, h) {
+
+            name = "ChessServer";
+
+            ServerModule* sm = new ServerModule(a, h);
+            deps[*sm] = sm;
+            sm->shouldHandleEvents(ServerModule::SMEventEnum::ConnectionStatusChanged | ServerModule::SMEventEnum::DataSent);
+        }
+
+        ChessServer() { name = "ChessServer"; }
+
+        ~ChessServer() {
+            if(app) {}
+        }
+
+        void onLoad();
+
+        //void run();
+
+        bool onEvent(const Archimedes::Event&);
+};
+
+#ifdef CHESSSERVER_DYNAMIC
+typedef ChessServer mtype;
+#include "endModule.h"
+#endif

modules/Archimedes-Modules/DependsOnPrint/DependsOnPrint.cpp

@@ -1,16 +0,0 @@
-#include "DependsOnPrint.h"
-
-DependsOnPrint::DependsOnPrint(Archimedes::App* a, void* h) : Module(a, h) {
-    name = "DependsOnPrint";
-
-    deps["Print"] = "/home/nathan/Projects/Archimedes/result-1/bin/Print";
-}
-
-DependsOnPrint::~DependsOnPrint() {
-    std::cout << "DependsOnPrint Destroyed!\n";
-}
-
-void DependsOnPrint::run() {
-    std::cout << "DependsOnPrint lib loaded and run!\n";
-    app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));
-}

modules/Archimedes-Modules/DependsOnPrint/DependsOnPrint.h

@@ -1,16 +0,0 @@
-#include "Archimedes.h"
-
-class DependsOnPrint : public Archimedes::Module {
-
-    public:
-        DependsOnPrint(Archimedes::App*, void*);
-        ~DependsOnPrint();
-        void run();
-        void onLoad() {}
-
-};
-
-#ifdef DEPENDSONPRINT_DYNAMIC
-typedef DependsOnPrint mtype;
-#include "endModule.h"
-#endif

modules/Archimedes-Modules/DependsOnPrintStatic/DependsOnPrintStatic.cpp

@@ -1,19 +0,0 @@
-#include "DependsOnPrintStatic.h"
-
-#include "modules/Archimedes-Modules/Print/Print.h"
-
-DependsOnPrintStatic::DependsOnPrintStatic(Archimedes::App* a, void* h) : Module(a, h) {
-    name = "DependsOnPrintStatic";
-
-    Print* p = new Print(a, h);
-    deps[*p] = p;
-}
-
-DependsOnPrintStatic::~DependsOnPrintStatic() {
-    std::cout << "DependsOnPrintStatic Destroyed!\n";
-}
-
-void DependsOnPrintStatic::run() {
-    std::cout << "DependsOnPrintStatic lib loaded and run!\n";
-    app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));
-}

modules/Archimedes-Modules/DependsOnPrintStatic/DependsOnPrintStatic.h

@@ -1,16 +0,0 @@
-#include "Archimedes.h"
-
-class DependsOnPrintStatic : public Archimedes::Module {
-
-    public:
-        DependsOnPrintStatic(Archimedes::App*, void*);
-        ~DependsOnPrintStatic();
-        void run();
-        void onLoad() {}
-
-};
-
-#ifdef DEPENDSONPRINTSTATIC_DYNAMIC
-typedef DependsOnPrintStatic mtype;
-#include "endModule.h"
-#endif

modules/Archimedes-Modules/TestMenu/TestMenu.cpp

@@ -1,37 +0,0 @@
-#include "TestMenu.h"
-
-TestMenu::TestMenu(Archimedes::App* a, void* h) : Module(a, h) {
-    name = "TestMenu";
-}
-
-TestMenu::~TestMenu() {
-    std::cout << "TestMenu Destroyed!\n";
-}
-
-void TestMenu::run() {
-    
-    std::cout << "Your number is: " << num << "\n"
-              << "1. Add 1\n"
-              << "2. Subtract 1\n"
-              << "3. Unload Module\n\n"
-              << "4. Quit\n\n";
-
-    std::cin >> choice;
-
-    switch(choice) {
-        case 1:
-            num++;
-            break;
-        case 2:
-            num--;
-            break;
-        case 3:
-            app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));
-            break;
-        case 4:
-            app->end();
-            break;
-        default:
-            break;
-    }
-}

modules/Archimedes-Modules/TestMenu/TestMenu.h

@@ -1,20 +0,0 @@
-#include "Archimedes.h"
-
-class TestMenu : public Archimedes::Module {
-
-    public:
-        TestMenu(Archimedes::App*, void*);
-        TestMenu() { name = "TestMenu"; }
-        ~TestMenu();
-        void run();
-        void onLoad() {}
-
-    private:
-        int choice;
-        int num = 5;
-};
-
-#ifdef TESTMENU_DYNAMIC
-typedef TestMenu mtype;
-#include "endModule.h"
-#endif

modules/ServerModule/ServerModule.h

@@ -52,7 +52,12 @@ class ServerModule : public Archimedes::Module {
             }
         }
 
-        std::map<HSteamNetConnection, unsigned int> getClients() const { return clients; }
+        std::map<HSteamNetConnection, unsigned int> getClients(unsigned int* num = nullptr) const { 
+            if(num) {
+                *num = numClients;
+            }
+            return clients; 
+        }
 
         void pollIncomingData();