bizzarerie avec cout et vector

bonjour,

j'ai un problème sur un mario bros que je suis en train de creer en sdl avec la gestion des collision, elle fonctionne parfaitement avec toutes les briques sauf la première
voici la fonction de la gestion des collision de la classse obstacle :

bool Obstacle::estEnContact(int posMario, int posX) {	


 //la variable posXinit stocke la position de l'obstacle par rapport a l'arriere plan
 //la variable posMarioX stocke la distance entre mario et l'origine de l'arrière plan	
	
	if (m_posxinit <= m_posMariox && m_posxinit + m_longueur >= m_posMariox) {
			
		std::cout << "posMarioX : " << m_posMariox << std::endl << m_posxinit << std::endl;
			
			if (posMario >= m_positiony - m_largeur) {
				return true;
			}
		}	
	
	else {
		return false;
	}
	

}

mario ne tombe pas lorsqu'il est au dessus de la première brique !!
pour voir ce qui n'allait pas j'ai mis ce cout, et ça a fonctionné (mario tombait), alors je l'ai mis en commentaire, et ça na plus fonctionné, j'ai éssayé d'enlenver l'affichage de m_posxmario, ça ne fonctionnait plus, j'ai enlevé les mots entre guillemet en ne laissant que les variable, il ne tombait pas !!
pour que ça fonctionne, il faut le std::cout avec des mots entre guillemets, la variable m_posmariox et m_posxinit
vraiment incompréhensible... quelqu'un pourrait il m'expliquer pourquoi cela fait ça et comment avoir les mêmes effets sans le std::cout ??

2eme problème

j'ai fait un tableau d'Obstacle, brique. j'ai voulu l'alouer dynamyquement avec vector

vector<Obstacle> brique(10);

et la, ce n'est plus la première brique qui bugait mais les 2eme et la dernière !! a quoi est-ce du ? comment pourrais-je avoir un tableau dynamique avec le moins de bug possible ??

merci d'avance !!

veux-tu le code entier ??

jouer.cpp

/*
 *  jouer.cpp
 *  projectSDL
 *
 *  Created by Olivier COUTEAUX on 07/05/08.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */


#include <Niveau.h>
#include <vector>
#include <iostream>
#include "SDL.h"
#include "SDL_image/SDL_image.h"
#include "Mario.h"
#include "Obstacle.h"
#include "jouer.h"

using namespace std;

void jouer(bool *cacontinue) {		//là j'envoie un pointeur sur caContinue qui me dit si le jeu doit s'arreter

SDL_Surface *ecran, *fondDecran, *mario, *drapeau;
	SDL_Rect position, posMario, posDrapeau;
	bool continuer = true;
	SDL_Event event;
	long x = 0;
	long y = 0;
	long posBlockX[10];
	long posRoulX[2];
	bool peutSauter = false;
	int posMini = 0;
	int posMaxi = 0;
	Niveau niveau;
	
	
	vector<SDL_Surface*> block(niveau.getNombreBrique());
	vector<SDL_Surface*> rouleau2(niveau.getNombreRoul());
	vector<SDL_Rect> posBlocks(niveau.getNombreBrique());
	vector<SDL_Rect> posRoul(niveau.getNombreRoul());
	//*
	vector<Obstacle> brique(niveau.getNombreBrique());
	vector<Obstacle> rouleau(niveau.getNombreRoul());
	//*/
	
	Mario mario2;	
	
	/*
	Obstacle brique[10];
	Obstacle rouleau[2];
	//*/	

	rouleau[0].changelongueurs(500, 32);
	rouleau[1].changelongueurs(500, 32);
	
	for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {	
		brique[i].changeCoor(niveau.getCoor("x", i), niveau.getCoor("y", i));
		posBlockX[i] = niveau.getCoor("x", i) + 20; //j'ajoute 20 pixels pour ajuster la gestion des collisions au blit
		posBlocks[i].y = niveau.getCoor("y", i);
	}	
	
	int j = niveau.getNombreBrique();
	
	for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
		rouleau[i].changeCoor(niveau.getCoor("x", j), niveau.getCoor("y", j));	
		posRoulX[i] = niveau.getCoor("x", j);
		posRoul[i].y = niveau.getCoor("y", j);
		j++;
	}
//*/
	
	ecran=SDL_SetVideoMode(640,480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
	
	fondDecran = IMG_Load("fondMario.jpg");
	mario = IMG_Load("mario_droite.gif");
	drapeau = IMG_Load("spritesMario/GoalFlag.gif");	
	
	for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
	
		rouleau2[i] = IMG_Load("spritesMario/rouleau.jpg");
	
	}
	
	for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
	
		block[i] = IMG_Load("spritesMario/Bricks.gif");
	
	}
	
	position.x = 0;
	position.y = 0;
	
	posMario.x = 320;
	posMario.y = 400;
	
	posDrapeau.x = 9320;
	posDrapeau.y = 200;
	
	posBlockX[0] = 330;
	
	
	while (continuer) {
	
	Uint8 *touches = SDL_GetKeyState(NULL); 


		if (touches[SDLK_LEFT] && !mario2.aGagne()) {
			x += 16;
			posDrapeau.x += 16;
			//*
			for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
				posRoulX[i] += 16;
				rouleau[i].bouge(2);
			}			
				//*/		
			for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
				posBlockX[i] += 16;
				brique[i].bouge(2);
			}			
			
		}
		
		if (touches[SDLK_RIGHT] && !mario2.aGagne()) {
			x -= 16;
			posDrapeau.x -= 16;
			//*
			for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
				posRoulX[i] -= 16;
				rouleau[i].bouge(1);
			}				
			//*/
			for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
				posBlockX[i] -= 16;
				brique[i].bouge(1);
			}			
			
						
		}
		
		if (touches[SDLK_UP] && peutSauter) {				
				posMario.y -= 16;	
				mario2.sauter(posMario.y);		
		}
		
		if (touches[SDLK_DOWN]) {
			posMario.y += 8;
		}
		
		//ces conditions font tomber mario s'il n'est en contact avec aucune brique
		
		/*
	if (brique[1].estEnContact(posMario.y, x)) {
		std::cout << "en contact" << std::endl;
	}
	
	else std::cout << "pas en contact" << std::endl;
		//*/
		
		if (!brique[0].estEnContact(posMario.y, x)) {	
			
			if (!brique[1].estEnContact(posMario.y, x)) {	
					
				if (!brique[2].estEnContact(posMario.y, x)) {	
								
					if (!brique[3].estEnContact(posMario.y, x)) {	
									
						if (!brique[4].estEnContact(posMario.y, x)) {	
												
							if (!brique[5].estEnContact(posMario.y, x)) {	
			
								if (!brique[6].estEnContact(posMario.y, x)) {	
					
									if (!brique[7].estEnContact(posMario.y, x)) {	
								
										if (!brique[8].estEnContact(posMario.y, x)) {	
									
											if (!brique[9].estEnContact(posMario.y, x)) {
											
													if (!rouleau[0].estEnContact(posMario.y, x)) { 
													
														if (!rouleau[1].estEnContact(posMario.y, x)) {
							
															int tempsActuel = SDL_GetTicks();
															int tempsPrecedent = 0;									
																						
															if (tempsActuel - tempsPrecedent > 10) {
																posMario.y += 8; 
																tempsPrecedent = tempsActuel; 
															}
															
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		
			
	
		

		//ceci fait descendre le drapeau quand mario gagne :
		
		
		if (mario2.aGagne() && posDrapeau.y < 380) {
			int tempsActuel = SDL_GetTicks();
			int tempsPrecedent = 0;
			
			if (tempsActuel - tempsPrecedent > 10) {
				posDrapeau.y += 8; 
				tempsPrecedent = tempsActuel;
			}
		}
		
		//le jeu quitte quand mario perd :  \\
		
		
		else if (mario2.aPerdu()) {
			continuer = false;
			cout << "perdu" << endl;
		}
		
		
		SDL_PollEvent(&event);
			switch (event.type) {

				case SDL_MOUSEMOTION:
					break;
				case SDL_MOUSEBUTTONDOWN:
					break;
				case SDL_KEYDOWN:
					switch (event.key.keysym.sym) {
					
						case SDLK_ESCAPE:
							continuer = false;
							*cacontinue = false;
						break;
						case SDLK_UP:
							for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
								if (brique[i].estEnContact(posMario.y, x)) {
									
									posMini = posMario.y;
									posMaxi = posMini - 300;
									peutSauter = true;
								}
								
								
							}	
						
							for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
							
								if (rouleau[i].estEnContact(posMario.y, x)) {
									posMini = posMario.y;
									posMaxi = posMini - 300;
									peutSauter = true;
								}	
							}
														
						break;						
						
					}
					break;
				case SDL_KEYUP:
					if (event.key.keysym.sym == SDLK_UP) {
							peutSauter = false;
					
					}
				
				break;
				case SDL_QUIT:
					continuer = false;
					*cacontinue = false;	//et la je met le pointeur a false pour arreter le jeu dans le main quand on quitte

					break;
				default:
					break;
			}
			
		if (x < -9000) {
			mario2.Gagne();			
		}
		
		if (posMario.y > 480) {
			mario2.Perd();
		}
		
		if (posMario.y <= posMaxi || posMario.y <= 2) { peutSauter = false; }
		
			
		position.x = x;
		position.y = y;
		
		for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {
			
			posRoul[i].x = posRoulX[i];
		
		}
		
		for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
			posBlocks[i].x = posBlockX[i];
			
		}
		
		SDL_BlitSurface(fondDecran, NULL, ecran, &position);		
		SDL_BlitSurface(drapeau, NULL, ecran, &posDrapeau);
		
		for (int i = 0 ; i < niveau.getNombreBrique() ; i++) {
		
			SDL_BlitSurface(block[i], NULL, ecran, &posBlocks[i]);
		
		}
		
		for (int i = 0 ; i < niveau.getNombreRoul() ; i++) {

			SDL_BlitSurface(rouleau2[i], NULL, ecran, &posRoul[i]);
		}
		
		SDL_BlitSurface(mario, NULL, ecran, &posMario);
		SDL_Flip(ecran);
		
		}
	SDL_FreeSurface(fondDecran);

}

niveau.cpp :

#include "jouer.h"
 #include <string>

class Niveau {

	public :
		Niveau();
		int getNombreBrique();
		int getNombreRoul();
		int getCoor(std::string xOy, int nombre);
	private :
		int m_nombreBrique;
		int m_nombreRoul;	
		Coor m_coor[12];

};

Obstacle.cpp

#include "Obstacle.h"
#include <iostream>

Obstacle::Obstacle(int posx, int posy) {

	m_positionx = posx;
	m_positiony = posy;
	m_longueur = 32;
	m_largeur = 32;
	m_posxinit = posx;
	m_type = "brique";
	m_posMariox = 320;
}

//Surcharge du constructeur :

Obstacle::Obstacle() {

m_positionx = 320;
	m_positiony = 400;
	m_longueur = 32;
	m_largeur = 32;
	m_posxinit = 320;
	m_type = "brique";
	m_posMariox = 320;

}

Obstacle::Obstacle(int longueur, int largeur, int tagueule) {
	m_positionx = 320;
	m_positiony = 400;
	m_longueur = longueur;
	m_largeur = largeur;
	m_type = "rouleau";
	m_posMariox = 320;
}


void Obstacle::changeCoor(int x, int y) {

	m_positionx = x;
	m_positiony = y;
	m_posxinit = x;

}

void Obstacle::changelongueurs(int longueur, int largeur) {
	
	m_longueur = longueur;
	m_largeur = largeur;
	
}


bool Obstacle::estEnContact(int posMario, int posX) {	


 //la variable posXinit stocke la position de l'obstacle par rapport a l'arriere plan
 //la variable posMarioX stocke la distance entre mario et l'origine de l'arrière plan	
	
	if (m_posxinit <= m_posMariox && m_posxinit + m_longueur >= m_posMariox) {
		
			
		if (posMario >= m_positiony - m_largeur) {
			std::cout << "yu" << m_posMariox << m_posxinit << std::endl;
			return true;
		}
	}	
	
	else {
		return false;
	}
	

}

void Obstacle::bouge(int cote) {

if (cote == 1) {
	m_positionx += 16; 
	m_posMariox += 16;	//elle augmente quand il se déplace vers la droite
	
}

else {
	m_positionx -= 16;
	m_posMariox -= 16;	 //elle diminue quand il va vers la gauche
}


}

dis moi si tu en veux d'autres, le main est je pense inutile, il gére la page d'accueil.

vins64

7 mai 2008 à 21:05:40

13 mai 2008 à 18:42:47

Pas de réponse ??
j'en conclus donc que c'est paranormal et que mon compilateur ou mon code source est possédé...
je garde mon cout, alors.
merci quand meme.

MatteX

13 mai 2008 à 19:37:44

Le seul effet que pourrait avoir le cout c'est de retarder du code qui viendrait après. Donc probablement une erreur de synchronisme entre threads/timer.

Sinon avec si peu d'information on ne peut pas faire plus.

13 mai 2008 à 19:47:13

13 mai 2008 à 19:49:55

revois les boucles...

...

... Je parles de relire le cours ...

... Et les fonctions tant qu'à y être.

13 mai 2008 à 20:29:45

voilà j'ai relu...
j'ai pas compris ce que je fais de mal.... :euh:

Anonyme

13 mai 2008 à 20:33:40

aucune fonction->code dur a lire (inconprensible)

13 mai 2008 à 20:40:00

désolé... j'ai essayer de mettre dans des classes ce que je pouvais y mettre...

Citation : MatteX

Le seul effet que pourrait avoir le cout c'est de retarder du code qui viendrait après. Donc probablement une erreur de synchronisme entre threads/timer.

j'ai donc de la chance que ce soit bénéfique pour moi !! et comment pourrais-je substituer ce cout ? (pas très pratique...)

pourrait on m'expliquer ??

bizzarerie avec cout et vector

Supprimer

Modérer

Signaler le message aux modérateurs