Import old non versioned project

BoundyDriver.cbp

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="BoundyDriver" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/BoundyDriver" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+					<Add directory="Cars" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/BoundyDriver" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="0" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+					<Add directory="Cars" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-std=c++11" />
+			<Add option="-Wall" />
+			<Add option="`sdl-config --cflags`" />
+		</Compiler>
+		<Linker>
+			<Add option="`sdl-config --libs`" />
+			<Add library="SDLmain" />
+			<Add library="SDL_image" />
+			<Add library="SDL_gfx" />
+			<Add library="SDL" />
+			<Add library="Box2D" />
+		</Linker>
+		<Unit filename="Car.cpp" />
+		<Unit filename="Car.h" />
+		<Unit filename="Cars/PickUp.cpp" />
+		<Unit filename="Cars/PickUp.h" />
+		<Unit filename="Cars/PinkLiner.cpp" />
+		<Unit filename="Cars/PinkLiner.h" />
+		<Unit filename="Terrain.cpp" />
+		<Unit filename="Terrain.h" />
+		<Unit filename="main.cpp" />
+		<Extensions>
+			<code_completion />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

BoundyDriver.depend

@@ -0,0 +1,56 @@
+# depslib dependency file v1.0
+1493564105 source:/home/jovian/Programmes/Box2D/BoundyDriver/Car.cpp
+	"Car.h"
+
+1493564108 /home/jovian/Programmes/Box2D/BoundyDriver/Car.h
+	<iostream>
+	<cmath>
+	<vector>
+	<ctime>
+	<cstdlib>
+	<SDL/SDL.h>
+	<SDL/SDL_rotozoom.h>
+	<SDL/SDL_gfxPrimitives.h>
+	<Box2D/Box2D.h>
+
+1493561267 source:/home/jovian/Programmes/Box2D/BoundyDriver/main.cpp
+	<iostream>
+	<vector>
+	<string>
+	<ctime>
+	<cstdlib>
+	<SDL/SDL.h>
+	<SDL/SDL_rotozoom.h>
+	<SDL/SDL_gfxPrimitives.h>
+	<Box2D/Box2D.h>
+	"Cars/PickUp.h"
+	"Cars/PinkLiner.h"
+	"Terrain.h"
+
+1493558064 /home/jovian/Programmes/Box2D/BoundyDriver/Terrain.h
+	<iostream>
+	<fstream>
+	<vector>
+	<cmath>
+	<ctime>
+	<cstdlib>
+	<SDL/SDL.h>
+	<SDL/SDL_gfxPrimitives.h>
+	<SDL/SDL_image.h>
+	<Box2D/Box2D.h>
+
+1493561802 source:/home/jovian/Programmes/Box2D/BoundyDriver/Terrain.cpp
+	"Terrain.h"
+
+1493560050 source:/home/jovian/Programmes/Box2D/BoundyDriver/Cars/PickUp.cpp
+	"PickUp.h"
+
+1485104332 /home/jovian/Programmes/Box2D/BoundyDriver/Cars/PickUp.h
+	"../Car.h"
+
+1485106689 /home/jovian/Programmes/Box2D/BoundyDriver/Cars/PinkLiner.h
+	"../Car.h"
+
+1493559965 source:/home/jovian/Programmes/Box2D/BoundyDriver/Cars/PinkLiner.cpp
+	"PinkLiner.h"
+

BoundyDriver.layout

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_layout_file>
+	<ActiveTarget name="Release" />
+	<File name="main.cpp" open="1" top="1" tabpos="9" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="5404" topLine="179" />
+		</Cursor>
+	</File>
+	<File name="Terrain.h" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="323" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="Terrain.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="3022" topLine="146" />
+		</Cursor>
+	</File>
+	<File name="Car.cpp" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="2642" topLine="114" />
+		</Cursor>
+	</File>
+	<File name="Cars/PickUp.h" open="1" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="256" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="Car.h" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="793" topLine="17" />
+		</Cursor>
+	</File>
+	<File name="Cars/PinkLiner.h" open="1" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="282" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="Cars/PickUp.cpp" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="615" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="Cars/PinkLiner.cpp" open="1" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="387" topLine="0" />
+		</Cursor>
+	</File>
+</CodeBlocks_layout_file>

Car.cpp

@@ -0,0 +1,293 @@
+# include "Car.h"
+
+Car::Car()
+:m_imgCar( 0x0 ), m_imgWheel( 0x0 ),
+m_bodyCar( 0x0 ),
+m_cmd( FREE ),
+m_currentTorque( 0.0f ), m_currentSpeed( 0.0f ), m_sense( 1.0f ), m_latence( 40.0f ),
+m_goTorque( 0.9f ), m_minTorque( 0.0025f ), m_maxSpeed( 60.0f )
+{
+	// Constructeur
+	m_currentTorque = m_minTorque ;
+	m_currentSpeed = 0.0f ;
+}
+
+Car::~Car()
+{
+	if ( !m_imgCar )
+		SDL_FreeSurface( m_imgCar );
+
+	if ( !m_imgWheel )
+		SDL_FreeSurface( m_imgWheel );
+}
+
+void Car::destroy( b2World &world )
+{
+    /// Détruire les liaisons
+    // Les moteurs
+    while ( !m_motorAxe.empty() )
+    {
+        world.DestroyJoint( m_motorAxe.back() );
+        m_motorAxe.back() = nullptr;
+        m_motorAxe.pop_back();
+    }
+
+    // Les roues libres
+    while ( !m_fwdAxe.empty() )
+    {
+        world.DestroyJoint( m_fwdAxe.back() );
+        m_fwdAxe.back() = nullptr;
+        m_fwdAxe.pop_back();
+    }
+
+    /// Détruire les entités
+    // Les roues
+    while ( !m_bodyWheel.empty() )
+    {
+        world.DestroyBody( m_bodyWheel.back() );
+        m_bodyWheel.back() = nullptr;
+        m_bodyWheel.pop_back();
+    }
+
+    // Le carénage
+    if ( m_bodyCar )
+        world.DestroyBody( m_bodyCar );
+    m_bodyCar = nullptr;
+}
+
+void Car::drive( command cmd )
+{
+     // Commande
+	m_cmd = cmd ;
+
+	// Actions
+	if ( m_cmd == FREE )
+	{
+		m_currentSpeed = 0.0f ;
+		m_currentTorque = m_minTorque ;
+	}
+
+	else if ( m_cmd == BREAK )
+	{
+		m_currentSpeed = 0.0f ;
+		m_currentTorque = m_goTorque ;
+	}
+
+	else if ( m_cmd == GO )
+	{
+        m_sense = -1.0f ;
+		m_currentSpeed = m_maxSpeed ;
+		m_currentTorque = m_goTorque / 20.0f ;
+	}
+
+	else if ( m_cmd == REVERSE )
+	{
+        m_sense = 0.5f ;
+		m_currentSpeed = m_maxSpeed ;
+		m_currentTorque = m_goTorque / 20.0f ;
+	}
+}
+
+void Car::jump( float32 correction )
+{
+     // Jump
+     b2Vec2 spring;
+     spring.Set( 0.0f, -1.7f );
+
+     m_bodyCar->ApplyLinearImpulseToCenter( spring, true );
+
+     // Correction
+     m_bodyCar->ApplyAngularImpulse( - m_bodyCar->GetAngle() * correction, true );
+}
+
+void Car::spin( float32 tq )
+{
+    // Couple sur le carénage
+    m_bodyCar->ApplyAngularImpulse( tq, true );
+}
+
+void Car::update()
+{
+	// Update state
+     if ( m_cmd == GO || m_cmd == REVERSE )
+	{
+		m_currentTorque = ( m_latence * m_currentTorque + m_goTorque ) / ( m_latence + 1.0f ) ;
+	}
+
+	// Update motor
+	for ( unsigned int i(0); i < m_motorAxe.size() ; i++ )
+	{
+          m_motorAxe[i]->SetMotorSpeed( m_sense * m_currentSpeed );
+          m_motorAxe[i]->SetMaxMotorTorque( m_currentTorque );
+	}
+}
+
+b2Vec2 Car::GetPosition()
+{
+	return m_bodyCar->GetPosition();
+}
+
+b2Vec2 Car::GetVelocity()
+{
+	return m_bodyCar->GetLinearVelocity();
+}
+
+float32 Car::GetTorque()
+{
+	return m_currentTorque;
+}
+
+float32 Car::GetSpeed()
+{
+	return m_currentSpeed;
+}
+
+bool Car::GetIsOnGround()
+{
+    bool rep( false );
+
+    for ( b2ContactEdge* ce( m_bodyWheel.front()->GetContactList() ); ce && !rep; ce = ce->next )
+        rep = ce->contact->IsTouching() ;
+
+    return rep;
+}
+
+void Car::createMotorWheel( b2World &world, b2Vec2 rel, float32 friction, float32 density )
+{
+     // Vérifie la présence d'image
+     if ( m_imgWheel == 0x0 )
+     {
+          std::cout << "Car::createMotorWheel > pas d'image." << std::endl ;
+          return ;
+     }
+
+     // Vérifie la présence de carénage
+     if ( m_bodyCar == 0x0 )
+     {
+          std::cout << "Car::createMotorWheel > pas de carénage." << std::endl ;
+          return ;
+     }
+
+     // Dimensions
+     float32 rwheel;
+     rwheel = (float32)m_imgWheel->h / MULTI / 2 ;
+
+     // Définition body
+     b2BodyDef bodyDef;
+     b2CircleShape dynamicCircle;
+     b2FixtureDef fixtureDef;
+     bodyDef.type = b2_dynamicBody;
+
+     // Roue moteur
+     bodyDef.userData = m_imgWheel ;
+     bodyDef.position = m_bodyCar->GetPosition() + rel ;
+
+     dynamicCircle.m_radius = rwheel ;
+
+     fixtureDef.shape = &dynamicCircle;
+     fixtureDef.density = density;
+     fixtureDef.friction = friction;
+
+     m_bodyWheel.push_back( world.CreateBody(&bodyDef) );
+     m_bodyWheel.back()->CreateFixture(&fixtureDef);
+
+     // Création pivot arrière
+     b2RevoluteJointDef myJointDef;
+     myJointDef.collideConnected = false ;
+
+     myJointDef.Initialize( m_bodyWheel.back(), m_bodyCar, m_bodyWheel.back()->GetPosition() );
+
+     myJointDef.maxMotorTorque = 0.05f;
+     myJointDef.motorSpeed = 0.0f;
+     myJointDef.enableMotor = true;
+
+     m_motorAxe.push_back( (b2RevoluteJoint*)world.CreateJoint(&myJointDef) );
+
+     // Fin
+     return ;
+}
+
+void Car::createFreeWheel( b2World &world, b2Vec2 rel, float32 friction, float32 density )
+{
+     // Vérifie la présence d'image
+     if ( m_imgWheel == 0x0 )
+     {
+          std::cout << "Car::createFreeWheel > pas d'image." << std::endl ;
+          return ;
+     }
+
+     // Vérifie la présence de carénage
+     if ( m_bodyCar == 0x0 )
+     {
+          std::cout << "Car::createFreeWheel > pas de carénage." << std::endl ;
+          return ;
+     }
+
+     // Dimensions
+     float32 rwheel;
+     rwheel = (float32)m_imgWheel->h / MULTI / 2 ;
+
+     // Définition body
+     b2BodyDef bodyDef;
+     b2CircleShape dynamicCircle;
+     b2FixtureDef fixtureDef;
+     bodyDef.type = b2_dynamicBody;
+
+     // Roue avant
+     bodyDef.userData = m_imgWheel ;
+     bodyDef.position = m_bodyCar->GetPosition() + rel ;
+
+     dynamicCircle.m_radius = rwheel ;
+
+     fixtureDef.shape = &dynamicCircle;
+     fixtureDef.density = density;
+     fixtureDef.friction = friction;
+
+     m_bodyWheel.push_back( world.CreateBody(&bodyDef) );
+     m_bodyWheel.back()->CreateFixture(&fixtureDef);
+
+     // Création pivot avant
+     b2RevoluteJointDef myJointDef;
+     myJointDef.collideConnected = false ;
+
+     myJointDef.Initialize( m_bodyWheel.back(), m_bodyCar, m_bodyWheel.back()->GetPosition() );
+
+     m_fwdAxe.push_back( (b2RevoluteJoint*)world.CreateJoint(&myJointDef) );
+
+     // Fin
+     return ;
+}
+
+void Car::createCarenage( b2World &world, float32 x, float32 y, float32 friction, float32 density )
+{
+     // Vérifie si présence de carénage
+     if ( m_bodyCar != 0x0 )
+     {
+          world.DestroyBody( m_bodyCar );
+          m_bodyCar = 0x0 ;
+     }
+
+     // Dimensions
+     float32 wtruck, htruck ;
+     wtruck = (float32)m_imgCar->w / MULTI / 2 ;
+     htruck = (float32)m_imgCar->h / MULTI / 2 ;
+
+     // Définition body
+     b2BodyDef bodyDef;
+     b2PolygonShape dynamicBox;
+     b2FixtureDef fixtureDef;
+     bodyDef.type = b2_dynamicBody;
+
+     // Carrosserie
+     bodyDef.userData = m_imgCar ;
+     bodyDef.position.Set( x, y );
+
+     dynamicBox.SetAsBox( wtruck, htruck );
+
+     fixtureDef.shape = &dynamicBox;
+     fixtureDef.density = density;
+     fixtureDef.friction = friction;
+
+     m_bodyCar = world.CreateBody( &bodyDef );
+     m_bodyCar->CreateFixture( &fixtureDef );
+}

Car.h

@@ -0,0 +1,77 @@
+# ifndef CAR_HEADER_FILE
+# define CAR_HEADER_FILE
+
+// Basiques
+# include <iostream>
+# include <cmath>
+# include <vector>
+
+// Random
+# include <ctime>
+# include <cstdlib>
+
+// SDL
+# include <SDL/SDL.h>
+# undef main
+# include <SDL/SDL_rotozoom.h>
+# include <SDL/SDL_gfxPrimitives.h>
+
+// bBox2D
+# include <Box2D/Box2D.h>
+# define MULTI 100.0f
+
+enum command { FREE, BREAK, GO, REVERSE };
+
+class Car
+{
+/// Méthodes
+public:
+	Car();
+	virtual ~Car();
+
+	void destroy( b2World &world );
+	virtual void init( b2World &world, float32 x, float32 y, float32 angle = 0.0f ) = 0;
+
+	void drive( command cmd );
+	void jump( float32 correction = 0.0f );
+	void spin( float32 tq );
+	virtual void update();
+
+	b2Vec2 GetPosition();
+	b2Vec2 GetVelocity();
+	float32 GetTorque();
+	float32 GetSpeed();
+	bool GetIsOnGround();
+
+protected:
+	void createMotorWheel( b2World &world, b2Vec2 rel, float32 friction = 10.0f, float32 density = 0.25f );
+	void createFreeWheel( b2World &world, b2Vec2 rel, float32 friction = 10.0f, float32 density = 0.25f );
+	void createCarenage( b2World &world, float32 x, float32 y, float32 friction = 1.0f, float32 density = 1.0f );
+
+/// Attributs
+protected:
+	SDL_Surface* m_imgCar ;
+	SDL_Surface* m_imgWheel ;
+
+private:
+	b2Body* m_bodyCar ;
+	std::vector< b2Body* > m_bodyWheel ;
+
+	std::vector< b2RevoluteJoint* > m_motorAxe ;
+	std::vector< b2RevoluteJoint* > m_fwdAxe ;
+
+
+	command m_cmd ;
+
+	float32 m_currentTorque ;
+	float32 m_currentSpeed ;
+	float32 m_sense ;
+	float32 m_latence ;
+
+	float32 m_goTorque ;
+	float32 m_minTorque ;
+	float32 m_maxSpeed ;
+};
+
+
+# endif // CAR_HEADER_FILE

Cars/PickUp.cpp

@@ -0,0 +1,42 @@
+#include "PickUp.h"
+
+PickUp::PickUp()
+{
+     //ctor
+}
+
+PickUp::~PickUp()
+{
+     //dtor
+}
+
+void PickUp::init( b2World &world, float32 x, float32 y, float32 angle )
+{
+	// Images
+	if ( m_imgCar == nullptr )
+	{
+          m_imgCar = SDL_LoadBMP("Textures/PickUp.bmp");
+          SDL_SetColorKey( m_imgCar, SDL_SRCCOLORKEY, SDL_MapRGBA( m_imgCar->format, 0, 0, 0, 255 ) );
+     }
+     if ( m_imgWheel == nullptr )
+     {
+          m_imgWheel = SDL_LoadBMP("Textures/PickUpWheel.bmp");
+          SDL_SetColorKey( m_imgWheel, SDL_SRCCOLORKEY, SDL_MapRGBA( m_imgWheel->format, 0, 0, 0, 255 ) );
+     }
+
+     // Propre !
+     destroy( world );
+
+     // Eléments
+     createCarenage( world, x, y );
+
+     b2Vec2 rel ;
+     rel.Set( -0.3f, 0.25f );
+     createMotorWheel( world, rel );
+
+     rel.Set( 0.25f, 0.25f );
+     createFreeWheel( world, rel );
+
+     // Fin
+     return ;
+}

Cars/PickUp.h

@@ -0,0 +1,21 @@
+# ifndef PICKUP_H
+# define PICKUP_H
+
+# include "../Car.h"
+
+
+class PickUp : public Car
+{
+/// Méthodes
+     public:
+          PickUp();
+          virtual ~PickUp();
+
+          virtual void init( b2World &world, float32 x, float32 y, float32 angle = 0.0f );
+
+/// Attributs
+     protected:
+     private:
+};
+
+# endif // PICKUP_H

Cars/PinkLiner.cpp

@@ -0,0 +1,43 @@
+#include "PinkLiner.h"
+
+PinkLiner::PinkLiner()
+{
+     //ctor
+}
+
+PinkLiner::~PinkLiner()
+{
+     //dtor
+}
+
+void PinkLiner::init( b2World &world, float32 x, float32 y, float32 angle )
+{
+	// Images
+	if ( m_imgCar == nullptr )
+	{
+          m_imgCar = SDL_LoadBMP("Textures/LinerRose.bmp");
+          SDL_SetColorKey( m_imgCar, SDL_SRCCOLORKEY, SDL_MapRGBA( m_imgCar->format, 0, 0, 0, 255 ) );
+	}
+
+     if ( m_imgWheel == nullptr )
+     {
+          m_imgWheel = SDL_LoadBMP("Textures/LinerWheelRose.bmp");
+          SDL_SetColorKey( m_imgWheel, SDL_SRCCOLORKEY, SDL_MapRGBA( m_imgWheel->format, 0, 0, 0, 255 ) );
+     }
+
+     // Être propre sur soi
+     destroy( world );
+
+     // Eléments
+     createCarenage( world, x, y, 0.5f, 0.2f );
+
+     b2Vec2 rel ;
+     rel.Set( -0.5f, 0.1f );
+     createMotorWheel( world, rel, 10.0f, 0.1f );
+
+     rel.Set( 0.5f, 0.1f );
+     createFreeWheel( world, rel, 10.0f, 0.1f );
+
+     // Fin
+     return ;
+}

Cars/PinkLiner.h

@@ -0,0 +1,21 @@
+#ifndef PINKLINER_H
+#define PINKLINER_H
+
+#include "../Car.h"
+
+
+class PinkLiner : public Car
+{
+/// Méthodes
+     public:
+          PinkLiner();
+          virtual ~PinkLiner();
+
+          virtual void init( b2World &world, float32 x, float32 y, float32 angle = 0.0f );
+
+/// Attributs
+     protected:
+     private:
+};
+
+#endif // PINKLINER_H

Makefile

@@ -0,0 +1,25 @@
+# Flags:
+#  -g    adds debugging information to the executable file
+#  -Wall turns on most, but not all, compiler warnings
+FLAGS = -g -Wall -std=c++11 -O
+
+# Libraries :
+# Box2D -Wl,-rpath=/usr/local/lib/
+# SDL
+# SDL_gfx
+# SDL_image
+LIBS = -l Box2D -Wl,-rpath=/usr/local/lib/ -l SDL -l SDL_gfx -l SDL_image
+
+# Name of output:
+NAME = a.out
+
+# Names of cpp files:
+FILES = main.cpp Terrain.cpp Cars/PickUp.cpp Cars/PinkLiner.cpp Car.cpp SnapFile.cpp
+
+default: build
+
+build: $(FILES)
+	g++ $(FLAGS) $(FILES) $(LIBS) -o $(NAME)
+
+clean:
+	$(RM) $(NAME)

Niveaux/2Jumps.lvl

@@ -0,0 +1,82 @@
+0 -1
+0 0
+6 0
+7.96 0.11
+8.57 0.32
+9.83 0.8
+10.64 1.19
+13.11 1.42
+13.39 0.46
+14.92 0.81
+15.95 1.22
+17.4 1.96
+18.27 2.11
+19.26 2.07
+19.95 0.82
+21.44 0.7
+22.82 0.98
+23.49 1.17
+23.92 3.47
+24.63 3.5
+24.8 2.23
+25.97 2.83
+27.16 3.78
+28.02 3.76
+29.42 3.76
+31.21 3.92
+37.61 2.42
+44 3.06
+49.46 5.86
+56.84 7.66
+62.38 7.98
+64.5 7.8
+68.38 6.24
+70.24 4.04
+72.1 1.54
+75.9 30.28
+91.56 30.9
+101.46 30.56
+117.94 29.42
+135.76 28.7
+147.02 28.56
+150.22 28.98
+152.18 28.96
+153.48 28.82
+154.68 28.2
+156.22 27.2
+157.54 25.86
+158.54 23.88
+159.06 22.2
+177.88 22.04
+181.6 29.24
+185.02 30.88
+188.86 31.22
+191.94 31.32
+195.6 31.04
+199.16 31.04
+200.14 33.64
+203.32 30.46
+210.86 30.1
+215.1 35
+221.1 30.08
+233.06 30.74
+240.84 29.2
+246.26 29.56
+247.52 29.74
+248.9 30.62
+250.46 31.56
+252.54 31.7
+253.8 31.16
+255.16 29.34
+259.6 26.28
+266 25.3
+267.78 28.54
+268.88 29.94
+273.14 27.76
+276.22 25.9
+280.34 29.24
+301.62 28.54
+302.36 25.48
+306.86 25.5
+320.52 29.82
+322.86 27.44

Niveaux/Carlo.lvl

@@ -0,0 +1,57 @@
+0 -1
+0 0
+6 0
+14.66 0.04
+21.08 0.02
+23.34 -0.02
+24.92 -0.08
+26.2 -0.28
+27.5 -0.58
+29.2 -1.22
+30.3 -1.82
+31.54 -2.82
+33.12 8.2
+51.02 8.18
+66.78 7.8
+78.86 7.9
+78.98 6.7
+86.04 6.72
+88.68 6.6
+90.44 6.34
+92.5 5.7
+94.1 4.98
+95.66 3.64
+96.64 2.74
+98.32 9.16
+100.66 9.16
+101.38 0.4
+103.24 8.98
+105.14 8.86
+105.76 2.16
+108.34 4.1
+110.74 5.66
+113.18 6.34
+115.58 6.46
+117.08 6.2
+118.16 5.42
+119.26 4.06
+119.94 2.28
+121.08 -0.34
+123.06 -1.6
+125.9 -1.44
+129.98 -1.46
+134.88 -1.14
+143.62 -0.86
+143.88 4.56
+146.84 4.52
+147.06 0.84
+154.04 0.96
+153.96 6.14
+155.72 6.08
+155.42 2.48
+172.56 3.1
+181.86 2.84
+190.52 1.72
+192.02 -0.64
+193.92 -0.8
+194.66 2.38

Niveaux/Donut.lvl

@@ -0,0 +1,72 @@
+0 -1
+0 0
+6 0
+9.8 0.44
+11.36 1.12
+13.94 2.42
+16.12 2.84
+17.42 2.84
+17.5 1.74
+19.98 2.04
+22.12 2.42
+24.72 3.04
+26.04 3.52
+27.28 4.1
+29.38 4.72
+31.44 4.94
+33.16 4.86
+36.24 4.8
+36.3 3.12
+40.32 3.36
+41.62 3.4
+42.78 3.68
+44.04 4.08
+45.6 4.6
+47.18 5.3
+48.56 5.68
+49.8 5.64
+50.5 5.32
+51.48 4.86
+52.56 3.86
+53.32 6.52
+54.1 7.14
+55.48 8
+57.06 8.5
+58.36 8.76
+59.4 8.7
+60.18 8.66
+61.1 8.66
+62.54 8.62
+63.92 8.18
+64.8 7.6
+65.34 6.82
+65.7 6.18
+66.52 5.74
+67.5 5.84
+68.36 7.08
+68.58 6.5
+69.72 7.06
+70.76 7.8
+71.72 8.72
+72.74 9.28
+74.36 9.56
+75.28 9.78
+76.28 13.82
+77.1 14
+77.32 11.42
+78.58 12
+79.68 12.9
+80.54 13.76
+81.46 14
+83.08 14.06
+85.16 13.64
+86.42 13.38
+87.82 12.66
+96.64 6.12
+97.34 11.42
+99.76 11.3
+99.72 5.78
+103.8 8.48
+106.62 9.08
+110.14 9.02
+130.3 8.64

Niveaux/GitHubOpening.lvl

@@ -0,0 +1,28 @@
+0 -1
+0 0
+6 0
+8.22 0.84
+10.12 2.68
+11.24 4.96
+13.58 5.6
+16.3 5.5
+18.66 4.24
+21 2.56
+22.16 1.04
+23.38 -0.9
+24.78 1.2
+27.42 6.96
+32.16 5.44
+40.48 5.74
+43.02 2.02
+49.26 3.58
+54.06 4.76
+56.9 4.6
+59.28 4.2
+62.34 2.96
+62.56 2.74
+66.08 7.36
+71.04 6.38
+72.66 4.62
+75.74 4.22
+76.9 6.2

Niveaux/HalfPipe.lvl

@@ -0,0 +1,13 @@
+0 -1
+0 0
+6 0
+6.61 1.58
+7.3 2.58
+8.87 3.73
+11.09 4.22
+14.06 3.98
+15.02 3.19
+15.66 2.02
+16.48 0.1
+20.06 0.07
+20.96 -1.21

Niveaux/Hyperdrive1.lvl

@@ -0,0 +1,64 @@
+0 -1
+0 0
+6 0
+17.2 4.76
+21.8 6.16
+41.24 16.24
+47.84 17.48
+63.84 21.12
+74.96 23.84
+91.28 28.64
+95.6 29.56
+97.52 29.6
+100.08 28.88
+105.08 27.36
+109.28 24.92
+115.56 19.64
+117.8 18.12
+120.36 15.68
+123.8 12.28
+124.8 10.64
+127.08 7.84
+132.28 25.36
+139.96 -1.08
+144.16 25.12
+151.48 5.52
+160.76 12.24
+162.8 13.28
+165.44 14.72
+168.2 16.32
+172.84 18.28
+210.24 18.56
+226.2 18.24
+226.6 15.6
+231.96 15.84
+242.68 16.08
+245.68 22.32
+247.56 12.4
+250.88 21.96
+251.48 15.16
+259.56 14.96
+260.96 22.08
+263.84 12.52
+266.92 21.72
+268.2 15
+277.52 18.04
+279.56 18.12
+281.68 17.88
+283.76 16.84
+284.92 15.56
+289.84 21.32
+291.36 12.92
+293.92 20.8
+294.68 13.12
+297.92 20.48
+301.2 21.48
+303.28 22.16
+305.64 22.64
+308.6 23.2
+311.32 23.64
+314.92 24.4
+316.88 24.52
+319.16 24.76
+320.32 24.64
+321.76 10.96

Niveaux/Level.idx

@@ -0,0 +1,8 @@
+2Jumps.lvl
+Carlo.lvl
+Donut.lvl
+HalfPipe.lvl
+Hyperdrive1.lvl
+NiveauInstant.lvl
+Shark.lvl
+GitHubOpening.lvl

Niveaux/NiveauInstant.lvl

@@ -0,0 +1,64 @@
+0 -1
+0 0
+6 0
+17.2 4.76
+21.8 6.16
+41.24 16.24
+47.84 17.48
+63.84 21.12
+74.96 23.84
+91.28 28.64
+95.6 29.56
+97.52 29.6
+100.08 28.88
+105.08 27.36
+109.28 24.92
+115.56 19.64
+117.8 18.12
+120.36 15.68
+123.8 12.28
+124.8 10.64
+127.08 7.84
+132.28 25.36
+139.96 -1.08
+144.16 25.12
+151.48 5.52
+160.76 12.24
+162.8 13.28
+165.44 14.72
+168.2 16.32
+172.84 18.28
+210.24 18.56
+226.2 18.24
+226.6 15.6
+231.96 15.84
+242.68 16.08
+245.68 22.32
+247.38 15.48
+250.88 21.96
+251.48 15.16
+259.56 14.96
+260.96 22.08
+263.76 15.14
+266.92 21.72
+268.2 15
+277.52 18.04
+279.56 18.12
+281.68 17.88
+283.76 16.84
+284.92 15.56
+289.84 21.32
+291.36 12.92
+293.92 20.8
+294.68 13.12
+297.92 20.48
+301.2 21.48
+303.28 22.16
+305.64 22.64
+308.6 23.2
+311.32 23.64
+314.92 24.4
+316.88 24.52
+319.16 24.76
+320.32 24.64
+321.76 10.96

Niveaux/Shark.lvl

@@ -0,0 +1,169 @@
+0 -1
+0 0
+6 0
+11.86 0.12
+13.04 0.58
+14.56 1.5
+19.66 3.3
+22.04 3.28
+28.22 3.3
+30.58 3.08
+35.26 -1.36
+35.46 1.1
+37.3 -1.76
+38.94 0.6
+39.92 -2.14
+41.54 0.22
+42.62 -1.94
+44.02 0.14
+45.3 -1.72
+51.48 3.72
+55.96 6.1
+60.5 6.2
+65.22 6.28
+66.26 6.3
+68.04 6.08
+69.6 5.38
+71.08 4.24
+72.3 2.38
+73.64 0.24
+76.98 -4.12
+81.3 -8.82
+83.76 -10.68
+85.62 -11.44
+87.66 -12.14
+89.72 -12.34
+91.5 -12.4
+92.28 -10.54
+93.28 -10.4
+94.38 -10.12
+94.78 -4.04
+96.88 -4.08
+97.26 -9.22
+98.66 -8.74
+100 -8.04
+100.94 -6.94
+102.02 -6.24
+104.94 -4.04
+107.64 -3.18
+109.58 -3.36
+112.24 -4.38
+114.06 -5.54
+115.5 -6.7
+116.74 -8.22
+118 -8.46
+120.3 -8.84
+122.76 -8.78
+125.62 -8.8
+129.06 -8.96
+142.68 -9.08
+149.6 -9.18
+150.52 -6.04
+150.94 -9.04
+158.04 -9.08
+159.28 -5.94
+160.62 -8.84
+166.84 -8.9
+167.82 -6.68
+169.02 -8.74
+173.4 -8.68
+173.98 -7.12
+174.54 -8.32
+188.04 -8.16
+194.02 -8.68
+195.38 -9.18
+196.94 -10.22
+198.28 -11.42
+199.42 -6.9
+202.44 -11.54
+203.12 -7.7
+204.28 -9.92
+205.64 -7.12
+208.82 -13
+209.84 -7.86
+212.84 -14.3
+214.68 -7.84
+216.48 -10.42
+218.66 -10.72
+219.6 -12.86
+220.64 -10.64
+224.1 -10.8
+225.08 -9.14
+226.6 -8.98
+227.38 -6.74
+230.28 -6.2
+235.06 -6.12
+240.26 -6.8
+243.58 -7.16
+246.06 -7.66
+248.14 -6.28
+251.36 -6.98
+255.14 -6.04
+260.36 -6.08
+276.24 -6.06
+276.94 -6.34
+278.02 -8
+279.08 -7.34
+277.84 -7.26
+278.1 -7.58
+280.26 -9.46
+280.72 -9.64
+282.32 -9.56
+282.74 -8.34
+283.88 -8.3
+284.52 -6.26
+287.7 -5.64
+289.14 -5.8
+290.64 -5.76
+292.22 -5.46
+294.36 -4.66
+295.52 -3.44
+304 3.6
+307.36 6.08
+310.74 7.7
+312.56 7.86
+314.78 7.7
+316.78 7.14
+320.9 5.76
+322.56 4.76
+324.3 3.46
+327.88 1.04
+328.92 -0.38
+330.22 -1.86
+330.98 -3.22
+333.46 -7.18
+334.32 -9.28
+335.06 -11.32
+335.6 -13.82
+345.22 -13.82
+346.6 -13.72
+348 -13.52
+349.24 -12.78
+350.18 -11.66
+351.12 -10.72
+351.62 -9.94
+352.54 -2.6
+353.3 -5.88
+355.04 -1.64
+356.06 -0.24
+359.42 4.14
+361.98 7.1
+363.74 15.06
+364.12 11.64
+367.7 15.84
+370.28 18.32
+371.48 18.9
+373.14 19.36
+375.7 20.22
+377.86 22.6
+379.34 23.6
+380.42 32.08
+381.04 26.28
+383.26 27.02
+389.06 28.54
+392.32 28.64
+396.48 28.28
+402.9 27.34
+406.66 27.58
+410.02 26.92
+410.66 20.44

SnapFile.cpp

@@ -0,0 +1,315 @@
+#include "SnapFile.h"
+
+using namespace std;
+
+void SF_makeList( const string & indexName, vector<string> & dirList )
+{
+	// Stream
+	ifstream myStream( indexName.c_str() );
+
+	// Failure
+	if ( !myStream )
+	{
+		cout << "SF_makeList can't read " << indexName << endl;
+		return;
+	}
+
+	// Read
+	string line;
+
+	while( getline( myStream, line ) )
+	{
+		dirList.push_back( line );
+	}
+
+	// End
+	myStream.close();
+}
+
+
+void SF_filter( vector<string> & dirList, string ext, bool autoRemove )
+{
+	// Setup
+	unsigned int offset( ext.length() );
+	unsigned int curLeng;
+	vector<string> done;
+
+	// Filtering
+	while( !dirList.empty() )
+	{
+		curLeng = dirList.back().length();
+
+		if ( dirList.back()[ curLeng - offset - 1] == '.'
+		     && dirList.back().compare( curLeng - offset, offset, ext ) == 0 )
+		{
+			done.push_back( dirList.back() );
+
+			if ( autoRemove )
+				done.back().erase( curLeng - offset - 1, offset + 1 );
+		}
+
+		dirList.pop_back();
+	}
+
+	// Fill dirList again
+	while( !done.empty() )
+	{
+		dirList.push_back( done.back() );
+
+		done.pop_back();
+	}
+}
+
+
+void SF_choose( const string & indexName, string & fileChosen, SDL_Surface* tgt, const SF_Graphic cfg )
+{
+	// Get file list
+	vector<string> dirList;
+	SF_makeList( indexName, dirList );
+
+	if ( dirList.empty() )
+	{
+		cout << "SF_choose : no file found in " << indexName << "." << endl;
+		return;
+	} 
+
+	// Graphic init
+    bool mustDestroy;
+    SDL_Surface* screen( tgt );
+    mustDestroy = SF_fixWindow( screen, cfg );
+
+    // Mecanism
+    unsigned int select(0); // Element selected
+    unsigned int top(0); // First element display (scroll)
+    const unsigned int range( (screen->h - 32) / 9 );
+
+    // Loop
+    bool done(false);
+    SDL_Event event;
+    string msg("Jovian");
+    while (!done)
+    {
+        // [4.1] Gestion évènements
+        SDL_WaitEvent(&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_SPACE:
+            case SDLK_RETURN:
+            	done = true;
+            	fileChosen = dirList[ select ];
+            	break;
+            case SDLK_RIGHT :
+            case SDLK_DOWN :
+                if ( select < dirList.size() - 1 )
+                	select ++;
+                break;
+            case SDLK_LEFT :
+            case SDLK_UP :
+                if ( select > 0 )
+                	select --;
+                break;
+            default :
+                break;
+            }
+            break;
+        /*case SDL_MOUSEMOTION:
+            mouse.x = event.motion.x ;
+            mouse.y = event.motion.y ;
+            break;*/
+        default:
+            break;
+
+        }
+
+        // Draw
+        SDL_FillRect(screen, 0, cfg.color_back );
+
+        SF_enhanceWindow( screen, cfg );
+
+     	for ( unsigned int k( top ); k < dirList.size() && k < top + range; k++ )
+     	{
+     		if ( k == select )
+     			stringColor( screen, 24, 32 + k*9, (">" + dirList[k]).c_str(), cfg.color_select );
+     		else
+     			stringColor( screen, 32, 32 + k*9, dirList[k].c_str(), cfg.color_line );
+     	}
+
+        SDL_Flip(screen);
+
+    }
+
+    // End
+    if ( mustDestroy )
+    {
+        SDL_FreeSurface( screen );
+        screen = nullptr;
+    }
+
+    return;
+}
+
+
+void SF_keyName( string & fileName, SDL_Surface* tgt, const SF_Graphic cfg )
+{
+	// Graphic init
+    bool mustDestroy;
+    SDL_Surface* screen( tgt );
+    mustDestroy = SF_fixWindow( screen, cfg );
+
+    // Input init
+    SDL_EnableUNICODE( 1 );
+
+    // Location
+    const unsigned int y( screen->h / 2 - 4 );
+    unsigned int x;
+
+    // Loop
+    bool done(false);
+    SDL_Event event;
+    while (!done)
+    {
+        // [4.1] Gestion évènements
+        SDL_WaitEvent(&event);
+        switch (event.type)
+        {
+        case SDL_QUIT:
+            done = true;
+            break;
+        case SDL_KEYDOWN:
+            switch( event.key.keysym.sym )
+            {
+            case SDLK_ESCAPE :
+                done = true;
+                fileName = "";
+                break;
+            case SDLK_RETURN :
+            	done = true;
+            	break;
+            case SDLK_BACKSPACE :
+            	if ( fileName.size() > 0 )
+            		fileName.erase( fileName.size() - 1 );
+            	break;
+            case SDLK_RIGHT :
+            case SDLK_DOWN :
+                break;
+            case SDLK_LEFT :
+            case SDLK_UP :
+                break;
+            default :
+            	if( event.key.keysym.unicode < 0x80 && event.key.keysym.unicode > 0 )
+            	{
+                	fileName += (char)event.key.keysym.unicode;
+            	}
+                break;
+            }
+            break;
+        /*case SDL_MOUSEMOTION:
+            mouse.x = event.motion.x ;
+            mouse.y = event.motion.y ;
+            break;*/
+        default:
+            break;
+
+        }
+
+        // Draw
+        SDL_FillRect(screen, 0, cfg.color_back );
+
+        SF_enhanceWindow( screen, cfg );
+
+        x = screen->w / 2 - 4*fileName.length();
+     	stringColor( screen, x, y, fileName.c_str(), cfg.color_select );
+
+        SDL_Flip(screen);
+
+    }
+
+    // End
+    if ( mustDestroy )
+    {
+        SDL_FreeSurface( screen );
+        screen = nullptr;
+    }
+    
+    return;
+}
+
+void SF_addAskedFile( const string & indexName, string & fileName, SDL_Surface* tgt, const SF_Graphic cfg )
+{
+	// Ask
+    SF_keyName( fileName, tgt, cfg );
+
+    // Add
+    SF_addFile( indexName, fileName );
+}
+
+void SF_addFile( const string & indexName, const string & fileName )
+{
+    // Check occurence
+    vector<string> dirList;
+    SF_makeList( indexName, dirList );
+
+    for ( auto it( dirList.begin() ); it != dirList.end(); it ++ )
+    {
+        if ( *it == fileName )
+            return;
+    }
+
+    dirList.clear();
+
+    // Stream
+    ofstream myStream( indexName.c_str(), ios::app );
+
+    // Failure
+    if ( !myStream )
+    {
+        cout << "SF_makeList can't write " << indexName << endl;
+        return;
+    }
+
+    // Write
+    myStream << fileName << endl;
+
+    // End
+    myStream.close();
+}
+
+bool SF_fixWindow( SDL_Surface* & screen, const SF_Graphic cfg )
+{
+    // Surface already set
+    if ( screen )
+        return false;
+
+    // Graphic init
+    screen = SDL_SetVideoMode(cfg.w, cfg.h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF );
+    if ( !screen )
+    {
+        cout << "SF_fixWindow : graphic error : " << SDL_GetError() << endl;
+        return false;
+    }
+    SDL_WM_SetCaption( cfg.name.c_str(), 0);
+
+    // Created
+    return true;
+}
+
+void SF_enhanceWindow( SDL_Surface* screen, const SF_Graphic & cfg )
+{
+    unsigned int line_offset( 55 + 8 * cfg.name.length() );
+    stringColor( screen, 50, 6, cfg.name.c_str(), cfg.color_line );
+    #define SF_BORD 10
+    lineColor( screen, SF_BORD, SF_BORD, 45, SF_BORD, cfg.color_line );
+    lineColor( screen, line_offset, SF_BORD, screen->w - SF_BORD, SF_BORD, cfg.color_line );
+    lineColor( screen, screen->w - SF_BORD, SF_BORD, screen->w - SF_BORD, screen->h - SF_BORD, cfg.color_line );
+    lineColor( screen, screen->w - SF_BORD, screen->h - SF_BORD, SF_BORD, screen->h - SF_BORD, cfg.color_line );
+    lineColor( screen, SF_BORD, screen->h - SF_BORD, SF_BORD, SF_BORD, cfg.color_line );
+}

SnapFile.h

@@ -0,0 +1,70 @@
+#ifndef SNAPFILE_H
+#define SNAPFILE_H
+
+// Description
+/*
+SnapFile is a library based on SDL and SDL_gfx built to manage an index.
+
+Author : Jovian Hersmeule
+Last modification : 14 May 2017
+
+> Why is it relevant to use index ?
+Index are commonly used to list files inside a folder. Using index is
+relevant because it doesn't rely on a specific exploitation system.
+Indeed, listing files in a folder recquires specific libraries which
+are different between Windows and Linux.
+
+> What can perform SnapFile ?
+SnapFile has many functions do update and read your index. Thanks to SDL, SnapFile
+can create windows in order to interact easily with a user, in order to type a file
+name or to choose a file from the index.
+*/
+
+// Basic includes
+#include <iostream>
+#include <vector>
+#include <fstream>
+
+// Graphic includes
+#include <SDL/SDL.h>
+#include <SDL/SDL_gfxPrimitives.h>
+
+// Graphic config
+struct SF_Graphic
+{
+	unsigned int h;
+	unsigned int w;
+	Uint32 color_line; // GFX : RGBA
+	Uint32 color_back; // SDL : ARGB
+	Uint32 color_select; // GFX : RGBA
+	std::string name;
+};
+
+// Standard graphic config
+#define SF_STDGRPH {300, 400, 0xffff00ff, 0xff000000, 0xffffffff, "SnapFile"}
+
+// Add files listed in the index given
+void SF_makeList( const std::string & indexName, std::vector<std::string> & dirList );
+
+// Keep files with desired extension, and remove them if wanted
+void SF_filter( std::vector<std::string> & dirList, std::string ext, bool autoRemove = false );
+
+// Create a window and return file chosen
+void SF_choose( const std::string & indexName, std::string & fileChosen, SDL_Surface* tgt = nullptr, const SF_Graphic cfg = SF_STDGRPH );
+
+// Create a window to write a name
+void SF_keyName( std::string & fileName, SDL_Surface* tgt = nullptr, const SF_Graphic cfg = SF_STDGRPH );
+
+// Create a window to add a file, modify arg "fileName"
+void SF_addAskedFile( const std::string & indexName, std::string & fileName, SDL_Surface* tgt = nullptr, const SF_Graphic cfg = SF_STDGRPH );
+
+// Add a file in a index, with occurence check
+void SF_addFile( const std::string & indexName, const std::string & fileName );
+
+// Create a window if needed, return true if creation
+bool SF_fixWindow( SDL_Surface* & tgt, const SF_Graphic cfg = SF_STDGRPH );
+
+// Add shape and esthetic
+void SF_enhanceWindow( SDL_Surface* screen, const SF_Graphic & cfg );
+
+#endif

Terrain.cpp

@@ -0,0 +1,364 @@
+#include "Terrain.h"
+
+Terrain::Terrain()
+: m_size( 0 ), m_multi(MULTI), m_plot( 0x0 ), m_areaBody( 0x0 ),
+m_minX( 0.0f ), m_minY( 0.0f ), m_maxX( 0.0f ), m_maxY( 0.0f ),
+m_backTexture( 0x0 ), m_groundTexture( 0x0 ), m_bricks( 0x0 ), m_buff1( 0x0 ), m_buff2( 0x0 )
+{
+	// Constructor
+}
+
+Terrain::~Terrain()
+{
+	// Points
+	if ( m_plot )
+	{
+		delete[] m_plot ;
+		m_plot = 0x0 ;
+	}
+
+	// Textures
+	if ( m_groundTexture )
+	{
+		SDL_FreeSurface( m_groundTexture );
+		m_groundTexture = 0x0;
+	}
+
+	if ( m_backTexture )
+	{
+		SDL_FreeSurface( m_backTexture );
+		m_backTexture = 0x0;
+	}
+
+	// Buffers
+	if ( m_buff1 )
+	{
+		SDL_FreeSurface( m_buff1 );
+		m_buff1 = 0x0;
+	}
+
+	if ( m_buff2 )
+	{
+		SDL_FreeSurface( m_buff2 );
+		m_buff2 = 0x0;
+	}
+
+	if ( m_bricks )
+	{
+		SDL_FreeSurface( m_bricks );
+		m_bricks = 0x0;
+	}
+}
+
+void Terrain::defaultPlot()
+{
+	// Safety
+	if ( m_plot )
+	{
+		std::cout << "Données déjà existantes ; échec Terrain::defaultPlot()." << std::endl;
+		return;
+	}
+
+	// Tableau
+	m_size = 400;
+    m_plot = new b2Vec2[m_size];
+
+	// Premiers points
+	m_plot[0].x = 0.0f;
+	m_plot[0].y = 0.0f;
+
+    m_plot[1].x = 0.0f;
+    m_plot[1].y = 2.75f;
+
+	// Remplissage
+	for ( unsigned int i(2); i < m_size; i++ )
+	{
+		m_plot[i].x = 1.0f * i;
+		m_plot[i].y = 2.75f + 1.2f * sin( 0.05f * std::pow( i, 1.35f ) );
+	}
+}
+
+void Terrain::build( b2World &world )
+{
+	// Check previous body
+	if ( m_areaBody )
+	{
+		world.DestroyBody( m_areaBody );
+		m_areaBody = nullptr;
+	}
+
+	// Build fixture
+	b2BodyDef areaDef;
+	areaDef.position.Set(0.0f, 0.0f);
+	m_areaBody = world.CreateBody(&areaDef);
+
+	b2ChainShape chain;
+	chain.CreateChain( m_plot, m_size );
+	m_areaBody->CreateFixture( &chain, 0.0f );
+}
+
+void Terrain::textureLoad( SDL_Surface* screen )
+{
+	// Load texture ground
+	if ( m_groundTexture == 0x0 )
+		m_groundTexture = IMG_Load( "Textures/brick052b.jpg" );
+
+	if ( m_groundTexture == 0x0 )
+		std::cout << "Texture " << "Textures/brick052b.jpg" << " impossible à charger." << std::endl;
+
+	// Load texture background
+	if ( m_backTexture == 0x0 )
+		m_backTexture = IMG_Load( "Textures/ChatoLine.jpg" );
+
+	if ( m_backTexture == 0x0 )
+		std::cout << "Texture " << "Textures/ChatoLine.jpg" << " impossible à charger." << std::endl;
+
+	// Create buffers
+	if ( m_buff1 == 0x0 )
+		m_buff1 = SDL_CreateRGBSurface( SDL_HWSURFACE, screen->w, screen->h, 32, 0, 0, 0, 0);
+
+	SDL_SetColorKey( m_buff1, SDL_SRCCOLORKEY, SDL_MapRGB(screen->format, 0, 0, 0) );// 255 128 0
+
+	if ( m_buff2 == 0x0 )
+		m_buff2 = SDL_CreateRGBSurface( SDL_HWSURFACE, screen->w, screen->h, 32, 0, 0, 0, 0);
+
+	if ( m_bricks == 0x0 )
+		m_bricks = SDL_CreateRGBSurface( SDL_HWSURFACE, screen->w, screen->h, 32, 0, 0, 0, 0);
+
+	// Fill up bricks
+	if ( m_groundTexture == 0x0 )
+		return;
+
+	SDL_Rect pos({0, 0, 0, 0});
+
+	for ( pos.y = 0; pos.y < screen->h; pos.y += m_groundTexture->h )
+		for ( pos.x = 0; pos.x < screen->w; pos.x += m_groundTexture->w )
+			SDL_BlitSurface( m_groundTexture, 0x0, m_bricks, &pos );
+
+	// Optimisation
+	accelerateTexture( m_backTexture );
+	accelerateTexture( m_groundTexture );
+	accelerateTexture( m_bricks );
+	accelerateTexture( m_buff1 );
+	accelerateTexture( m_buff2 );
+}
+
+void Terrain::accelerateTexture( SDL_Surface* & text )
+{
+	if ( !text )
+		return;
+
+	SDL_Surface* temp( text );
+
+	text = SDL_DisplayFormat( temp );
+
+	SDL_FreeSurface( temp );
+}
+
+void Terrain::draw( SDL_Surface* screen, b2Vec2 origin )
+{
+	Sint16 xTab[4];
+	Sint16 yTab[4];
+
+	for ( unsigned int i(0); i < m_size - 1 ; i++ )
+	{
+		xTab[0] = xTab[3] = ( m_plot[i].x - origin.x ) * m_multi ;
+		xTab[1] = xTab[2] = ( m_plot[i + 1].x - origin.x ) * m_multi ;
+
+		if ( ! (xTab[1] > 0 && xTab[0] < screen->w ) )
+			continue ;
+
+		yTab[0] = ( m_plot[i].y - origin.y ) * m_multi ;
+		yTab[1] = ( m_plot[i + 1].y - origin.y ) * m_multi ;
+
+		yTab[2] = screen->h;
+		yTab[3] = screen->h;
+
+		filledPolygonRGBA( screen, xTab, yTab, 4, 255, 0, 0, 255);
+	}
+}
+
+void Terrain::drawUni( SDL_Surface* screen, b2Vec2 origin )
+{
+	// Variables
+	m_vx.clear();
+	m_vy.clear();
+	Sint16 x, y;
+
+	// Incrément
+	unsigned int i(1);
+
+	// Recherche du premier point dans le champ
+	while ( m_plot[i].x < origin.x )
+		i ++;
+
+	// Revenir au dernier point hors champ
+	i --;
+
+	// Premiers points du polygone
+	x = ( m_plot[i].x - origin.x ) * m_multi;
+
+	m_vx.push_back( x );
+	m_vy.push_back( screen-> h );
+
+	// Ajout des points visibles
+	for ( ; i < m_size && m_vx.back() < screen->w ; i++ )
+	{
+		x = ( m_plot[i].x - origin.x ) * m_multi;
+		y = ( m_plot[i].y - origin.y ) * m_multi ;
+
+		m_vx.push_back( x );
+		m_vy.push_back( y );
+	}
+
+	// Ajout du dernier point
+	m_vx.push_back( x );
+	m_vy.push_back( screen-> h );
+
+	// Dessin
+	filledPolygonRGBA( screen, m_vx.data(), m_vy.data(), m_vx.size(), 255, 128, 0, 255 );
+}
+
+
+
+void Terrain::drawWithTexture( SDL_Surface* screen, b2Vec2 origin )
+{
+	// Load texture
+	if ( m_groundTexture == 0x0 )
+		drawUni( screen, origin );
+
+	// Variables
+	m_vx.clear();
+	m_vy.clear();
+	Sint16 x, y;
+
+	// Incrément
+	unsigned int i(0);
+
+	// Recherche du premier point dans le champ
+	while ( m_plot[i].x < origin.x )
+		i ++;
+
+	// Revenir au dernier point hors champ
+	//i --;
+
+	// Premiers points du polygone
+	x = ( m_plot[i].x - origin.x ) * m_multi;
+
+	m_vx.push_back( x );
+	m_vy.push_back( screen-> h - 5 );
+
+	// Ajout des points visibles
+	for ( ; i < m_size && m_vx.back() < screen->w ; i++ )
+	{
+		x = ( m_plot[i].x - origin.x ) * m_multi;
+		y = ( m_plot[i].y - origin.y ) * m_multi ;
+
+		m_vx.push_back( x );
+		m_vy.push_back( y );
+	}
+
+	// Debug
+	m_vx.pop_back();
+	m_vy.pop_back();
+
+	// Ajout du dernier point
+	m_vx.push_back( ( m_plot[i - 2].x - origin.x ) * m_multi );
+	m_vy.push_back( screen-> h - 5 );
+
+	// Dessin
+	texturedPolygon( screen, m_vx.data(), m_vy.data(), m_vx.size(), m_groundTexture, -origin.x * m_multi, origin.y * m_multi);
+	polygonRGBA( screen, m_vx.data(), m_vy.data(), m_vx.size(), 255, 0, 0, 255 );
+}
+
+void Terrain::drawArtist( SDL_Surface* screen, b2Vec2 origin )
+{
+	// Process first buffer
+	SDL_Rect pos;
+	pos.x = - ( origin.x - m_minX ) * ( m_backTexture->w - screen->w ) / ( m_maxX - m_minX );
+	pos.y = - ( origin.y - m_minY ) * ( m_backTexture->h - screen->h ) / ( m_maxY - m_minY );
+	//SDL_FillRect(m_buff1, 0, 0x00000000 );
+	SDL_BlitSurface( m_backTexture, 0x0, screen, & pos );
+	drawUni( screen, origin );
+
+	// Process second buffer
+	/*SDL_BlitSurface( m_bricks, 0x0, m_buff2, 0x0 );
+	SDL_BlitSurface( m_buff1, 0x0, m_buff2, 0x0 );*/
+
+	// Final rendering
+	//SDL_BlitSurface( m_buff2, 0x0, screen, 0x0 );
+}
+
+void Terrain::load(std::string chemin)
+{
+	// Flux
+    std::ifstream loadStream( chemin.c_str() );
+
+    // Lecture
+    float buff;
+
+    std::vector<float> data;
+
+    while ( loadStream >> buff )
+		data.push_back( buff );
+
+	loadStream.close();
+
+	// Remplacment
+	if ( m_plot )
+	{
+		delete[] m_plot;
+		m_plot = 0x0;
+	}
+
+	// Création
+	m_size = data.size() / 2;
+	m_plot = new b2Vec2[m_size];
+
+	// Remplissage
+	for ( unsigned int i(0); i < m_size; i++ )
+	{
+		m_plot[i].x = data[2*i];
+		m_plot[i].y = data[2*i + 1];
+	}
+
+	// Ajustement du scrolling
+	setMaxRect();
+}
+
+void Terrain::setMaxRect()
+{
+	// Réinitialisation
+	m_maxX = m_minX = m_maxY = m_minY = 0.0f;
+
+	// Recherche des extremums
+	for ( unsigned int i(0); i < m_size; i++ )
+	{
+		if ( m_plot[i].x > m_maxX )
+			m_maxX = m_plot[i].x;
+
+		if ( m_plot[i].x < m_minX )
+			m_minX = m_plot[i].x;
+
+		if ( m_plot[i].y > m_maxY )
+			m_maxY = m_plot[i].y;
+
+		if ( m_plot[i].y < m_minY )
+			m_minY = m_plot[i].y;
+	}
+
+	// Ajustements
+	m_minY -= 6.0f;
+}
+
+
+void Terrain::setMulti( float newMulti )
+{
+	m_multi = newMulti;
+
+	if ( m_multi <= 0.0f )
+		m_multi = MULTI;
+}
+
+
+/// END OF FILE

Terrain.h

@@ -0,0 +1,65 @@
+# ifndef TERRAIN_HEADER_FILE
+# define TERRAIN_HEADER_FILE
+
+// Basiques
+# include <iostream>
+# include <fstream>
+# include <vector>
+# include <cmath>
+
+// Random
+# include <ctime>
+# include <cstdlib>
+
+// SDL
+# include <SDL/SDL.h>
+# undef main
+# include <SDL/SDL_gfxPrimitives.h>
+# include <SDL/SDL_image.h>
+
+// bBox2D
+# include <Box2D/Box2D.h>
+# define MULTI 100.0f
+
+class Terrain
+{
+public:
+	Terrain();
+	~Terrain();
+
+	void defaultPlot();
+	void build( b2World &world );
+	void textureLoad( SDL_Surface* screen );
+	void accelerateTexture( SDL_Surface* & text );
+
+	void draw( SDL_Surface* screen, b2Vec2 origin ); // Pas opti
+	void drawUni( SDL_Surface* screen, b2Vec2 origin );
+	void drawWithTexture( SDL_Surface* screen, b2Vec2 origin ); // Lent
+	void drawArtist( SDL_Surface* screen, b2Vec2 origin ); // Wonderful landscape
+
+	void load( std::string chemin );
+	void setMaxRect();
+	void setMulti( float newMulti );
+
+protected :
+	unsigned int m_size ;
+	float m_multi;
+	b2Vec2* m_plot; // Static array
+	b2Body* m_areaBody;
+
+	float m_minX;
+	float m_minY;
+	float m_maxX;
+	float m_maxY;
+
+	SDL_Surface* m_backTexture;
+	SDL_Surface* m_groundTexture;
+	SDL_Surface* m_bricks;
+	SDL_Surface* m_buff1;
+	SDL_Surface* m_buff2;
+
+	std::vector<Sint16> m_vx;
+	std::vector<Sint16> m_vy;
+};
+
+# endif // TERRAIN_HEADER_FILE

main.cpp

@@ -0,0 +1,303 @@
+// Basiques
+# include <iostream>
+# include <vector>
+# include <string>
+
+// Random
+# include <ctime>
+# include <cstdlib>
+
+// SDL
+# include <SDL/SDL.h>
+# undef main
+# include <SDL/SDL_rotozoom.h>
+# include <SDL/SDL_gfxPrimitives.h>
+
+// bBox2D
+# include <Box2D/Box2D.h>
+
+// Local
+# include "Cars/PickUp.h"
+# include "Cars/PinkLiner.h"
+# include "Terrain.h"
+
+// SnapFile
+#include "SnapFile.h"
+
+int main(int argc, char** argv)
+{
+	/// [1] Démarrage
+    // [1.0] Démarrage aléatoire
+    srand( time(0) );
+
+    // [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("Box2DTests", 0);
+
+    /// [2] Préparation des composants SDL
+    // [2.1] Préparation de la fenêtre
+    SDL_Surface* screen = SDL_SetVideoMode(1200, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
+    if ( !screen )
+    {
+        std::cout << "Bug à l'initialisation: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    // [2.2] Préparation variables
+    SDL_Rect mouse({ 400, 200, 0, 0 });
+    SDL_Rect pxpos({ 400, 200, 0, 0 });
+
+    // [2.3] Préparation surfaces
+    SDL_Surface* tempo( 0x0 );
+
+    // [2.4] Préparation du temps
+    Uint32 frameRate( 60 );
+    Uint32 tprev(0), twait( 1000 / frameRate );
+    bool pause( false );
+
+    // [2.5] Préparation des messages
+    std::string msg("Victor");
+
+    /// [3] Box2D
+    // Trucs
+    B2_NOT_USED(argc);
+    B2_NOT_USED(argv);
+
+    // Construct a world object
+    b2Vec2 gravity( 0.0f, 10.0f );
+    b2World world(gravity);
+
+    // Simulation settings
+    float32 timeStep = 1.0f / frameRate;
+    int32 velocityIterations = 8;
+    int32 positionIterations = 3;
+    float32 angle, multi(MULTI);
+    b2Vec2 position, ref, decalage;
+
+	// Define the edge body
+	float32 areah( (float32)screen->h / multi );
+	float32 areaw( (float32)screen->w / multi );
+
+    // Terrain
+    //std::cout << "Quel niveau ?" << std::endl;
+    std::string lvl("NiveauInstant");
+    std::string indexName("Niveaux/Level.idx");
+    //std::cin >> lvl;
+    Terrain myTerrain;
+    myTerrain.load( "Niveaux/" + lvl + ".lvl" );
+    myTerrain.build( world );
+    myTerrain.textureLoad( screen );
+
+    // Voiture
+    PinkLiner myCar;
+    myCar.init( world, 3.0f, -1.0f );
+
+    // Évènements
+    bool spin_right( false );
+    bool spin_left( 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 :
+                    // Destroy joints first of all
+                    myCar.init(world, 3.0f, -1.0f );
+                    std::cout << std::endl << "Respawn !" << std::endl << std::endl;
+                    break;
+                case SDLK_a :
+                case SDLK_q :
+                    spin_left = true;
+                    break;
+                case SDLK_d :
+                    spin_right = true;
+                    break;
+                case SDLK_p :
+                    pause = !pause ;
+                    break;
+                case SDLK_RIGHT :
+                    myCar.drive( GO );
+                    break;
+                case SDLK_LEFT :
+                    myCar.drive( REVERSE );
+                    break;
+                case SDLK_DOWN :
+                    myCar.drive( BREAK );
+                    break;
+                case SDLK_l:
+                    SF_choose( indexName, lvl, screen );
+                    if ( lvl != "" )
+                    {
+                        myCar.init( world, 3.0f, -1.0f );
+                        myTerrain.load( "Niveaux/" + lvl );
+                        myTerrain.build( world );
+                    }
+                case SDLK_SPACE :
+                    if ( myCar.GetIsOnGround() )
+                        myCar.jump();
+                    break;
+                default :
+                    break;
+                }
+                break;
+            case SDL_KEYUP:
+                switch( event.key.keysym.sym )
+                {
+                case SDLK_LEFT :
+                case SDLK_RIGHT :
+                case SDLK_DOWN :
+                    myCar.drive( FREE );
+                    break;
+                case SDLK_a :
+                case SDLK_q :
+                    spin_left = false;
+                    break;
+                case SDLK_d :
+                    spin_right = false;
+                    break;
+                default :
+                    break ;
+                }
+                break;
+            case SDL_MOUSEMOTION:
+                mouse.x = event.motion.x ;
+                mouse.y = event.motion.y ;
+                break;
+            case SDL_MOUSEBUTTONDOWN:
+                std::cout << "SDL_MOUSEBUTTONDOWN" << std::endl;
+                break;
+            case SDL_MOUSEBUTTONUP:
+                std::cout << "SDL_MOUSEBUTTONUP" << std::endl;
+                break;
+            default:
+                break;
+
+            } // end switch event type
+        } // end of message processing
+
+        // [4.2] Calculs
+        // It is generally best to keep the time step and iterations fixed.
+        /*motor->SetMotorSpeed( speed );
+        motor->SetMaxMotorTorque( torque );*/
+
+        if ( !pause )
+        {
+            // Spin
+            if ( spin_left )
+                myCar.spin( -0.005f );
+
+            if ( spin_right )
+                myCar.spin( 0.005f );
+
+            // Physique
+			world.Step(timeStep, velocityIterations, positionIterations);
+
+            myCar.update();
+        }
+
+        // Référentiel
+        decalage = 0.95f * decalage + 0.005f * myCar.GetVelocity();
+
+        ref = myCar.GetPosition();
+        ref.Set( ref.x - areaw / 5.0f , ref.y - areah / 2.0f );
+        ref += decalage;
+
+        // Zoom
+        multi = MULTI * (1.0f - 0.2f * decalage.Length());
+        myTerrain.setMulti( multi );
+
+        // [4.3] Dessin des composants
+        SDL_FillRect(screen, 0, 0x00000000 );
+
+        myTerrain.drawArtist( screen, ref );//drawUni
+
+        for ( b2Body* b = world.GetBodyList(); b; b = b->GetNext() )
+        {
+            position = b->GetPosition() - ref ;
+            angle = b->GetAngle();
+
+            tempo = (SDL_Surface*)b->GetUserData();
+            if ( tempo == 0x0 )
+                continue ;
+
+            tempo = rotozoomSurface( tempo, -angle * 180.0f / b2_pi, multi / MULTI, 0 );
+
+
+            pxpos.x = position.x * multi - tempo->w / 2 ;
+            pxpos.y = position.y * multi - tempo->h / 2 ;
+            SDL_BlitSurface( tempo, 0x0, screen, &pxpos);
+
+            SDL_FreeSurface( tempo );
+            tempo = 0x0 ;
+        }
+
+        // Messages
+        msg = "Niveau : " ;
+        msg += lvl ;
+        stringRGBA( screen, 16, 7, msg.c_str(), 0, 255, 0, 255 );
+
+        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 = "Position : " ;
+        msg += std::to_string( ref.x ) ;
+        msg += " m." ;
+        stringRGBA( screen, 16, 25, msg.c_str(), 0, 255, 0, 255 );
+
+        msg = "Torque : " ;
+        msg += std::to_string( myCar.GetTorque() ) ;
+        msg += " N.m." ;
+        stringRGBA( screen, 16, 34, msg.c_str(), 0, 255, 0, 255 );
+
+        msg = "Speed : " ;
+        msg += std::to_string( myCar.GetSpeed() ) ;
+        msg += " rad/s." ;
+        stringRGBA( screen, 16, 43, msg.c_str(), 0, 255, 0, 255 );
+
+        msg = "Is on air : " ;
+        msg += std::to_string( myCar.GetIsOnGround() ) ;
+        msg += "." ;
+        stringRGBA( screen, 16, 52, 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;
+}