SOLUCIONADO. fui muy boludo y en el main no usaba la clase heredada JAJAJAJ. el cafe no basto para esa noche
Hola, como andan ? espero que bien :p

Verán, después de mucho regreso con C/C++ extrañando sus punteros jaja
Tengo este problema que ya me quemo las pestañas y no veo lo que esta mal.

Tengo mi clase base Escenario.h con su método virtual isEndEscena el cual luego reescribo en su clase derivada HelloEscena y por ultimo, almaceno HelloEscena en un vector de vector<CEscenario*> de la clase Cordinador

El problema esta, en que cuando, tengo llamar a isEndEscena, me llama a la de la clase base y no su deribada.

Dejo el código:

Escenario

//head
#pragma once
 
#include <SFML\Graphics.hpp>
#include "Sprite.h"
 
class CEscenario
{
public:
	void addSprite(CSprite*);
	void clearSprites();
	void deleteSprite(const char* key);
 
	virtual bool isEndEscena(sf::Event);
 
	void updateSprites(sf::Event);
	void drawSprites();
 
	char* getKey();
private:
	std::vector<CSprite*> sprites;
	char* key;
};
 
//cpp
 
#include "Escenario.h"
 
bool CEscenario::isEndEscena(sf::Event)
{ 
	return true; 
}
 
char* CEscenario::getKey()
{
	return this->key;
}
 
void CEscenario::updateSprites(sf::Event evento)
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		this->sprites[i]->update(evento);
	}
}
 
void CEscenario::addSprite(CSprite* newSprite)
{
	this->sprites.push_back(newSprite);
}
 
void CEscenario::deleteSprite(const char* key)
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		if (std::strcmp(this->sprites[i]->getKey(), key) == 0)
		{
			this->sprites.erase(this->sprites.begin() + i);
			return;
		}
	}
}
 
void CEscenario::clearSprites()
{
	this->sprites.clear();
}
 
void CEscenario::drawSprites()
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		this->sprites[i]->draw();
	}
}
 

HelloEscena

//head
#pragma once
 
#include <SFML\Graphics.hpp>
#include "Escenario.h"
 
class CHelloEscena : CEscenario
{
public:
	bool isEndEscena(sf::Event);
};
 
 
//cpp
#include "HelloEscena.h"
 
bool CHelloEscena::isEndEscena(sf::Event evento)
{
	int a = 0;
	return false;
}
 

Cordinador

 
//head
#pragma once
 
#include <vector>
#include "Escenario.h"
 
class CCordinador
{
public:
	void addEscenario(CEscenario*);
	void clearEscenarios();
	void deleteEscenario(const char *key);
 
	CEscenario* getEscenario();	
 
	//void nextEscenario();
	void(*nextEscenario)();
private:
	std::vector<CEscenario* > escenarios;
	CEscenario *escenarioActual;	
};
 
//cpp
#include <cstring>
 
#include "Cordinador.h"
 
CEscenario* CCordinador::getEscenario()
{
	return escenarioActual;
}
 
void CCordinador::addEscenario(CEscenario* newEscenario)
{
	this->escenarios.push_back(newEscenario);
	this->escenarioActual = newEscenario;
}
 
void CCordinador::deleteEscenario(const char* key)
{
	int i = 0;
	for (int i = 0; i < int(this->escenarios.size()); i++)
	{
		if (std::strcmp(this->escenarios[i]->getKey(), key) == 0)
		{
			this->escenarios.erase(this->escenarios.begin() + i);
			return;
		}
	}
}
 
void CCordinador::clearEscenarios()
{
	this->escenarios.clear();
}
 

Donde uso Cordinador....

//head
#pragma once
 
#include "Cordinador.h"
 
class CApp
{
public:
	CApp(sf::RenderWindow *widows);
 
	/*Parte del siclo de vida del juego*/
	void loopGame();
	void catchEvent();
	void clearScreen();
 
	void update(sf::Event);
	void draw();
	void displayWindows();
 
 
	/*Armado del juego*/	
	static sf::RenderWindow *window;
	void setCordinador(CCordinador *c) { this->cordinador = c; }
private:	
	CCordinador *cordinador;
};
 
//cpp
//solo puse donde lo uso por que es mucho si no xD
void CApp::update(sf::Event evento)
{
	if (evento.type == sf::Event::Closed)
	{
		this->window->close();
		return;
	}
 
	if (this->cordinador->getEscenario()->isEndEscena(evento))
	{
//regresa siempre true de la clase base, y no false de la clase derivada
 
		//Un momento del juego termino y pasa al siguiente
		//ej: menues, niveles, etc		
		this->cordinador->nextEscenario();
	}
 
	this->cordinador->getEscenario()->updateSprites(evento);
}
 

y el main infaltable :p

#include <SFML/Graphics.hpp>
 
#include "App.h"
 
#include "HelloSprite.h"
#include "HelloEscena.h"
 
int main()
{
	// Create the main window
	sf::RenderWindow win(sf::VideoMode(800, 600, 32), "Hello World - SFML");
 
	//Definimos los sprites:
	CHello sprite;
 
	//Definimos los escenario:
	//imprimira en pantalla en orden de pila de como se le fue agregando al escenario
	CEscenario test;
	test.addSprite(&sprite);
 
	//Cargamos los Escenarios al Cordinador
	CCordinador cordinador;
	cordinador.addEscenario(&test);
 
	//Le damos al App el cordinador
	CApp app(&win);
	app.setCordinador(&cordinador);
 
	//Empezamos el juego
	app.loopGame();
 
	return 0;
}
 

Desde ya muchas gracias por leer.