UDP

#include "stdafx.h"
#include <SFML/System.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Network.hpp>
#include <iostream>
using namespace std;
using sf::SocketUDP;
using sf::IPAddress;
using sf::Packet;

class Input
{
public:
    Input():
      left(false), right(false), up(false), down(false)
      {}
    bool left;
    bool right;
    bool up;
    bool down;
    void update(const sf::Input& input);
};

void Input::update(const sf::Input& input)
{
    left = input.IsKeyDown(sf::Key::Left);
    right = input.IsKeyDown(sf::Key::Right);
    up = input.IsKeyDown(sf::Key::Up);
    down = input.IsKeyDown(sf::Key::Down);
}

class Player
{
public:
    Player(float x, float y, float width, float height, float xSpeed, float ySpeed):
      xPos(x), yPos(y), width(width), height(height), xSpeed(xSpeed), ySpeed(ySpeed)
      {}
    Input input;
    float xPos;
    float yPos;
    float height;
    float width;
    float xSpeed;
    float ySpeed;
    void move(float delta);
    void draw(sf::RenderWindow & app);
};

void Player::draw(sf::RenderWindow & app)
{
    glBegin(GL_QUADS);
    glVertex2f(xPos, yPos);
    glVertex2f(xPos + width, yPos);
    glVertex2f(xPos + width, yPos + height);
    glVertex2f(xPos, yPos + height);
    glEnd();
}

void Player::move(float delta)
{
    int xDir = 0;
    int yDir = 0;
    if(input.left ^ input.right)
    {
        if(input.left)
            xDir = -1;
        else
            xDir = 1;
    }
    if(input.up ^ input.down)
    {
        if(input.up)
            yDir = 1;
        else
            yDir = -1;
    }
    xPos += xDir * xSpeed * delta;
    yPos += yDir * ySpeed * delta;
}

sf::Packet& operator>>(sf::Packet& packet, Input& inp)
{
    packet >> inp.left >> inp.right >> inp.up >> inp.down;
    return packet;
}

sf::Packet& operator<<(sf::Packet& packet, const Input& inp)
{
    packet << inp.left << inp.right << inp.up << inp.down;
    return packet;
}

class Game
{
public:
    Game();
    int run();
private:
    void handleEvents();
    void update(float delta);
    void updateGameState(float delta);
    void initNetwork();
    void receiveClientInput();
    void sendClientInput();
    void sendGameState();
    void receiveAndSyncGameState();

    Player myServerPlayer;
    Player myClientPlayer;
    bool myIsServer;
    bool myIsConnected;
    sf::IPAddress myIPAddress;
    sf::SocketUDP mySocket;
    sf::RenderWindow * myWindow;
    static const unsigned short PORT;
    static const float UPDATE_RATE;
};

const unsigned short Game::PORT = 3456;
const float Game::UPDATE_RATE = 1.f/20; //TODO different rates for update and networking

Game::Game():
myServerPlayer(-1, -1, 0.2f, 0.2f, 0.35f, 0.35f),
myClientPlayer(0.5f, 0.5f, 0.2f, 0.2f, 0.35f, 0.35f),
myIsServer(false),
myWindow(0),
myIsConnected(false)
{

}

void Game::initNetwork()
{
    while(true)
    {
        cout << "Server mode(s) or Client mode (c)? ";
        string str;
        cin >> str;
        if(str == "s")
        {
            myIsServer = true;
            break;
        }
        else if(str == "c")
        {
            myIsServer = false;
            break;
        }
    }
    if(!mySocket.Bind(PORT))
    {
        cerr << "Error binding socket to port << PORT";
    }
    cout << "Enter ip: ";
    string line;
    cin >> line;
    myIPAddress = IPAddress(line);
    mySocket.SetBlocking(false);
    myIsConnected = true;
}

void Game::handleEvents()
{
    sf::Event event;
    while (myWindow->GetEvent(event))
    {
        switch(event.Type)
        {
        case sf::Event::Closed:
            myWindow->Close();
            break;
        case sf::Event::Resized:
            glViewport(0, 0, event.Size.Width, event.Size.Height);
            break;
        default:
            break;
        }
    }
}

int Game::run()
{
    initNetwork();
    myWindow = new sf::RenderWindow(sf::VideoMode(800, 600, 32), "SFML Window");
    float restTime = 0;
    while(myWindow->IsOpened())
    {
        handleEvents();
        restTime += myWindow->GetFrameTime();
        while(restTime > UPDATE_RATE)
        {
            restTime -= UPDATE_RATE;
            update(UPDATE_RATE);
        }
        glClear(GL_COLOR_BUFFER_BIT);
        myClientPlayer.draw(*myWindow);
        myServerPlayer.draw(*myWindow);
        myWindow->Display();
    }
    return 0;
}

void Game::sendClientInput()
{
    sf::Packet toSend;
    toSend << myClientPlayer.input;
    unsigned short port = PORT;
    sf::Socket::Status status = mySocket.Send(toSend, myIPAddress, port);
    switch(status)
    {
    case sf::Socket::Disconnected:
        cout << "Disconnected" << endl;
        myIsConnected = false;
        break;
    case sf::Socket::Error:
        cout << "Error sending input" << endl;
        break;
    case sf::Socket::Done:
        break;
    case sf::Socket::NotReady:
        //try again next time;
        break;
    }
}

void Game::receiveClientInput()
{
    sf::Packet toReceive;
    unsigned short port = PORT;
    sf::Socket::Status status = mySocket.Receive(toReceive, myIPAddress, port);
    switch(status)
    {
    case sf::Socket::Disconnected:
        cout << "Disconnected" << endl;
        myIsConnected = false;
        break;
    case sf::Socket::Error:
        cout << "Error receiving" << endl;
        break;
    case sf::Socket::Done:
        toReceive >> myClientPlayer.input;
        break;
    case sf::Socket::NotReady:
        //try again next time;
        break;
    }
}

void Game::sendGameState()
{
    sf::Packet toSend;
    toSend << myServerPlayer.xPos << myServerPlayer.yPos << myServerPlayer.input
        << myClientPlayer.xPos << myClientPlayer.yPos;
    sf::Socket::Status status = mySocket.Send(toSend, myIPAddress, PORT);
    switch(status)
    {
    case sf::Socket::Disconnected:
        cout << "Disconnected" << endl;
        myIsConnected = false;
        break;
    case sf::Socket::Error:
        cout << "Error sending" << endl;
        break;
    case sf::Socket::Done:
        break;
    case sf::Socket::NotReady:
        //try again next time;
        break;
    }
}

void Game::receiveAndSyncGameState()
{
    sf::Packet toReceive;
    unsigned short port = PORT;
    sf::Socket::Status status = mySocket.Receive(toReceive, myIPAddress, port);
    switch(status)
    {
    case sf::Socket::Disconnected:
        cout << "Disconnected" << endl;
        myIsConnected = false;
        break;
    case sf::Socket::Error:
        cout << "Error receiving game state" << endl;
        break;
    case sf::Socket::Done:
        toReceive >> myServerPlayer.xPos >> myServerPlayer.yPos >> myServerPlayer.input
        >> myClientPlayer.xPos >> myClientPlayer.yPos;
        //no interpolation yet
        break;
    case sf::Socket::NotReady:
        //try again next time;
        break;
    }
}

void Game::updateGameState(float delta)
{
    myClientPlayer.move(delta);
    myServerPlayer.move(delta);
}

void Game::update(float delta)
{
    if(myIsServer)
    {
        myServerPlayer.input.update(myWindow->GetInput());
        if(myIsConnected)
        {
            receiveClientInput();
            updateGameState(delta);
            sendGameState();
        }
    }
    else
    {
        myClientPlayer.input.update(myWindow->GetInput());
        if(myIsConnected)
        {
            sendClientInput();
            receiveAndSyncGameState();
        }
    }
}

int main()
{
    Game game;
    return game.run();
}