Import source code of tank net

Previously known as "Tank Reseau".

tankNet/AABBSightQuery.cpp

@@ -0,0 +1,48 @@
+#include "AABBSightQuery.h"
+
+AABBSightQuery::AABBSightQuery()
+{
+	// go
+}
+
+AABBSightQuery::~AABBSightQuery()
+{
+	// go
+}
+
+// Manimulation de la liste d'entités
+void AABBSightQuery::clearData()
+{
+	m_data.clear();
+}
+
+bool AABBSightQuery::ReportFixture( b2Fixture* fixture )
+{
+	b2Body* body( fixture->GetBody() );
+
+	b2Vec2 pos( body->GetPosition() );
+
+	Acteur* myActor( (Acteur*)body->GetUserData() );
+
+	if ( myActor->idx == TIR )
+	{
+		m_data.push_back({ pos.x, pos.y, DET_TIR, 42 });
+	}
+	else
+	{
+		m_data.push_back({ pos.x, pos.y, DET_TANK, myActor->idx });
+	}
+
+	return true;
+}
+
+// Méthode pour utiliser le réseau
+void* AABBSightQuery::getData()
+{
+	return m_data.data();
+}
+
+unsigned int AABBSightQuery::getSize()
+{
+	return m_data.size() * sizeof( Entity );
+}

tankNet/AABBSightQuery.h

@@ -0,0 +1,27 @@
+#ifndef ACTEUR_H_INCLUDED
+#define ACTEUR_H_INCLUDED
+
+#include <iostream>
+#include <Box2D/Box2D.h>
+#include "acteur.h"
+#include "description.h"
+
+class AABBSightQuery : public b2QueryCallback
+{
+public:
+	AABBSightQuery();
+	~AABBSightQuery();
+
+	// Manimulation de la liste d'entités
+	void clearData();
+	bool ReportFixture( b2Fixture* fixture );
+
+	// Méthode pour utiliser le réseau
+	void* getData();
+	unsigned int getSize();
+	
+private:
+	std::vector< Entity > m_data;
+};
+
+#endif // ACTEUR_H_INCLUDED

tankNet/Compile.sh

@@ -0,0 +1 @@
+g++ main.cpp Serveur.cpp AABBSightQuery.cpp -l Box2D -Wl,-rpath=/usr/local/lib/ -std=c++11

tankNet/Serveur.cpp

@@ -0,0 +1,90 @@
+#include "Serveur.h"
+
+Serveur::Serveur(int port, int nbrClient): m_port(port), m_nbrClient(nbrClient)
+{
+    #ifdef WIN32
+        m_erreur = WSAStartup(MAKEWORD(2,2), &m_WSAData);
+    #else
+        m_erreur = 0;
+    #endif // WIN32
+    m_sock.recsize = sizeof(m_sock.sin);
+
+    m_csock = new Sock[m_nbrClient];
+    for(int i = 0;i<m_nbrClient;i++)
+    {
+        m_csock[i].recsize = sizeof(m_csock[i].sin);
+    }
+
+}
+
+Serveur::~Serveur()
+{
+    #ifdef WIN32
+        WSACleanup();
+    #endif // WIN32
+    std::cout << "Fermeture des sockets clientes" << std::endl;
+    for(int i = 0;i<m_nbrClient;i++)
+        closesocket(m_csock[i].sock);
+    std::cout << "Fermeture de la socket serveur" << std::endl;
+    closesocket(m_sock.sock);
+    std::cout << "Fermeture du serveur termine" << std::endl;
+}
+
+
+bool Serveur::rendreUtilisable()
+{
+    if(!m_erreur)
+    {
+        m_sock.sock = socket(AF_INET, SOCK_STREAM, 0);// SOCK_STREAM pour TCP/IP, SOCK_DGRAM pour UDP/IP
+        if(m_sock.sock != INVALID_SOCKET)
+        {
+            std::cout << "La socket " << m_sock.sock << " est maintenant ouverte en mode TCP/IP" << std::endl;
+            m_sock.sin.sin_addr.s_addr = htonl(INADDR_ANY);
+            m_sock.sin.sin_family = AF_INET;
+            m_sock.sin.sin_port = htons(m_port);
+            if(bind(m_sock.sock, (SOCKADDR*)&m_sock.sin, m_sock.recsize) != SOCKET_ERROR)
+            {
+                std::cout << "Listage du port " << m_port << "..." << std::endl;
+                if(listen(m_sock.sock, 5) != SOCKET_ERROR)
+                {
+                    std::cout << "Patientez pendant que les " << m_nbrClient << " clients se connectent sur le port " << m_port << "..." << std::endl;
+                    for(int i = 0;i<m_nbrClient;i++)
+                    {
+                        m_csock[i].sock = accept(m_sock.sock, (SOCKADDR*)&m_csock[i].sin, &m_csock[i].recsize);// renvoi INVALID_SOCKET si il y a un probleme
+                        if(m_csock[i].sock != INVALID_SOCKET)
+                        {
+                            std::cout << "Un clien se connect avec la socket " << m_csock[i].sock << " de " << inet_ntoa(m_csock[i].sin.sin_addr) << " : " << htons(m_csock[i].sin.sin_port) << std::endl;
+                        }
+                        else
+                            return false;
+                    }
+                }
+                else
+                    return false;
+            }
+            else
+                return false;
+        }
+        else
+            return false;
+    }
+    else
+        return false;
+    return true;
+}
+
+void Serveur::envoyer(void* donnee, int indice, int tailleByte)
+{
+    if(tailleByte != 0)
+        send(m_csock[indice].sock, (char*)donnee, tailleByte, 0);
+    else
+        send(m_csock[indice].sock, (char*)donnee, sizeof(donnee), 0);
+}
+
+void Serveur::recevoir(void* donnee, int indice, int tailleByte)
+{
+    if(tailleByte != 0)
+        recv(m_csock[indice].sock, (char*)donnee, tailleByte, 0);
+    else
+        recv(m_csock[indice].sock, (char*)donnee, sizeof(donnee), 0);
+}

tankNet/Serveur.h

@@ -0,0 +1,55 @@
+#ifndef SERVEUR_H_INCLUDED
+#define SERVEUR_H_INCLUDED
+#ifdef WIN32
+    #include <winsock2.h>
+    typedef int socklen_t;
+#else
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <unistd.h>
+
+    #define INVALID_SOCKET -1
+    #define SOCKET_ERROR -1
+    #define closesocket(s) close (s)
+
+    typedef int SOCKET;
+    typedef struct sockaddr_in SOCKADDR_IN;
+    typedef struct sockaddr SOCKADDR;
+
+#endif // WIN32
+#include <iostream>
+
+struct Sock
+{
+    SOCKADDR_IN sin;
+    SOCKET sock;
+    socklen_t recsize;
+};
+
+class Serveur
+{
+public:
+    Serveur(int port, int nbrClient);
+    ~Serveur();
+
+    bool rendreUtilisable();
+    void envoyer(void* donnee, int indice, int tailleByte);
+    void recevoir(void* donnee, int indice, int tailleByte);
+
+
+private:
+    #ifdef WIN32
+    WSADATA m_WSAData;
+    #endif
+
+    Sock m_sock;
+    Sock *m_csock;
+
+    int m_port;
+    int m_erreur;
+    const int m_nbrClient;
+};
+
+#endif // SERVEUR_H_INCLUDED

tankNet/acteur.h

@@ -0,0 +1,11 @@
+#ifndef AABB_TANK_H_INCLUDED
+#define AABB_TANK_H_INCLUDED
+
+enum ActIdx { TANK_A = 0, TANK_B = 1, TIR = 2 } ;
+
+struct Acteur
+{
+	ActIdx idx ;
+};
+
+#endif // AABB_TANK_H_INCLUDED

tankNet/description.h

@@ -0,0 +1,27 @@
+#ifndef DESCRIPTION_H_INCLUDED
+#define DESCRIPTION_H_INCLUDED
+
+#define AABB_WIDTH 80.0f
+#define TANK_WIDTH 1.0f
+#define TIR_WIDTH 0.2f
+
+enum DetIdx { FIN = 0, DET_TANK = 1, DET_TIR = 2 } ;
+
+struct Entity
+{
+    float x ;
+    float y ;
+    DetIdx type ;
+    unsigned int id ;
+};
+
+struct Cmd
+{
+	float vx ;
+	float vy ;
+	bool tir ;
+	float tx ;
+	float ty ;
+};
+
+#endif // DESCRIPTION_H_INCLUDED

tankNet/main.cpp

@@ -0,0 +1,157 @@
+// Général
+#include <iostream>
+#include <Box2D/Box2D.h>
+
+// Locaux
+#include "Serveur.h"
+#include "description.h"
+#include "acteur.h"
+#include "AABBSightQuery.h"
+
+using namespace std;
+
+int main()
+{
+    /// Introduction
+    cout << "Lancement de Tank Réseau." << endl;
+
+    /// Démarrage Box2D
+    // Signalement
+    cout << "Chargement du monde physique." << endl;
+
+    // Monde Box2D
+    b2Vec2 gravity(0.0f, 0.0f);
+	b2World world( gravity );
+	b2Vec2 dir;
+
+	// Pramètres de simulation
+	float32 timeStep = 1.0f / 60.0f;
+	int32 velocityIterations = 8;
+	int32 positionIterations = 3;
+
+	/// Création des tanks
+	// Signalement
+	cout << "Création des tanks." << endl ;
+
+	// Définitions
+	b2BodyDef bodyDef;
+	bodyDef.type = b2_dynamicBody;
+	bodyDef.linearDamping = 10.0f ;
+	b2PolygonShape dynamicBox;
+	b2FixtureDef fixtureDef;
+	fixtureDef.shape = &dynamicBox;
+
+	// Création des paramètres
+	dynamicBox.SetAsBox( TANK_WIDTH / 2.0f , TANK_WIDTH / 2.0f  );
+
+	fixtureDef.density = 1.0f;
+	fixtureDef.friction = 0.3f;
+	fixtureDef.restitution = 0.05f;
+
+	b2Body* tank[2];
+
+	// Tank A
+	bodyDef.position.Set( 7.0f, 5.5f );
+	bodyDef.userData = new Acteur({TANK_A});
+	tank[ TANK_A ] = world.CreateBody( &bodyDef );
+	tank[ TANK_A ]->CreateFixture( &fixtureDef );
+
+	// Tank B
+	bodyDef.position.Set( 7.0f, 3.5f );
+	bodyDef.userData = new Acteur({TANK_B});
+	tank[ TANK_B ] = world.CreateBody( &bodyDef );
+	tank[ TANK_B ]->CreateFixture( &fixtureDef );
+
+	// Requeteur
+	AABBSightQuery myQuerer;
+	b2AABB aabb;
+
+	/// Initialisation du réseau
+	// Signalement
+	cout << "Création du serveur." << endl ;
+
+	// Création du serveur
+	Serveur monServeur( 25565, 2 );
+
+	// Mise en branle
+	if ( !monServeur.rendreUtilisable() )
+	{
+		cout << "Plantage du serveur !" << endl ;
+		return 1;
+	}
+
+	// Annonce des identifiants
+	unsigned int id, taille;
+
+	id = TANK_A ;
+	monServeur.envoyer( &id, id, sizeof(id) );
+
+	id = TANK_B ;
+	monServeur.envoyer( &id, id, sizeof(id) );
+
+	/// Procédure
+	// Signalement
+	cout << "Début de la boucle infinie." << endl ;
+
+	// Booléen d'arrêt
+	bool stop( false );
+
+	// Données de communication
+	Cmd dataCmd;
+	//vector<Entity> dataEntity;
+
+	// Boucle
+	while ( !stop )
+	{
+		// Recevoir les commandes de déplacement
+		for ( id = 0; id < 2; id ++ )
+		{
+			monServeur.recevoir( &dataCmd, id, sizeof( Cmd ) );
+
+			dir.Set( dataCmd.vx, dataCmd.vy );
+
+			tank[id]->ApplyLinearImpulseToCenter( dir, true );
+		}
+
+		// Calculs physiques
+		world.Step( timeStep, velocityIterations, positionIterations );
+
+		// Requêtes AABB
+		for ( id = 0; id < 2 ; id ++ )
+		{
+			myQuerer.clearData();
+
+			dir = tank[id]->GetPosition();
+
+			aabb.lowerBound.Set( dir.x - AABB_WIDTH / 2, dir.y - AABB_WIDTH / 32 * 9 );
+			aabb.upperBound.Set( dir.x + AABB_WIDTH / 2, dir.y + AABB_WIDTH / 32 * 9 );
+
+			world.QueryAABB( &myQuerer, aabb );
+
+			taille = myQuerer.getSize();
+			monServeur.envoyer( &taille, id, sizeof( unsigned int ) );
+			monServeur.envoyer( myQuerer.getData(), id, myQuerer.getSize() );
+		}
+
+		/*dataEntity.clear();
+
+		for ( id = 0; id < 2 ; id ++ )
+		{
+			dir = tank[id]->GetPosition();
+
+			dataEntity.push_back({ dir.x, dir.y, DET_TANK, id });
+		}
+
+		for ( id = 0; id < 2 ; id ++ )
+		{
+			taille = dataEntity.size();
+
+			monServeur.envoyer( &taille, id, sizeof( unsigned int ) );
+
+			monServeur.envoyer( dataEntity.data(), id, taille * sizeof( Entity ) );
+		}*/
+	}
+
+
+    return 0;
+}