Pong Network

#include <stdio.h>
#include <GL/gl.h>
#include <onidev/io.h>
#include <onidev/view.h>
#include <onidev/texture.h>
#include <onidev/object.h>
#include <onidev/mask/rectangle.h>
#include <onidev/math.h>
#include <cmath>

#include <SFML/System.hpp>
#include <SFML/Network.hpp>

sf::SocketTCP mainSocket;
sf::Mutex mutex;

enum {
    obj_none = -1,
    obj_player1,
    obj_player2,
    obj_ball,
    obj_number
};

class Player : public Object
{
    protected:
    int speed;

    public:
    static RectangleShape rect;

    Player(double x, double y, int obj) : Object(x, y - rect.height()/2, obj, &rect), speed(12) {}

    void draw() {
        rect.draw(x, y);
    }
};

RectangleShape Player::rect(0, 0, 16, 128);

// Server
class Player1 : public Player
{
    public:
    Player1(double x, double y) : Player(x, y, obj_player1) {}

    void step()
    {
        if(keyCheck(vk_up))
        {
            y -= speed;
        }
        if(keyCheck(vk_down))
        {
            y += speed;
        }
    }
};

// Client
class Player2 : public Player
{
    public:
    Player2(double x, double y) : Player(x, y, obj_player2) {}
};

class Ball : public Object
{
    bool isServer;
    float speed;
    float angle;
    double xstart, ystart;

    public:
    static RectangleShape rect;

    Ball(double x, double y, bool server)
    : Object(x, y, obj_ball, &rect), isServer(server), speed(0), angle(0), xstart(x), ystart(y)
    {
        if(isServer)
        {
            speed = 4.0;
            angle = 180-45;
        }
    }

    void reset(int dir)
    {
        x = xstart;
        y = ystart;

        speed = 4.0;
        if(dir == -1)
            angle = 180-45;
        else if(dir == 1)
            angle = 45;
    }

    void reverseAngleH()
    {
        double xx = lendirx(1, angle);
        double yy = lendiry(1, angle);
        angle = atan2(-yy, -xx) * 180.0/M_PI;
    }

    void reverseAngleV()
    {
        double xx = lendirx(1, angle);
        double yy = lendiry(1, angle);
        angle = atan2(yy, xx) * 180.0/M_PI;
    }

    void moveH(int vx)
    {
        if(vx > 0) {
            for(int i=0; i<vx; i++)
            {
                if(!placeMeeting(x+1, y, obj_player2))
                    x++;
                else
                {
                    reverseAngleH();
                    break;
                }
            }
        }
        else if(vx < 0) {
            for(int i=0; i<-vx; i++)
            {
                if(!placeMeeting(x-1, y, obj_player1))
                    x--;
                else
                {
                    reverseAngleH();
                    break;
                }
            }
        }
    }

    void moveV(int vy)
    {
        if(vy > 0) {
            for(int i=0; i<vy; i++)
            {
                if(y < 480-rect.height() && !placeMeeting(x, y+1, obj_player2))
                    y++;
                else
                {
                    reverseAngleV();
                    break;
                }
            }
        }
        else if(vy < 0) {
            for(int i=0; i<-vy; i++)
            {
                if(y >= 0 && !placeMeeting(x, y-1, obj_player2))
                    y--;
                else
                {
                    reverseAngleV();
                    break;
                }
            }
        }
    }

    void step()
    {
        if(isServer)
        {
            static double addx = 0;
            static double addy = 0;
            double movex = lendirx(speed, angle);
            double movey = lendiry(speed, angle);
            int vx = movex;
            int vy = movey;
            addx += movex - vx;
            addy += movey - vy;

            while(addx > 1) {
                vx++;
                addx--;
            }
            while(addx < -1) {
                vx--;
                addx++;
            }
            while(addy > 1) {
                vy++;
                addy--;
            }
            while(addy < -1) {
                vy--;
                addy++;
            }

            moveH(vx);
            moveV(vy);

            x += 0.01;
        }
    }

    // update clien ball
    void updatePosition(double x, double y)
    {
        if(isServer) return;

        this->x = x;
        this->y = y;
    }

    void draw() {
        rect.draw(x, y);
    }
};
RectangleShape Ball::rect(0, 0, 16, 16);


Ball * ball = 0;
Player1 * player = 0;
Player2 * player2 = 0;

void receiveServerInfos(void *)
{
    printf("Thread de reception des donnees du client en cours...\n");

    sf::SocketTCP listener;
    if(!listener.Listen(7777))
    {
        printf("Impossible d'ouvrir le port 7777.\n");
    }
    else
    {
        sf::IPAddress clientAdress;

        // Attend les connections sur le port 7777
        printf("En attente d'un joueur...");
        if(listener.Accept(mainSocket, &clientAdress) != sf::Socket::Done)
        {
            printf("Aucune connection sur le port 7777.\n");
            return;
        }
    }
    printf("Un joueur est connecte.\n");

    while(true)
    {
        sf::Lock lock(mutex);
        sf::Packet packet;

        if(mainSocket.Receive(packet) != sf::Socket::Done)
        {
            printf("Le joueur s'est deconnecte.\n");
            break;
        }
        else
        {
            packet >> player2->y;
        }
    }
}

void receiveClienInfos(void *)
{
    printf("Thread de reception des donnees du serveur en cours...\n");

    if(mainSocket.Connect(7777, sf::IPAddress::LocalHost) != sf::Socket::Done)
    {
        printf("Impossible de se connecter au serveur.\n");
        return;
    }
    printf("Vous etes connecte au serveur.\n");
    //return;

    while(true)
    {
        sf::Lock lock(mutex);
        sf::Packet packet;

        if(mainSocket.Receive(packet) != sf::Socket::Done)
        {
            printf("Erreur de reception du socket...\n");
            break;
        }
        else
        {
            packet >> ball->x >> ball->y >> player2->y;
        }
    }
}

// envoie les données de jeu au client
void sendServerInfos()
{
    sf::Packet send;
    send << ball->x << ball->y << player->y;
    mainSocket.Send(send);
}

// envoie les données de jeu du client vers le serveur
void sendClienInfos()
{
    sf::Packet send;
    send << player->y;
    mainSocket.Send(send);
}

int main()
{
    int wid=640, hei=480;
    windowCreate(wid, hei);

    setSynchronization(true);
    //initShaders();

    glEnable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0, 0, 0, 1);

    setView(0, 0, 0, wid, hei);
    setViewport(0, 0, 0, wid, hei);

    glColor3ub(255,255,255);

    initializeObjectEngine(obj_number);

    int server = true;

    printf("Choix du mode: 0=client, 1=server\n");
    scanf("%d", &server);
    if(server != 0 && server != 1)
        server = false;

    // Creation du serveur
    sf::Thread * thread = 0;

    if(server)
    {
        player = new Player1(16, 480/2);
        player2 = new Player2(640 - 32, 480/2);
        ball = new Ball(640/2, 480/2, server);

        thread = new sf::Thread(&receiveServerInfos);
        thread->Launch();
    }
    else // client
    {
        player = new Player1(640 - 32, 480/2);
        player2 = new Player2(16, 480/2);
        ball = new Ball(640/2, 480/2, server);

        thread = new sf::Thread(&receiveClienInfos);
        thread->Launch();
    }

    int score1 = 0, score2 = 0;

    while(windowIsOpen())
    {
        sf::Lock lock(mutex);

        ioHandle();

        if(keyCheck(vk_escape))
            break;

        glClear(GL_COLOR_BUFFER_BIT);

        viewUpdate(0);
        gameStep();

        // Game update
        if(server)
        {
            if(ball->x < -16)
            {
                score2++;
                ball->reset(1);
            }
            else if(ball->x > 640)
            {
                score1++;
                ball->reset(-1);
            }
            sendServerInfos();
        }
        else
        {
            sendClienInfos();
        }

        screenRefresh();
    }

    destroyAll();
    terminateObjectEngine();

    if(thread)
    {
        delete thread;
    }

    return 0;
}