Import project

Compile.sh

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

Missiles.cpp

@@ -0,0 +1,158 @@
+# include "Missiles.h"
+
+/*
+- Passer le plane pour update
+- Faire une fonction de création commune
+*/
+
+void updateMissiles( b2World &world, b2Body* target, bool foresee )
+{
+	// Variables
+	Entity* descr( nullptr );
+	bool boom(false) ;
+	std::vector<b2Body*> dustbin;
+
+    // Force de correction
+    b2Vec2 to( target->GetPosition() );
+    b2Vec2 force;
+    float d;
+
+	// Parcours des entités
+	for ( b2Body* b( world.GetBodyList() ); b; b = b->GetNext() )
+    {
+    	// Description de l'entité
+        descr = (Entity*)b->GetUserData();
+
+        // Skip entités non missile
+        if ( descr == 0x0 || descr->id == LAND || descr->id == PLANE )
+        	continue ;
+
+        // Anticipation du mouvement de la cible
+        if ( foresee )
+            to = anticipate( b, target );
+
+        // Trajectoire des missiles
+        switch ( descr->id )
+        {
+        	case INERT :
+        	case ANG :
+        		break;
+            case ARROW :
+                force =  to - b->GetPosition();
+                force.Normalize();
+                force *= 0.0005f ;
+                b->ApplyLinearImpulseToCenter( force, true );
+                break;
+            case CHARGE :
+                force =  to - b->GetPosition();
+                d = force.Length() + 0.1f;
+                force.Normalize();
+                force *= 0.0005f / d / d ;
+                b->ApplyLinearImpulseToCenter( force, true );
+                break;
+
+            default:
+                std::cout << "Missile sans protocole de guidage." << std::endl;
+                continue ;
+                break ;
+        }
+
+        // Test de collision
+    	boom = false;
+
+		for ( b2ContactEdge* ce( b->GetContactList() ); ce && !boom; ce = ce->next )
+			boom = ce->contact->IsTouching() ;
+
+		if ( boom )
+			dustbin.push_back(b);
+    }
+
+    // Destruction des missiles détruits
+    for ( unsigned int k(0); k < dustbin.size(); k++ )
+    {
+    	delete (Entity*)dustbin[k]->GetUserData() ;
+
+    	world.DestroyBody( dustbin[k] );
+    	dustbin[k] = nullptr;
+    }
+}
+
+void createInert( b2Vec2 from, b2Body* target, b2World &world, Identity missile )
+{
+	// Body
+	b2BodyDef bodyDef;
+	bodyDef.position = from;
+    bodyDef.userData = new Entity( {0.01f, missile} );
+
+    bodyDef.type = b2_dynamicBody;
+    bodyDef.linearDamping = 0.01f;
+    bodyDef.fixedRotation = true ;
+    b2Body* body = world.CreateBody(&bodyDef);
+
+    // Shape
+    b2CircleShape dynamicCircle;
+    dynamicCircle.m_radius = 0.01f ;
+    b2FixtureDef fixtureDef;
+    fixtureDef.shape = &dynamicCircle;
+
+    fixtureDef.density = 10.0f;
+    fixtureDef.friction = 0.3f;
+
+    body->CreateFixture(&fixtureDef);
+
+    // Force de départ
+    b2Vec2 to( target->GetPosition() );
+    b2Vec2 force;
+
+    switch ( missile )
+    {
+    	default :
+    		break ;
+    	case INERT :
+		    force =  to - from;
+		    force.Normalize();
+		    force *= 0.01f ;
+		    body->ApplyLinearImpulseToCenter( force, true );
+  			break ;
+    	case ANG :
+		    force = target->GetLinearVelocity();
+		    force *= (to - from).Length();
+		    force *= 0.33f ;
+		    force += to - from;
+		    force.Normalize();
+		    force *= 0.01f ;
+		    body->ApplyLinearImpulseToCenter( force, true );
+    		break;
+        case ARROW :
+        case CHARGE :
+            break;
+    }
+}
+
+b2Vec2 anticipate( b2Body* missile, b2Body* target )
+{
+    // Vecteur entre le missile et la cible
+    b2Vec2 destination( target->GetPosition() - missile->GetPosition() );
+    float32 distance( destination.Length() );
+    destination *= ( 1.0f / distance );
+
+    // Données sur le missile
+    b2Vec2 vMissile_vec( missile->GetLinearVelocity() );
+
+    // Vitesse d'approche
+    float32 incoming( b2Dot(vMissile_vec, destination) );
+    if ( incoming == 0.0f )
+        return target->GetPosition() ;
+
+    // Temps d'approche
+    float32 tau( distance / incoming );
+
+    // Données de la cible
+    b2Vec2 vPlane_vec( target->GetLinearVelocity() );
+
+    // Réponse
+    b2Vec2 rep( target->GetPosition() + tau * vPlane_vec );
+
+    // Fin du calcul
+    return rep;
+}

Missiles.h

@@ -0,0 +1,29 @@
+# ifndef MISSILES_H
+# define MISSILES_H
+
+// Basiques
+# include <iostream>
+# include <vector>
+
+// bBox2D
+# include <Box2D/Box2D.h>
+
+// Identification
+enum Identity { LAND = 0, PLANE = 1, INERT = 2, ANG = 3, ARROW = 4, CHARGE = 5 };
+
+// Entité
+struct Entity
+{
+    float rayon ;
+    Identity id ;
+};
+
+// Fonctions
+
+void updateMissiles( b2World &world, b2Body* target, bool foresee = false );
+
+void createInert( b2Vec2 from, b2Body* target, b2World &world, Identity missile );
+
+b2Vec2 anticipate( b2Body* missile, b2Body* target );
+
+# endif // MISSILES_H

main.cpp

@@ -0,0 +1,386 @@
+// Basiques
+# include <iostream>
+
+// SDL
+# include <SDL/SDL.h>
+# undef main
+# include <SDL/SDL_gfxPrimitives.h>
+
+// bBox2D
+# include <Box2D/Box2D.h>
+
+// Missiles
+# define MULTI 200.0f
+# include "Missiles.h"
+
+// Graphismes
+# define SCREEN_H 810
+# define SCREEN_W 810
+
+// Weapon
+struct Weapon
+{
+    b2Vec2 loc;
+    Identity missile;
+    Uint32 prev;
+    Uint32 del;
+};
+
+// Main
+int main(int argc, char** argv)
+{
+	/// [1] Démarrage
+    // [1.1] Démarrages SDL
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0)
+    {
+        std::cout << "Impossible d'initialiser la SDL: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    // [1.2] Préparation de fermeture
+    atexit(SDL_Quit);
+
+    // [1.3] Para-fenêtre
+    SDL_WM_SetCaption("Box2D - Balistique", 0);
+
+    /// [2] Préparation des composants SDL
+    // [2.1] Préparation de la fenêtre
+    SDL_Surface* screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
+    if ( !screen )
+    {
+        std::cout << "Bug à l'initialisation: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+    SDL_Surface* persistant = SDL_CreateRGBSurface( SDL_HWSURFACE, SCREEN_W, SCREEN_H, 32, 0, 0, 0, 0);
+    SDL_Surface* blackout = SDL_CreateRGBSurface( SDL_HWSURFACE, SCREEN_W, SCREEN_H, 32, 0, 0, 0, 0);
+    SDL_SetAlpha(blackout, SDL_SRCALPHA, 25);
+    bool superVisual( true );
+
+    // [2.2] Préparation variables
+    SDL_Rect mouse({ 400, 200, 0, 0 });
+    SDL_Rect pxpos({ 400, 200, 0, 0 });
+    SDL_Rect pxpos2({ 400, 200, 0, 0 });
+
+    // [2.4] Préparation du temps
+    Uint32 frameRate( 60 );
+    Uint32 tprev(0), twait( 1000 / frameRate );
+    bool pause( false );
+    Uint32 weap_wait(500);
+
+    // [2.5] Préparation des messages
+    std::string msg("Victor");
+    Uint32 vie(30);
+
+    /// [3] Box2D
+    // Trucs
+    B2_NOT_USED(argc);
+    B2_NOT_USED(argv);
+
+    // Construct a world object
+    b2Vec2 gravity(0.0f, 0.0f);
+    b2World world(gravity);
+
+    // Define the dynamic body container
+    std::vector<b2Body*> deadBodies;
+
+    // Simulation settings
+    float32 timeStep = 1.0f / frameRate;
+    int32 velocityIterations = 8;
+    int32 positionIterations = 3;
+
+    // Variables
+    b2Vec2 position, force;
+    float32 angle;
+    Entity* descr( nullptr );
+
+	// Define the edge body
+	b2BodyDef bodyDef;
+	bodyDef.position.Set(0.0f, 0.0f);
+    bodyDef.userData = new Entity( {0.0f, LAND} );
+	b2Body* areaBody = world.CreateBody(&bodyDef);
+
+	b2Vec2 vs[4];
+	float32 areah( (float32)screen->h / MULTI );
+	float32 areaw( (float32)screen->w / MULTI );
+	vs[0].Set( 0.0f, 0.0f );
+	vs[1].Set( 0.0f, areah );
+	vs[2].Set( areaw, areah );
+	vs[3].Set( areaw, 0.0f );
+	b2ChainShape chain;
+	chain.CreateLoop(vs, 4);
+	areaBody->CreateFixture(&chain, 0.0f);
+
+    // Define the plane body
+    bodyDef.type = b2_dynamicBody;
+    bodyDef.position.Set(areaw * 0.5f, areaw * 0.5f );
+    bodyDef.userData = new Entity( {0.05f, PLANE} );
+    bodyDef.linearDamping = 0.01f;
+    bodyDef.fixedRotation = true ;
+    b2Body* plane = world.CreateBody(&bodyDef);
+
+    b2CircleShape dynamicCircle;
+    dynamicCircle.m_radius = 0.05f ;
+    b2FixtureDef fixtureDef;
+    fixtureDef.shape = &dynamicCircle;
+
+    fixtureDef.density = 10.0f;
+    fixtureDef.friction = 0.3f;
+    fixtureDef.restitution = 0.5f;
+
+    plane->CreateFixture(&fixtureDef);
+
+    // Define the tourel list
+    std::vector<Weapon> tourelle;
+    Identity missile(INERT);
+    Uint32 weap_color[8] = { 0xffffffff,
+                             0xffffffff, 
+                             0xff0000ff, 
+                             0x00ff00ff, 
+                             0x0000ffff, 
+                             0xffff00ff, 
+                             0xff00ffff, 
+                             0x00ffffff };
+
+    // Define thruster
+    bool thrust_up(false);
+    bool thrust_down(false);
+    bool thrust_left(false);
+    bool thrust_right(false);
+    bool foresee(false);
+
+    /// [4] Boucle principale
+    bool done = false;
+    SDL_Event event;
+    while (!done)
+    {
+        // [4.1] Gestion évènements
+        while (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+            case SDL_QUIT:
+                done = true;
+                break;
+            case SDL_KEYDOWN:
+            	switch( event.key.keysym.sym )
+            	{
+            	case SDLK_ESCAPE :
+            		done = true;
+            		break;
+            	case SDLK_BACKSPACE :
+                    std::cout << std::endl << "Destruction des tourelles." << std::endl << std::endl;
+                    tourelle.clear();
+            		break;
+            	case SDLK_SPACE :
+                	pause = !pause ;
+                	break;
+                case SDLK_KP1:
+                    std::cout << "Tir basique." << std::endl;
+                    missile = INERT ;
+                    break;
+                case SDLK_KP2:
+                    std::cout << "Tir d'anticipation rectiligne." << std::endl;
+                    missile = ANG ;
+                    break;
+                case SDLK_KP3:
+                    std::cout << "Missile d'accélération linéaire." << std::endl;
+                    missile = ARROW ;
+                    break;
+                case SDLK_KP4:
+                    std::cout << "Missile d'accélération électrique (1/r^2)." << std::endl;
+                    missile = CHARGE ;
+                    break;
+                case SDLK_a :
+                    superVisual = !superVisual;
+                    std::cout << "Super visual : " << superVisual << std::endl;
+                    break;
+                case SDLK_z :
+                    weap_wait += 25 ;
+                    std::cout << "weap_wait += 25" << std::endl;
+                    break;
+                case SDLK_s :
+                    weap_wait -= 25 ;
+                    std::cout << "weap_wait -= 25" << std::endl;
+                    break;
+                case SDLK_e :
+                    vie = 30;
+                    std::cout << "vie = 30" << std::endl;
+                    break;
+                case SDLK_r :
+                    foresee = !foresee;
+                    if ( foresee )
+                        std::cout << "Anticipation activée." << std::endl;
+                    else
+                        std::cout << "Les missiles auront du retard." << std::endl;
+                    break;
+                case SDLK_LEFT :
+                    thrust_left = true ;
+                    break;
+                case SDLK_RIGHT :
+                    thrust_right = true ;
+                    break;
+                case SDLK_UP :
+                    thrust_up = true ;
+                    break;
+                case SDLK_DOWN :
+                    thrust_down = true ;
+                    break;
+            	}
+                break;
+            case SDL_KEYUP:
+                switch( event.key.keysym.sym )
+                {
+                case SDLK_LEFT :
+                    thrust_left = false ;
+                    break;
+                case SDLK_RIGHT :
+                    thrust_right = false ;
+                    break;
+                case SDLK_UP :
+                    thrust_up = false ;
+                    break;
+                case SDLK_DOWN :
+                    thrust_down = false ;
+                    break;
+                }
+                break;
+            case SDL_MOUSEMOTION:
+                mouse.x = event.motion.x ;
+                mouse.y = event.motion.y ;
+                break;
+            case SDL_MOUSEBUTTONDOWN:
+                std::cout << "Création tourelle." << std::endl;
+                tourelle.push_back({b2Vec2( (float32)mouse.x/MULTI, (float32)mouse.y/MULTI),
+                                    missile,
+                                    SDL_GetTicks(),
+                                    weap_wait});
+                break;
+            case SDL_MOUSEBUTTONUP:
+                break;
+            } // end switch event type
+        } // end of message processing
+
+        // [4.2] Calculs
+        // Reset graphismes
+        if ( superVisual ) {
+            SDL_BlitSurface( blackout, 0x0, persistant, 0x0 );
+            SDL_BlitSurface( persistant, 0x0, screen, 0x0 );
+        }
+        else {
+            SDL_FillRect( screen, 0x0, 0x00000000 );
+        }
+
+        // Tirs tourelle
+        for ( unsigned int k(0); k < tourelle.size() && vie > 0; k++ )
+        {
+            if ( SDL_GetTicks() - tourelle[k].prev > tourelle[k].del )
+            {
+                tourelle[k].prev = SDL_GetTicks();
+                createInert( tourelle[k].loc, plane, world, tourelle[k].missile );
+            } 
+        }
+
+        // Déplacement
+        if ( vie > 0 )
+        {
+            force = b2Vec2_zero;
+
+            if ( thrust_left )
+                force.x -= 1.0f;
+            if ( thrust_right )
+                force.x += 1.0f;
+            if ( thrust_up )
+                force.y -= 1.0f;
+            if ( thrust_down )
+                force.y += 1.0f;
+
+            plane->ApplyLinearImpulseToCenter( 0.004f * force, true );
+        }
+
+        // It is generally best to keep the time step and iterations fixed.
+        if ( !pause )
+			world.Step(timeStep, velocityIterations, positionIterations);
+
+        // Contact sur plane
+        position = plane->GetPosition();
+        pxpos.x = position.x * MULTI ;
+        pxpos.y = position.y * MULTI ;
+
+        for ( b2ContactEdge* ce( plane->GetContactList() ); ce && vie > 0; ce = ce->next )
+            if ( ce->contact->IsTouching() )
+            {
+                vie -- ;
+                filledCircleRGBA( screen, pxpos.x, pxpos.y, 13, 255, 255, 255, 255 );
+                circleRGBA( persistant, pxpos.x, pxpos.y, 13, 255, 128, 0, 255 );
+            }
+
+        // Mise à jour des trajectoires
+        updateMissiles( world, plane, foresee );
+
+        // [4.3] Dessin des composants
+        for ( b2Body* b( world.GetBodyList() ); b; b = b->GetNext() )
+        {
+            // Besoin d'afficher ?
+            descr = (Entity*)b->GetUserData();
+
+            if ( descr == nullptr || descr->id == LAND )
+                continue ;
+
+            // Affichage classique
+            position = b->GetPosition();
+
+            pxpos.x = position.x * MULTI ;
+            pxpos.y = position.y * MULTI ;
+
+            circleColor( screen, pxpos.x, pxpos.y, descr->rayon * MULTI, 0xddddddff );
+
+            // Affichage persistant
+            position -= timeStep * b->GetLinearVelocity();
+
+            pxpos2.x = position.x * MULTI ;
+            pxpos2.y = position.y * MULTI ;
+
+            lineColor( persistant, pxpos.x, pxpos.y, pxpos2.x, pxpos2.y, weap_color[descr->id] );
+            lineColor( screen, pxpos.x, pxpos.y, pxpos2.x, pxpos2.y, weap_color[descr->id] );
+        }
+        for ( unsigned int k(0); k < tourelle.size(); k++ )
+        {
+            circleColor( screen, tourelle[k].loc.x * MULTI, tourelle[k].loc.y * MULTI, 0.05f * MULTI, weap_color[tourelle[k].missile] );
+        }
+
+        // Messages
+        msg = "Ratio CPU : " ;
+        msg += std::to_string( ((float)SDL_GetTicks() - tprev) * 100 / twait ) ;
+        msg += " pourcents." ;
+        stringRGBA( screen, 16, 16, msg.c_str(), 0, 255, 0, 255 );
+
+        msg = "Vie : " ;
+        msg += std::to_string( vie ) ;
+        msg += " | " ;
+        for ( unsigned int i(0); i < vie ; i ++ )
+            msg += "#" ;
+        for ( unsigned int i(vie); i < 30 ; i ++ )
+            msg += "-" ;
+        stringRGBA( screen, 16, 25, msg.c_str(), 0, 255, 0, 255 );
+
+        msg = "Delai tourelle : " ;
+        msg += std::to_string( weap_wait ) ;
+        msg += " ms." ;
+        stringRGBA( screen, 16, 34, msg.c_str(), 0, 255, 0, 255 );
+
+        SDL_Flip(screen);
+
+        // [4.4] Temps
+        while( SDL_GetTicks() - tprev < twait )
+        {
+        	if ( SDL_GetTicks() - tprev < twait/2 )
+        		SDL_Delay( twait/3 );
+        }
+        tprev = SDL_GetTicks();
+
+    } //fin bcl principale
+
+    ///[5] Destruction des composants
+
+	return 0;
+}