Se ejecuta el método virtual de la clase base y no la heradada

[CSQCasimiro]

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

Código (c) [Seleccionar] Expandir


//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

Código (c) [Seleccionar] Expandir


//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

Código (c) [Seleccionar] Expandir



//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....

Código (c) [Seleccionar] Expandir


//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

Código (c) [Seleccionar] Expandir


#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.