SDL#4 - [x] Gestion des collisions

- [x] Index literaux pour ajouter au manager

SDL#4/main.cpp

@@ -4,6 +4,7 @@
 static xManager *mgr = NULL;
 static bool running  = true;
 
+static xMarioMario *mario = NULL;
 
 
 int main(int argc, char* argv[]) {
@@ -27,11 +28,11 @@ int main(int argc, char* argv[]) {
 	=========================================================*/
 	// On cree un bout du terrain
 	xMarioGrass btmleft(mgr, (SDL_Rect){-1, 20-2, 10, 3} );
-	btmleft.push();
+	btmleft.push("bottom-left");
 
 
 	xMarioGrass floattcenter(mgr, (SDL_Rect){10, 10, 5, 5} );
-	floattcenter.push();
+	floattcenter.push("float-center");
 
 
 
@@ -39,15 +40,19 @@ int main(int argc, char* argv[]) {
 	=========================================================*/
 	// On cree une coquille verte
 	// xMarioGreenShell gs(mgr, 5, 20-3);
-	// gs.start(100, SPRITE_ANIM_INFINITE);
+	// gs.start("green-sheel", 100, SPRITE_ANIM_INFINITE);
 
 	// On cree un bloc mystere
 	xMarioMysteryBloc mb(mgr, 5, 20-5);
-	mb.start(150, SPRITE_ANIM_INFINITE);
+	mb.start("mystery-bloc", 150, SPRITE_ANIM_INFINITE);
 
 	// On cree un bloc normal
 	// xMarioBloc bl(mgr, (SDL_Rect){0, 20-2, 10, 3});
-	// bl.push();
+	// bl.push("bloc-bottom-left");
+
+	// On cree mario
+	mario = new xMarioMario(mgr, 5, 20-3);
+	mario->start("mario", 100, SPRITE_ANIM_INFINITE);
 
 
 
@@ -109,5 +114,67 @@ void quitEventHandler(SDL_Event *e){
 *
 */
 void keydownEventHandler(SDL_Event *e){
-	cout << "BAS" << endl;
+	SDL_Rect *mRect = mario->viewport();
+	bool hasMoved = false;
+	int step = 20;
+
+
+	switch( (*e).key.keysym.sym ){
+		case SDLK_UP:
+			while( !hasMoved && step > 0 ){
+
+				if( !mgr->hit("mario", 0, -step) ){
+					mario->move(0, -step);
+					hasMoved = true;
+				}
+
+				step--;
+			}
+
+			break;
+
+		case SDLK_LEFT:
+			while( !hasMoved && step > 0 ){
+
+				if( !mgr->hit("mario", -step, 0) ){
+					mario->move(-step, 0);
+					hasMoved = true;
+				}
+
+				step--;
+			}
+						
+			break;
+
+		case SDLK_RIGHT:	
+			while( !hasMoved && step > 0 ){
+
+				if( !mgr->hit("mario", step, 0) ){
+					mario->move(step, 0);
+					hasMoved = true;
+				}
+
+				step--;
+			}
+			
+			break;
+
+		case SDLK_DOWN:
+			while( !hasMoved && step > 0 ){
+
+				if( !mgr->hit("mario", 0, step) ){
+					mario->move(0, step);
+					hasMoved = true;
+				}
+
+				step--;
+			}
+
+			break;
+
+		default:
+			cout << "PRESSED" << endl;
+			break;
+	}
+
 }

SDL#4/todo.md

@@ -1,8 +1,13 @@
 A FAIRE
 =======
-- [x] Auto-texture pour le sol (grass)
+- [ ] Gestion de la gravite
 
 
 
 FAIT
 ====
+- [x] Gestion des collisions
+- [x] Index literaux pour ajouter au manager
+- [x] Auto-texture pour le bloc mystere
+- [x] Auto-texture pour le mario (avec mvmts)
+- [x] Auto-texture pour le sol (grass)

SDL#4/xMario.h

@@ -13,6 +13,7 @@
 
 	/* [HEADERS] Inclusion des .h des sous-libs
 	=========================================================*/
+	#include "xMario/xMarioMario.h"
 	#include "xMario/xMarioGrass.h"
 	#include "xMario/xMarioGreenShell.h"
 	#include "xMario/xMarioMysteryBloc.h"
@@ -21,6 +22,7 @@
 
 	/* [BODIES] Inclusion des .cpp des sous-libs
 	=========================================================*/
+	#include "xMario/xMarioMario.cpp"
 	#include "xMario/xMarioGrass.cpp"
 	#include "xMario/xMarioGreenShell.cpp"
 	#include "xMario/xMarioMysteryBloc.cpp"

SDL#4/xMario/xMarioMario.cpp

@@ -0,0 +1,37 @@
+/* [CONSTRUCTOR] Construction d'un xMarioMario
+=========================================================*/
+xMarioMario::xMarioMario(xManager *m, int x, int y)
+: xSpriteAnimation(
+	m,
+	"src/mario.png",
+	(SDL_Rect){
+		(int) (BLOC_SIZE*x+BLOC_SIZE*.1),
+		BLOC_SIZE*y,
+		(int) (BLOC_SIZE*.8),
+		BLOC_SIZE
+	}
+){
+
+
+	// this->addFrame( (SDL_Rect){2, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){33, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){62, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){93, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){122, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){122, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){153, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){182, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){213, 0, 19, 29} );
+	this->addFrame( (SDL_Rect){238, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){269, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){298, 0, 19, 29} );
+	// this->addFrame( (SDL_Rect){329, 0, 19, 29} );
+
+	// /* (1) On definit les clip de chaque frame */
+	// this->addFrame( (SDL_Rect){21, 0, 18, 32} );
+	// this->addFrame( (SDL_Rect){42, 0, 18, 32} );
+	// this->addFrame( (SDL_Rect){63, 0, 18, 32} );
+	// this->addFrame( (SDL_Rect){82, 0, 18, 32} );
+	// this->addFrame( (SDL_Rect){103, 0, 18, 32} );
+	// this->addFrame( (SDL_Rect){125, 0, 18, 32} );
+}

SDL#4/xMario/xMarioMario.h

@@ -0,0 +1,15 @@
+#ifndef DEF_XMARIOMARIO_H
+
+	#define DEF_XMARIOMARIO_H
+
+	class xMarioMario : public xSpriteAnimation{
+
+		public:
+			xMarioMario(xManager *manager, int x, int y); // Spritesheet avec taille de chaque sprite
+
+		private:
+			Uint32 _lastmove;
+			float  _acceleration;
+	};
+
+#endif

SDL#4/xSDL/xManager.cpp

@@ -86,15 +86,101 @@ bool xManager::setImage(const char *url){
 }
 
 
+/* [HIT] Retourne si une texture est en collision avec une autre
+=========================================================*/
+bool xManager::hit(string current, int movex, int movey){
+	/* (1) On recupere le SDL_Rect destination du sprite courant */
+	SDL_Rect *cRect = this->getDst(current);
+
+	// Gestion erreur
+	if( cRect == NULL )
+		return false;
+
+	SDL_Rect r = (SDL_Rect){
+		(*cRect).x+movex,
+		(*cRect).y+movey,
+		(*cRect).w,
+		(*cRect).h
+	};
+	SDL_Rect c;
+
+	/* (2) On compare avec toutes les autres textures */
+	for( int i = 0 ; i < _indexes.size() ; i++ ){
+
+		// Si c'est pas le sprite courant
+		if( _indexes[i] != current ){
+
+			// taille du sprite en cours
+			c.x = (*_dst[i]).x;
+			c.y = (*_dst[i]).y;
+			c.w = (*_dst[i]).w;
+			c.h = (*_dst[i]).h;
+
+			for( int y = r.y ; y < r.y+r.h ; y++ )
+				for( int x = r.x ; x < r.x+r.w ; x++ )
+					if( x>=c.x && x<=c.x+c.w && y>=c.y && y<=c.y+c.h )
+						return true;
+
+		}
+
+	}
+
+	return false;
+}
+
+
+
+
+/* [GETTEXTURE] Renvoie la texture 
+=========================================================*/
+SDL_Texture *xManager::getTexture(string index){
+
+	// On cherche la texture avec l'index
+	for( int i = 0 ; i < _indexes.size() ; i++ )
+		if( _indexes[i] == index )
+			return _sprites[i];
+
+	return NULL;
+}
+
+
+/* [GETSRC] Renvoie le SDL_Rect source 
+=========================================================*/
+SDL_Rect *xManager::getSrc(string index){
+
+	// On cherche la texture avec l'index
+	for( int i = 0 ; i < _indexes.size() ; i++ )
+		if( _indexes[i] == index )
+			return _src[i];
+
+	return NULL;
+}
+
+
+/* [GETDST] Renvoie le SDL_Rect destination 
+=========================================================*/
+SDL_Rect *xManager::getDst(string index){
+
+	// On cherche la texture avec l'index
+	for( int i = 0 ; i < _indexes.size() ; i++ )
+		if( _indexes[i] == index )
+			return _dst[i];
+
+	return NULL;
+}
+
+
+
 /* [PUSH] Ajoute une texture au rendu principal
 =========================================================*/
-void xManager::push(SDL_Texture *t, SDL_Rect *src, SDL_Rect *dst){
+void xManager::push(string index, SDL_Texture *t, SDL_Rect *src, SDL_Rect *dst){
 	// On bloque l'acces inter-thread
 	_mutex.lock();
 
-	_sprites.push_back( t   );
-	_src.push_back(     src );
-	_dst.push_back(     dst );
+	_indexes.push_back( index );
+	_sprites.push_back( t     );
+	_src.push_back(     src   );
+	_dst.push_back(     dst   );
 
 	// On debloque l'acces
 	_mutex.unlock();
@@ -103,24 +189,25 @@ void xManager::push(SDL_Texture *t, SDL_Rect *src, SDL_Rect *dst){
 
 /* [PULL] Retire une texture du rendu principal
 =========================================================*/
-void xManager::pull(SDL_Texture *t){
+void xManager::pull(string index, SDL_Texture *t){
 	// On bloque l'acces inter-thread
 	_mutex.lock();
 
 	// On cherche l'indice de la texture
-	int index = -1;
+	int xIndex = -1;
 
-	for( int i = 0 ; i < _sprites.size() ; i++ )
-		if( _sprites[i] == t ) index = i;
+	for( int i = 0 ; i < _indexes.size() ; i++ )
+		if( _indexes[i] == index ) xIndex = i;
 
 	// Si on a rien trouve
-	if( index == -1 )
+	if( xIndex == -1 )
 		return;
 
 	// On supprime la texture et ses dimensions
-	_sprites.erase( _sprites.begin() + index );
-	_src.erase(     _src.begin()     + index );
-	_dst.erase(     _dst.begin()     + index );
+	_indexes.erase( _indexes.begin() + xIndex );
+	_sprites.erase( _sprites.begin() + xIndex );
+	_src.erase(     _src.begin()     + xIndex );
+	_dst.erase(     _dst.begin()     + xIndex );
 
 	// On debloque l'acces
 	_mutex.unlock();

SDL#4/xSDL/xManager.h

@@ -12,8 +12,13 @@
 			bool setBackground(Uint8 r=0xff, Uint8 g=0xff, Uint8 b=0xff, Uint8 a=0xff);
 			bool setImage(const char *url);
 
-			void push(SDL_Texture *t, SDL_Rect *origin, SDL_Rect *dest);
-			void pull(SDL_Texture *t);
+			bool hit(string current, int movex=0, int movey=0); // Gestion des collisions
+
+			SDL_Texture *getTexture(string index);
+			SDL_Rect    *getSrc(string index);
+			SDL_Rect    *getDst(string index);
+			void push(string index, SDL_Texture *t, SDL_Rect *origin, SDL_Rect *dest);
+			void pull(string index, SDL_Texture *t);
 
 			void update();
 
@@ -45,9 +50,10 @@
 			SDL_Texture  *_texture;
 
 			// Gestion des textures
+			vector<string>       _indexes;
 			vector<SDL_Texture*> _sprites;
-			vector<SDL_Rect*>     _src;
-			vector<SDL_Rect*>     _dst;
+			vector<SDL_Rect*>    _src;
+			vector<SDL_Rect*>    _dst;
 
 			// Protection thread-safe
 			mutex _mutex;

SDL#4/xSDL/xSprite.cpp

@@ -103,14 +103,14 @@ void xSprite::dimensions(SDL_Rect r, SDL_Rect clip){
 
 /* [PUSH] Ajoute le xSprite au rendu
 =========================================================*/
-void xSprite::push(){
-	_manager->push(_texture, &_src, &_dst);
+void xSprite::push(string index){
+	_manager->push(index, _texture, &_src, &_dst);
 }
 
 /* [PULL] Retire une sprite du rendu
 =========================================================*/
-void xSprite::pull(){
-	_manager->pull( _texture );
+void xSprite::pull(string index){
+	_manager->pull( index, _texture );
 }
 
 /* [UPDATE] Mise a jour du rendu

SDL#4/xSDL/xSprite.h

@@ -15,8 +15,8 @@
 			void dimensions(SDL_Rect r);                // Dimensions sortie
 			void dimensions(SDL_Rect r, SDL_Rect clip); // Dimensions in/out
 
-			void push(); // Ajoute a l'affichage
-			void pull(); // Retire de l'affichage
+			void push(string index); // Ajoute a l'affichage
+			void pull(string index); // Retire de l'affichage
 
 			void update(); // Fait renmonter la mise a jour du manager
 

SDL#4/xSDL/xSpriteAnimation.cpp

@@ -47,10 +47,25 @@ xSpriteAnimation::xSpriteAnimation(xManager *manager, SDL_Texture *t, SDL_Rect v
 /* [MOVE] Modification de la position/taille du sprite
 =========================================================*/
 void xSpriteAnimation::move(SDL_Rect newpos){
-	_viewport.x = newpos.x;
-	_viewport.y = newpos.y;
-	_viewport.w = newpos.w;
-	_viewport.h = newpos.h;
+	if( newpos.x != 0 )
+		_viewport.x = newpos.x;
+
+	if( newpos.y != 0 )
+		_viewport.y = newpos.y;
+
+	if( newpos.w != 0 )
+		_viewport.w = newpos.w;
+
+	if( newpos.h != 0)
+		_viewport.h = newpos.h;
+}
+
+
+/* [MOVE] Deplacement de la position/taille du sprite
+=========================================================*/
+void xSpriteAnimation::move(int x, int y){
+	_viewport.x += x;
+	_viewport.y += y;
 }
 
 
@@ -75,6 +90,11 @@ void xSpriteAnimation::addFrame(SDL_Rect clip){
 xManager *xSpriteAnimation::manager(){ return _manager; }
 
 
+/* [VIEWPORT] Retourne le viewport
+=========================================================*/
+SDL_Rect *xSpriteAnimation::viewport(){ return &_viewport; }
+
+
 
 /* [TRHEAD] Process de l'animation
 =========================================================*/
@@ -126,9 +146,9 @@ void xSpriteAnimationProcess(xSpriteAnimation *xSA, int t, int flags){
 
 /* [START] Ajoute l'animation au rendu
 =========================================================*/
-void xSpriteAnimation::start(int t, int flags){
+void xSpriteAnimation::start(string index, int t, int flags){
 	/* (1) On ajoute le sprite au rendu */
-	_manager->push(_texture, &_frame, &_viewport);
+	_manager->push(index, _texture, &_frame, &_viewport);
 
 	/* (2) On lance l'animation */
 	_animation = new thread(xSpriteAnimationProcess, this, t, flags);
@@ -141,10 +161,10 @@ void xSpriteAnimation::start(int t, int flags){
 
 /* [STOP] Arrete l'animation
 =========================================================*/
-void xSpriteAnimation::stop(){
+void xSpriteAnimation::stop(string index){
 	/* (1) On arrete l'animation */
 	delete _animation;
 
 	/* (2) On retire le sprite du rendu */
-	_manager->pull(_texture);
+	_manager->pull(index, _texture);
 }

SDL#4/xSDL/xSpriteAnimation.h

@@ -10,15 +10,18 @@
 			~xSpriteAnimation();
 
 			void move(SDL_Rect newpos);   // Deplace l'animation
+			void move(int x, int y);   // Deplace l'animation
 
 			void addFrame(SDL_Rect clip); // Ajoute une frame en fonction des coordonnees
 
 			// GETTER
 			xManager *manager();
+			SDL_Rect *viewport();
 
 			// Gestion de l'animation
-			void start(int t, int flags=SPRITE_ANIM_ONCE);
-			void stop();
+			void start(string index, int t, int flags=SPRITE_ANIM_ONCE);
+			void stop(string index);
+
 
 
 

SDL#4/xSDL/xSpriteGroup.cpp

@@ -47,16 +47,26 @@ void xSpriteGroup::remove(xSprite *s){
 
 /* [PUSH] Ajoute tous les xSprite du groupe a une surface parente
 =========================================================*/
-void xSpriteGroup::push(){
-	for( int i = 0 ; i < _sprites.size() ; i++ )
-		_sprites[i]->push();
+void xSpriteGroup::push(string index){
+	string newIndex;
+
+	for( int i = 0 ; i < _sprites.size() ; i++ ){
+		newIndex = index;
+		newIndex += to_string(i); 
+		_sprites[i]->push(newIndex);
+	}
 }
 
 /* [PULL] Retire une sprite de la surface parents
 =========================================================*/
-void xSpriteGroup::pull(){
-	for( int i = 0 ; i < _sprites.size() ; i++ )
-		_sprites[i]->pull();
+void xSpriteGroup::pull(string index){
+	string newIndex;
+
+	for( int i = 0 ; i < _sprites.size() ; i++ ){
+		newIndex = index;
+		newIndex += to_string(i); 
+		_sprites[i]->pull(newIndex);
+	}
 }
 
 

SDL#4/xSDL/xSpriteGroup.h

@@ -15,8 +15,8 @@
 			void remove(xSprite *s);
 			xSprite* get(int i);
 
-			void push(); // Ajoute les sprites a l'affichage
-			void pull(); // Retire les sprites de l'affichage
+			void push(string index); // Ajoute les sprites a l'affichage
+			void pull(string index); // Retire les sprites de l'affichage
 
 			void update(); // Fait renmonter la mise a jour du manager