View difference between Paste ID: keH3EL9h and CHeBjNmw

 void Game::cleanGarbage()
 {
 	Clock dt;
 	dt.restart();
 
-	for (int i = 0; i < this->garbage.size(); i++)
+	// Ces tableaux vont contenir les éléments "sauvés" (que tu ne garbages pas)
 	vector<Independant*> newSceneIndependants;
-		vector<Independant*>::iterator it1_ = this->sceneIndependants.begin();
+	//vector<Independant*> newSceneIndependantsLayered[NB_LAYERS];	// TODO: je te passe le code pour
-		vector<Independant*>::iterator it2_ = this->sceneIndependantsLayered[(int)(this->garbage[i]->layer)].begin();
+	//vector<Independant*> newSceneIndependantsTyped[NB_TYPES];	// ces tableaux-là...
-		vector<Independant*>::iterator it3_ = this->sceneIndependantsTyped[(int)(this->garbage[i]->collider_type)].begin();
+
 	// On "cache" les tailles des tableaux pour éviter de faire un appel de fonction à chaque itération
-		it1_ = this->sceneIndependants.erase(it1_);
+	// En "const", c'est mieux parce qu'on est certains que ça ne changera pas dans le code qui suit.
-		it2_ = this->sceneIndependantsLayered[(int)(this->garbage[i]->layer)].erase(it2_);
+	// En "size_t" plutôt que "int", c'est le même type que ce que renvoie "size()" (attention à ne pas utiliser
-		it3_ = this->sceneIndependantsTyped[(int)(this->garbage[i]->collider_type)].erase(it3_);
+	// ça si tu fais des boucles à l'envers, c'est toujours positif - for(j=size-1;j > 0 ;j--) est une boucle
 	// infinie si j est un size_t.
 	const size_t sceneIndependantsSize = this->sceneIndependants.size();
 	const size_t garbageSize = this->garbage.size();
 
 	newSceneIndependants.reserve(sceneIndependantsSize);	// évite des réallocations, optim, pas obligé mais mieux
 
 	for(size_t i=0 ; i < sceneIndependantsSize ; i++)
 	{
 		// On prend un "candidat" : sera-t-il sauvé ? (= pas présent dans la liste "garbage")
 		Independant* pCandidate = this->sceneIndependants[i];
 		bool bCandidateFound = false;
 		// NB : avant, quand tu appelais "remove()", ça parcourait toute la liste en cherchant
 		// un élément donné, donc c'était caché mais tu avais bien 2 boucles imbriquées aussi
 		for(size_t j=0 ; j < garbageSize ; j++)
 		{
 			if(pCandidate == this->garbage[j])
 			{
 				bCandidateFound = true;
 				break;	// pas nécessaire, mais c'est une optim : aucun intérêt à continuer à parcourir le tableau
 			}
 		}
 		if(!bCandidateFound)
 			newSceneIndependants.push_back(pCandidate);	// sauvé !
 	}
 
 	// Comme je disais, je te passe le code pour les version "layered" et "typed"...
 
 	// Et à la fin, tu copies (fait une boucle en interne), dans l' "operator=" de std::vector:
 	this->sceneIndependants = newSceneIndependants;
 
 	//printf("| Clean: %d ",dt.getElapsedTime().asMilliseconds());
 }