Messages

61

Network / Re: Non-blocking usage and Status handling

« on: April 14, 2016, 03:47:56 am »

Thx nicox11!

62

SFML projects / Re: [Release][GUI] SFML + ImGui lib

« on: April 12, 2016, 06:29:16 pm »

I love that library.

Aside from the new

ImGui::Image(someTexture);

(which is indeed very convenient), what else is new from the original repo? Also, when I was using the original, I noticed that if you resize the window after creation, the ImGui objects stopped rendering and working properly. Did you experience that too? And if so, is that fixed?

63

SFML projects / Re: Pointless Wars - [Turn-Based Pointless Strategy]

« on: April 12, 2016, 06:18:26 pm »

Not all of the versions. The MinGW-w64 fork has support via pwinthread if you pick the POSIX threading model builds (e.g. this build).

Ah, now I know! Thank you!

64

SFML projects / Re: Pointless Wars - [Turn-Based Pointless Strategy]

« on: April 11, 2016, 07:02:36 pm »

Obligatory post so that this thread doesn't leave the front page

I've been working on multiplayer stuff for the past few days, and I successfully implemented a match-making server. It is definitely not finished, but it works and if you are interested, it's a single .cpp file (sshhh, who needs .h anyway):

Match-making server:

(click to show/hide)

#include <SFML/Network.hpp>
#include <cstdlib>
#include <cstdio>
#include <list>
#include <vector>
#include <map>
#include <cstring>
#include <iostream>
#include <sstream>
#include <ios>
#ifdef _WIN32
        #include "mingw.thread.h"
#elif __linux__
        #include <thread>
#endif
using namespace std;

struct ClientProfile{
        enum Status{WAITING_FOR_OPPONENT, JUST_ONLINE, PLAYING, OFFLINE};
        typedef unsigned int ID;
        ID id;
       
        ClientProfile(){
                socket = NULL;
                pingCounter = 0;
                nPings = 5;
                matchID = "NONE";
                status = OFFLINE;
        }
        ClientProfile(sf::TcpSocket* skt, ClientProfile::ID id){
                socket = skt;
                ip = skt->getRemoteAddress();
                nPings = 5;
                pingCounter = 0;
                matchID = "NONE";
                status = JUST_ONLINE;
                this->id = id;
        }
        //PING command stuff
        double ping = 0;                                //milliseconds
        sf::Clock pingClock;
        int nPings = 5;
        int pingCounter = 0;
       
        sf::TcpSocket* socket;
        sf::IpAddress ip;
        Status status = OFFLINE;
        list<sf::Packet> sendQueue;
       
        string matchID;
};

struct Server{
        unsigned short port = 8080;
        sf::IpAddress publicIP;
        sf::IpAddress privateIP;
        sf::TcpListener listener;
    map<ClientProfile::ID, ClientProfile> clients;
       
        bool online;
       
        list<ClientProfile::ID> clientsOut;
        ClientProfile::ID nextClientID = 1;
};

struct Match{
        typedef string ID;                                                                              //each match has its own unique ID
        ID id;
        string gameMode;
        bool pub;
        pair<ClientProfile*, ClientProfile*> players;
};

struct MatchServer : public Server{
        map<Match::ID, Match> matches;                          //contains all matches, on-going or not
        map<string, list<Match::ID> > waitList;         //each game mode has its own wait list
        unsigned int nextID = 1;
       
        list<Match::ID> matchesOut;
        list<ClientProfile::ID> playersOut;
};

///HELPERS
int str2int(string s);
string int2str(int n, int width = 0);
string db2str(double n);
double str2db(string s);

///SERVER METHODS
void readUserInput(string& userCommand, bool& newCommand);
void showClients(Server& server);
void updateListener(Server& server);
void updateClients(Server& server);
bool startServer(Server& server);
void stopServer(Server& server);
void parseCommandLine(Server& server, int argc, char* argv[]);
void processUserCommand(Server& server, const string command);
void sendPing(ClientProfile& client);
void pingClient(Server& server, ClientProfile::ID clientID);
void pingAll(Server& server);
void showClient(ClientProfile& client);
void processPacket(Server& server, ClientProfile& client, sf::Packet& packet);
ClientProfile* getClientProfile(Server& server, sf::IpAddress ip);
void cleanupServer(Server& server);
void sendPacket(ClientProfile& client, sf::Packet packet);
void sendPacket(ClientProfile& client, sf::String id);

///MATCH SERVER METHODS
void updateMatchConnections(MatchServer& server);
void cleanupMatches(MatchServer& server);
void sendMatchFound(MatchServer& server, ClientProfile& client);
void showAllMatches(MatchServer& server);
void showMatch(Match& match);

int main(int argc, char* argv[]){
        MatchServer server;
        parseCommandLine(server, argc, argv);
       
        const float targetUPS = 60.f;
        const float timeStep = 1.f/targetUPS;
       
        sf::Clock updateClock;
        if (!startServer(server)) return -1;
       
        ///INPUT THREAD
        string userCommand;
        bool newCommand = false;
        thread userInputThread(readUserInput, ref(userCommand), ref(newCommand));
       
        while(1){
                if (newCommand){
                        string command;
                        string arg;
                        stringstream ss(userCommand);
                        ss >> command;
                        if (command == "show-online"){
                                showClients(server);
                        }else if (command == "stop"){
                                stopServer(server);
                        }else if (command == "set-port"){
                                if (server.online){
                                        printf(" Cannot set port while server is online!\n");
                                }else{
                                        ss >> server.port;
                                        printf(" Port set to %d\n", server.port);
                                }
                        }else if (command == "start" || command == "restart"){
                                if (server.online){
                                        stopServer(server);
                                }
                                startServer(server);
                        }else if (command == "ping-all"){
                                pingAll(server);
                        }else if (command == "ping"){
                                ss >> arg;
                                ClientProfile::ID clientID = str2int(arg);
                                pingClient(server, clientID);
                        }else if (command == "show-all-matches"){
                                MatchServer& mserver = static_cast<MatchServer&>(server);
                                showAllMatches(mserver);
                        }
                        newCommand = false;
                }
                if (updateClock.getElapsedTime().asSeconds() >= timeStep){
                        if (server.online){
                                updateListener(server);
                                updateClients(server);
                                updateMatchConnections(server);
                                cleanupServer(server);
                                cleanupMatches(server);
                        }
                        updateClock.restart();
                }
        }
       
        return 0;
}

void showClients(Server& server){
        printf(" Clients: %d\n", server.clients.size());
        for (auto& p : server.clients){
                showClient(p.second);
        }
}

void showAllMatches(MatchServer& server){
        printf(" Matches: %d\n", server.matches.size());
        for (auto& m : server.matches){
                showMatch(m.second);
        }
}

void showMatch(Match& match){
        ClientProfile::ID p1 = match.players.first ? match.players.first->id : 0;
        ClientProfile::ID p2 = match.players.second ? match.players.second->id : 0;
        printf("%15s %15d %15d\n", match.id.c_str(), p1, p2);
}

void updateListener(Server& server){
    sf::TcpSocket* socket = new sf::TcpSocket;
    while (server.listener.accept(*socket) == sf::Socket::Done){
        socket->setBlocking(false);
                ClientProfile::ID clientID = server.nextClientID++;
                ClientProfile client(socket, clientID);
                pair<ClientProfile::ID, ClientProfile> p(clientID, client);
        server.clients.insert(p);
        socket = new sf::TcpSocket;
    }
    delete socket;
}

void updateClients(Server& server){
    for (auto& p : server.clients){
        ClientProfile& client = p.second;
                sf::Packet packet;
        sf::Socket::Status status;
        while ((status = client.socket->receive(packet)) == sf::Socket::Done){
                        processPacket(server, p.second, packet);
        }
                if (status == sf::Socket::Disconnected){
                        client.status = ClientProfile::OFFLINE;
            server.clientsOut.push_back(client.id);
        }
               
                while (!client.sendQueue.empty() && (status = client.socket->send(client.sendQueue.front())) == sf::Socket::Done){
                        printf("Here\n");
                        client.sendQueue.pop_front();
                }
                if (status == sf::Socket::Error){
                        client.sendQueue.pop_front();
                }
        }
}

void updateMatchConnections(MatchServer& server){
        for (auto& clientID : server.clientsOut){
                ClientProfile* client = &server.clients[clientID];
                if (client->matchID != "NONE"){
                        ///ANNOUNCE TO ONLINE PLAYERS THAT OPPONENT HAS DISCONNECTED
                        Match& match = server.matches[client->matchID];
                        if (match.players.first && match.players.first->status == ClientProfile::PLAYING){
                                sendPacket(*match.players.first, "PLAYER-DISCONNECTED");
                        }else if (match.players.second && match.players.second->status == ClientProfile::PLAYING){
                                sendPacket(*match.players.second, "PLAYER-DISCONNECTED");
                        }
                        server.playersOut.push_back(client->id);
                }
        }
       
        for (auto& clientID : server.playersOut){
                ClientProfile* client = &server.clients[clientID];
                if (client->matchID != "NONE"){
                        Match& match = server.matches[client->matchID];
                       
                        if (match.players.first == client) match.players.first = nullptr;
                        else if (match.players.second == client) match.players.second = nullptr;
                        //if (match.players.first == nullptr && match.players.second == nullptr) server.matchesOut.push_back(client->matchID);
                       
                        ///REMOVE MATCH FROM WAIT LIST, IF IN IT
                        string gameMode = match.gameMode;
                        server.waitList[gameMode].remove(client->matchID);
                       
                        ///REMOVE MATCH FROM MATCHES
                       
                        server.matchesOut.push_back(client->matchID);
                       
                        client->matchID = "NONE";
                }
        }
        server.playersOut.clear();
}

void updateMatchPlayers(MatchServer& server){
       
}

void cleanupMatches(MatchServer& server){
    for (auto& matchID : server.matchesOut){
                if (server.matches[matchID].players.first) server.matches[matchID].players.first->matchID = "NONE";
                if (server.matches[matchID].players.second) server.matches[matchID].players.second->matchID = "NONE";
                server.matches.erase(server.matches.find(matchID));
    }
        server.matchesOut.clear();
}

void cleanupServer(Server& server){
    for (auto& client : server.clientsOut){
                map<ClientProfile::ID, ClientProfile>::iterator i = server.clients.find(client);
        i->second.socket->disconnect();
        delete i->second.socket;
        server.clients.erase(i);
    }
        server.clientsOut.clear();
}

void processPacket(Server& server, ClientProfile& client, sf::Packet& packet){
    sf::String id;
        sf::Packet oriPacket = packet;
    packet >> id;
        if (id == "PONG"){
                client.pingCounter++;
                if (client.pingCounter >= client.nPings){
                        client.ping /= (double)client.pingCounter;
                        showClient(client);
                }else{
                        client.ping += client.pingClock.restart().asMilliseconds();
                        sendPing(client);
                }
        }else if (id == "FIND-MATCH"){
                string gameMode;
                packet >> gameMode;
                MatchServer& mserver = static_cast<MatchServer&>(server);
                if (mserver.waitList.find(gameMode) == mserver.waitList.end()){
                        mserver.waitList.insert(make_pair(gameMode, list<Match::ID>()));
                }
                list<Match::ID>& waitList = mserver.waitList[gameMode];
               
                if (waitList.empty()){
                        Match::ID matchID = int2str(mserver.nextID++);
                        mserver.matches.insert(make_pair(matchID, Match()));
                        Match& match = mserver.matches[matchID];
                        match.id = matchID;
                        match.players.first = &client;
                        match.players.second = nullptr;
                        match.gameMode = gameMode;
                        waitList.push_back(match.id);
                        client.matchID = matchID;
                }else{
                        Match::ID matchID = waitList.front();
                        Match& match = mserver.matches[matchID];
                        match.players.second = &client;
                        client.matchID = matchID;
                        sendPacket(*match.players.first, "MATCH-FOUND");
                        sendPacket(*match.players.first, "TURN-ENDED");
                        sendPacket(*match.players.second, "MATCH-FOUND");
                        waitList.remove(matchID);
                }
        }else if(id == "LEAVE-MATCH"){
                MatchServer& mserver = static_cast<MatchServer&>(server);
                Match& match = mserver.matches[client.matchID];
                mserver.playersOut.push_back(client.id);
                ClientProfile* opponent = (&client == match.players.first) ? match.players.second : match.players.first;
                if (opponent != nullptr) sendPacket(*opponent, oriPacket);
        }else{
                MatchServer& mserver = static_cast<MatchServer&>(server);
                Match& match = mserver.matches[client.matchID];
                ClientProfile* opponent = (&client == match.players.first) ? match.players.second : match.players.first;
                if (opponent != nullptr) sendPacket(*opponent, oriPacket);
        }
}

void showClient(ClientProfile& client){
        printf(" %15d %15s %15.0f\n", client.id, client.socket->getRemoteAddress().toString().c_str(), client.ping);
}

void pingAll(Server& server){
        sf::TcpSocket* c;
        for (auto& p : server.clients){
                p.second.ping = 0;
                p.second.pingCounter = 0;
                sendPing(p.second);
        }
}

void pingClient(Server& server, ClientProfile::ID clientID){
        ClientProfile* client = &server.clients[clientID];
        if (client){
                client->ping = 0;
                client->pingCounter = 0;
                sendPing(*client);
        }else{
                printf(" Client not found: %s\n", client->ip.toString().c_str());
        }
}

void sendPing(ClientProfile& client){
        client.pingClock.restart();
        sendPacket(client, "PING");
}

void sendPacket(ClientProfile& client, sf::Packet pkt){
        client.sendQueue.push_back(pkt);
}

void sendPacket(ClientProfile& client, sf::String id){
        sf::Packet pkt;
        pkt << id;
        client.sendQueue.push_back(pkt);
}

ClientProfile* getClientProfile(Server& server, sf::IpAddress ip){
        for (auto& p : server.clients){
                ClientProfile& client = p.second;
                if (client.ip == ip){
                        return &client;
                }
        }
        return NULL;
}

bool startServer(Server& server){
        printf(" Starting server...\n");
        server.publicIP = sf::IpAddress::getPublicAddress();
        server.privateIP = sf::IpAddress::getLocalAddress();
        if (server.publicIP == sf::IpAddress::None){
                printf(" Failed to connect to the internet!\n");
                server.online = false;
        }else{
                printf(" Public IP: %s\n", server.publicIP.toString().c_str());
                printf(" Private IP: %s\n", server.privateIP.toString().c_str());
                printf(" Trying to listen to port %d...\n", server.port);
                sf::Socket::Status status = server.listener.listen(server.port);
                if (status != sf::Socket::Done){
                        printf(" Failed to listen to port %d!\n", server.port);
                        server.online = false;
                }else{
                        server.online = true;
                        printf(" Successfully binded to port %d\n", server.port);
                        printf(" Server is now online!\n");
                }
        }
        return server.online;
}

void stopServer(Server& server){
    server.online = false;
    for (auto p : server.clients){
                ClientProfile& client = p.second;
        sf::Packet pkt;
        client.socket->disconnect();
        delete client.socket;
    }
    server.clients.clear();
    server.listener.close();
        printf(" Server is now offline!\n");
}

void processUserCommand(Server& server, const string command){
        printf("Executing command: %s\n", command.c_str());
}

void parseCommandLine(Server& server, int argc, char* argv[]){
        server.listener.setBlocking(false);
        for (int i = 0; i < argc; ++i){
                if (strcmp(argv[i], "-p") == 0 && i+1 < argc){
                        server.port = atoi(argv[i+1]);
                }
        }
}

void readUserInput(string& userCommand, bool& newCommand){
        newCommand = false;
        int nargs = 3;
        int buffSize = 255;
        char input[255];
        while(1){
                if (!newCommand){
                        cin.getline(input, 255);
                        newCommand = true;
                        userCommand = input;
                        for(int j = 0; j < buffSize; j++) input[j] = '\0';
                }
        }
}
int str2int(string s){
    return atoi(s.c_str());
}

string int2str(int n, int width){
    char arg[255];
    sprintf(arg, "%%0%dd", width);
    char c[255];
    sprintf(c, arg, n);
    return string(c);
}

string db2str(double n){
    char c[255];
    sprintf(c, "%.2f", n);
    return string(c);
}

double str2db(string s){
    return atof(s.c_str());
}
 

Server features:
- Runs on linux and windows*.
- Runs on command-line only.
- Has a user-input thread so that the user can type commands in the command-line while it is running.

*MinGW c++ compiler doesn't support std::thread yet, that's why I'm using mingw.thread.h.

It is a black-box match-making system. It does one thing and one thing only: links players who want to play the same game mode. Just like Hearthstone.

Quick Overview (aka lazy explanation):
- Player connects to server, player is now in now expected to choose a game mode.
- Once it chooses the game mode, server looks for that game mode on the wait-list.
- If no game of that game mode is on the wait-list, a new game is created and inserted in the wait-list.
- If game is found, player enters the game and the game is removed from the wait-list. Start game.

Other things yet to implement:
- Give the player the option to have his match private, so only someone who knows the match ID can connect.
- Match-making based on the player rank, but this is for much later, when I actually have a player-base lol.

I rented a linux machine at ops.mnx.io, accessed with SSH Secure Shell Client in my windows PC, compiled, ran and tested with a little tic-tac-toe client that I made. I played a few games and didn't have any problems. Specially in the first months of beta-testing, this VPS solution will be very useful.

I didn't test it with Pointless Wars yet, but in terms of multiplayer communication, tic-tac-toe and Pointless Wars are pretty much the same.

If you are a somewhat experienced network programmer and have any thoughts about any of this, please let me know.

Cheers!

65

General / Re: Problem locking framerate

« on: April 11, 2016, 06:05:13 am »

If SEV_Framelock is 60 seconds (and you converted to microseconds), allocFrameTime will be 0, because 1,000,000/60,000,000 is 0.0166 and allocFrameTime is an integer type.

Then between < allocFrameTime will always be false (except I don't know what between holds).

But why do you want to sleep anyway? Are you using threads?

66

Network / Non-blocking usage and Status handling

« on: April 10, 2016, 08:09:21 am »

Hello friends,

When I have non-blocking sf::TcpSockets updated in a loop, what are the correct ways to send and receive data?
This is how I've been doing:

Listening to connections:

    sf::Status status;
    sf::TcpSocket* socket = new sf::TcpSocket;
    while ((status = listener.accept(*socket)) == sf::Socket::Done){
        // store socket somewhere, then...
        socket = new sf::TcpSocket;
    }
    delete socket;
 

Receiving data:

    sf::Packet packet;
    sf::Socket::Status status;
    while ((status = socket->receive(packet)) == sf::Socket::Done){
        // read packet
    }
    if (status == sf::Socket::Disconnected){
        // delete socket, remove from storage
    }
 

Sending data:

    // when I want to send a packet, I don't send it right away, I store it in a queue
    peer.packetsToSend.push_back(packet);
    //...
    // further in another moment I actually send it
    if (!peer.packetsToSend.empty()){
        sf::Packet& packet = peer.packetsToSend.front();
        if ((status = socket->send(packet)) == sf::Socket::Done){
            peer.packetsToSend.pop_front();
        }
    }
 

Question #1: is the packet send queue necessary? Do I need a receive queue too?
Question #2: can the send method return sf::Socket::Disconected as well? If so, do I have to handle it or you think it's fine handling it only on receive (considering I call receive 60 times per second)?
Question #3: how to proceed if send(...) returns an error? Should I try to send the whole thing again?
Question #4: how to proceed if receive(...) returns an error?

Thanks!

67

Window / Re: Window size changing

« on: April 04, 2016, 10:49:06 pm »

On the creation method, for the sf::Style parameter:
sf::Style::Default ^ sf::Style::Resize

68

Network / Re: My generic questions about network

« on: April 04, 2016, 06:48:18 pm »

Thanks for the help man, I might open other threads with more specific questions as the troubles come. 

69

Network / Re: My generic questions about network

« on: April 04, 2016, 05:39:41 pm »

Ok, you convinced me about the importance of a central server.
What I want to do is exactly what a game like Hearthstone does.
- It is a 1v1 turn-based strategy game, the player only needs to communicate with his adversary.
- There's no lobby, the match-making is a black box.
- The data transferred is not time critical, which is why I'm using TCP/IP.
- The data transferred is very small.

So how exactly does a server like this work? This is how I imagine:
- Player connects to server.
- Server matches 2 players together.
- Players start match.
- Whenever a player has some information to send to the other player, it says to the server: "Hey, I don't know who am I playing with (his IP Adress), but whoever it is, could you please send this to him?"
- Server says: "Sure buddy! Let me just check if you are cheating."

Is that right?

And also, considering the complexity of the calculations performed by this server in this scenario, and considering that the game is moderately successful (meaning there will be thousands of games happening in any given time) is renting a machine recommended? Or is there another solution?

Thanks!

70

Network / Re: My generic questions about network

« on: April 04, 2016, 04:36:40 pm »

Question 1 : I don't think there is any problem with this (you should maybe wait for a more experienced response).

Waiting...

Question 2 : Why don't you test it yourself ?

Is laziness a valid answer?

Question 3 : Check your firewall, this is surely the problem. Take in account that you need to open the specified port into your router if it has a firewall function. Make sure to use your public IP address (since you said you were beginner, we never know ).

Yep, I was using the local address 

Question 4 : I see some problem with your idea. I don't think player should be able to know their IP address and connect directly. This can lead to severe problems, especialy in an anonymous center. Instead, player shoudl always connect to the server, and then the server send back the data to the other player (allowing you to check for the validity of the data before sending it if you want, proventing your application from cheating systems). You can check the documentation of selector since it will surely do want you want.

I understand the cheating possibility. But here is what I'm most concerned about: money. I don't even know if that's a big deal or not, I'm just trying to foresee my future, but if I make so that all the data being transferred within the players passes through a server to be processed first, I would need the server to be running in a better machine with a better internet connection, right? But if I have the server acting only as a hub where the match-making happens, I can run the server in a much cheaper machine.

Also, as far as I know, cheating will always be a possibility if the cheater is brave enough.

Thoughts?

71

Network / My generic questions about network

« on: April 04, 2016, 05:35:09 am »

Hello friends,
I don't have any problems really, I'm just looking for more experienced programmers to point me to the right direction. This is a little chat I've made using SFML + Dear ImGui. It works fine, it does what it is supposed to do, yet, I want to make sure to learn everything I can with this little program.

ChatSystem.h:

(click to show/hide)

#ifndef CHATSYSTEM_H
#define CHATSYSTEM_H

#include "System.h"
#include "imgui.h"
#include "Standard.h"
#include <SFML/Network.hpp>

class ChatSystem : public System{
    public:
        ChatSystem();
        ~ChatSystem();

        void update();
        void start(EntitiesManager* eManager, sf::RenderWindow* window, double targetUPS);

    private:
        /// EVENT HANDLERS
        void onTryAndConnect(Entity* e);
        void onDisconnectFromPeer(Entity* e);
        void onSendMessage(Entity* e);
       
        /// CALLED ON UPDATE
        void listenToPeer();
        void updateGUI();
        void updateListener();
        void updateConnection();
        void updateChatLog(string msg);
       
        /// FACILITIES
        void clearBuff(char* buff, int size);
       
        char* ipBuff;
        int ipBuffSize;
        int port;
        sf::IpAddress ipCandidate;
        sf::Clock connectionClock;
        sf::Clock updateClock;
        string logString;
       
        sf::TcpSocket peerSocket;
        sf::TcpListener listener;
       
        bool connected;
        bool connecting;

        char* chatBuff;
        int chatBuffSize;
        string chatLog;
       
};

#endif // CHATSYSTEM_H
 

ChatSystem.cpp:

(click to show/hide)

#include "ChatSystem.h"

ChatSystem::ChatSystem(){
    addSubscription(TRY_AND_CONNECT);
    addSubscription(DISCONNECT_FROM_PEER);
    addSubscription(SEND_MESSAGE);

    ipBuff == NULL;
    chatBuff == NULL;
}
void ChatSystem::start(EntitiesManager* eManager, sf::RenderWindow* window, double targetUPS){
    this->eManager = eManager;
    this->window = window;
    this->targetUPS = targetUPS;

    wWindow = window->getView().getSize().x;
    hWindow = window->getView().getSize().y;
    cxWindow = wWindow/2;
    cyWindow = hWindow/2;

    for(list<Message>::iterator i = subscripts.begin(); i != subscripts.end(); i++){
        subscribe(*i);
    }

    ipBuffSize = 20;
    ipBuff = new char[ipBuffSize];
    clearBuff(ipBuff, ipBuffSize);

    chatBuffSize = 140;
    chatBuff = new char[chatBuffSize];
    clearBuff(chatBuff, chatBuffSize);

    port = 53001;

    listener.setBlocking(false);
    if (listener.listen(port) != sf::Socket::Done){
        logString = "can't listen to port " + int2str(port) + "\n" + logString;
    }

    peerSocket.setBlocking(false);

    connected = false;
}

ChatSystem::~ChatSystem(){
    //dtor
}

void ChatSystem::update(){
    updateGUI();
    updateConnection();
    listenToPeer();
    updateListener();
}

void ChatSystem::updateGUI(){
    ImGui::Begin("TCP/IP Connection");

        ImGui::PushItemWidth(150);
        ImGui::LabelText("Your IP", "%s", sf::IpAddress::getLocalAddress().toString().c_str());
        ImGui::BeginGroup();
            ImGui::InputText("IP Address", ipBuff, ipBuffSize);
            if (ImGui::Button("Connect")) notify(TRY_AND_CONNECT);
            ImGui::SameLine();
            if (ImGui::Button("Disconnect")) notify(DISCONNECT_FROM_PEER);
        ImGui::EndGroup();

        ImGui::BeginChild("Log");
            ImGui::Text("%s\n", logString.c_str());
        ImGui::EndChild();
    ImGui::End();

    if (connected){
        ImGui::Begin("Chat");
            ImGui::BeginChild("Messages", ImVec2(200, 200));
                ImGui::Text("%s\n", chatLog.c_str());
            ImGui::EndChild();
            if (ImGui::InputText("##ChatMessage", chatBuff, chatBuffSize, ImGuiInputTextFlags_EnterReturnsTrue)){
                notify(SEND_MESSAGE);
            }
            ImGui::SameLine();
            if (ImGui::Button("Send")) notify(SEND_MESSAGE);
        ImGui::End();
    }
}

void ChatSystem::updateConnection(){
    if (connecting){
        if (peerSocket.connect(ipCandidate, port) == sf::Socket::Done){
            connected = true;
            connecting = false;
            logString = "connected to " + peerSocket.getRemoteAddress().toString() + "\n" + logString;
        }else if (peerSocket.connect(ipCandidate, port) == sf::Socket::Error){
            connected = false;
            connecting = false;
            logString = "failed to connect to " + ipCandidate.toString() + "\n" + logString;
        }else if (peerSocket.connect(ipCandidate, port) == sf::Socket::NotReady){
            logString = "socket not ready?\n" + logString;
        }
    }
}

void ChatSystem::listenToPeer(){
    if (connected){
        sf::Packet pkt;
        sf::Socket::Status sts = peerSocket.receive(pkt);
        if (sts == sf::Socket::Done){
            string msg;
            pkt >> msg;
            updateChatLog("Him: " + msg + "\n");
        }
    }
}

void ChatSystem::onSendMessage(Entity* e){
    string msg = string(chatBuff);
    if (!msg.empty()){
        sf::Packet pkt;
        pkt << msg;
        if (peerSocket.send(pkt) == sf::Socket::Done){
        }else if (peerSocket.send(pkt) == sf::Socket::Error){
            logString = "failed to send message?\n" + logString;
        }
        updateChatLog("You: " + msg + "\n");
    }
    clearBuff(chatBuff, chatBuffSize);
}

void ChatSystem::onTryAndConnect(Entity* e){
    if (connected && string(ipBuff) == peerSocket.getRemoteAddress()){
        logString = "already connected to " + string(ipBuff) + "\n" + logString;
    }
    if (connecting || connected){
        peerSocket.disconnect();
    }
    connecting = true;
    ipCandidate = string(ipBuff);
    connectionClock.restart();
}

void ChatSystem::onDisconnectFromPeer(Entity* e){
    if (connected){

        sf::Packet pkt;
        pkt << "I left...";
        if (peerSocket.send(pkt) == sf::Socket::Done){

        }else if (peerSocket.send(pkt) == sf::Socket::Error){
            logString = "failed to send message?\n" + logString;
        }

        peerSocket.disconnect();
        connected = false;
        logString = "disconnection successful...\n" + logString;
        chatLog.clear();
    }
}

void ChatSystem::updateListener(){
    if (!connected){
        if (listener.accept(peerSocket) != sf::Socket::Done){
            //logString += "failed\n";
        }else{
            connected = true;
            logString = "connected to " + peerSocket.getRemoteAddress().toString() + "\n" + logString;
        }
    }
}

void ChatSystem::clearBuff(char* buff, int size){
    for(int i = 0; i < size; i++){
        buff[i] = '\0';
    }
}

void ChatSystem::updateChatLog(string msg){
    chatLog += msg;
}
 

Keep in mind that I have 0 (zero) experience with network programming (not true since I got this chat working  ).

Question #1: I only have one socket that I use for everything, connecting, sending and receiving data. Since it is an unblocking socket, could that be a problem? What if I try to send something when it is receiving something? (the send function is not inside any loop).

Question #2: Do sockets have an internal queue or something? In unblocking mode, if I call receive (and there are things to receive) right after I call send, will it return NOT_READY on the second call if it's not done?

Question #3: I'm only able to connect with computers in LAN, why is that?

Question #4: I'm doing this as an exercise for something bigger, a turn-based strategy game. This is how I have the match-making in my mind:
- Player connects to server.
- Server is connected to all the players who are looking for match-making.
- Server says to player: "Hey, you and him are connected to me, which means you are both looking for a match. Here is his sf::IPAddress, try to connect with him."
- If successful, match starts.
- Then it's pretty much like a chat, where player send commands to each other.
Did I get it right? Is it really that simple (I should not say that, I know I'll regret)? What other concepts should I grasp?

Thanks!

72

Window / Re: Poll Event issues

« on: April 03, 2016, 05:31:14 pm »

Since I create the sf::Clock right before the pollEvent call and print and reset it right after the call, there's only one function that can be taking that long to return, am I missing something?


If the while(pollEvent) returns false for multiple frames, it doesn't matter because the clock will always reset before it is called.

The code is pretty minimal already, after your suggestion, I even commented the rest of the loop, but I don't think the rest of the code matters, because as I said, the sf::Clock is always reset.


Hmm....

73

Window / Poll Event issues

« on: April 03, 2016, 07:02:57 am »

Briefly put, the issue is this: a few seconds after having the program running, the pollEvent function in one of its iterations takes a long time (more than 1 second) to do whatever it does.

1) This lag spike happens only once in the entire execution, and it only happens some time within the first 5 seconds of execution. It will run normally after that.

2) I had this problem with SFML 2.0 and now with SFML 2.3.2.

3) I'm using sf::RenderWindow.

This is the code:

...
    while(window.isOpen()){
        sf::Event ev;
        sf::Clock cl;
        while(window.pollEvent(ev)){
            printf("ev.type = %d took %.6fs\n", ev.type, cl.restart().asSeconds());
            if (ev.type == sf::Event::Closed){
                window.close();
            }
        }
    }
...

First execution:


Second execution:


Third execution:


Detailed description: I run the executable, it opens the window and runs the code fine, display whatever it has to display, 2-5 seconds after started, the lag spike happens. It doesn't matter if I let the mouse resting on screen or off-screen, if I don't move the mouse during this first 5 seconds, the next time I move the mouse, the lag spike will happen, 100% of the times.

I'm running Windows 10 and MinGW-4.9.3 compiler, although it also happened when using Windows 8.1 and some other previous MinGW version that I can't recall.

Thanks for helping!

74

SFML projects / Re: Pointless Wars - [Turn-Based Pointless Strategy]

« on: April 01, 2016, 10:56:28 pm »

All caps bold letters with 4 exclamation points, no pressure. 

I can't say how long it will take until I release a test version, all I can say is that I'm the most interested person in finishing the game as quick as possible. I applaud people who can do it for years, but I'm not that person. That's why my game is a circle rather than a line.

Once you draw a circle, that's it. Even if you want to increase its size, you can't unless you redraw it. And if it is a nice circle, people will say "hey nice circle". Another property of a circle is that if it is missing the smallest section, it is not a circle anymore, it is a broken circle, or even worse, an imperfect line.

On the other hand, a line can always be increased in size, and the drawer is always struggling with how further should the line go. If a line is missing a section, it is still a line, and can still be appreciated as such.

My point is, even for testing, I need a complete game.

Does my game design analogy with geometry makes sense? Or more importantly, who cares? 

75

SFML projects / Re: Pointless Wars - [Turn-Based Pointless Strategy]

« on: April 01, 2016, 02:08:34 am »

Thanks, I'm glad you like what you see.
I have a bunch of animations to work on, and on the user interface. Then it will be playable.



(Fullscreen)

(click to show/hide)

I need a way to show the player which units are being targeted.
I'm using a circle, the darker the color, more resistant is the unit for the attack.
A circle highlight works fine, right?