¡Oh, yeeeees! ¡¡¡Por fín funciona!!!!

Al principio he probado a sustituir la declaración del constructor de Player por esa, en la cabecera. Me ha dicho que faltaban unas llaves al final, con cara extrañada las añado, y veo que me dice que el constructor ya había sido definido (o algo así).

Total, que de pronto me hago a mí mismo un /facepalm, dejo la declaración del constructor de Player como estaba, me voy al Player.cpp, y cambio la primera línea del constructor por la que me has dado.

Y va de putísima madre .

Gracias por la ayuda, ya andaba como loco xD, me tengo que ver más a fondo todo el tema de la herencia en C++ .

Salu2 y tema solucionado ^^

Una cosa, ¿ese programa spice.exe funciona en red?

O sea... tu dices que quieres controlar las personas que se comunican con dicho programa (como si, poniendo otro ejemplo, tuviéramos un programa cliente/servidor de mensajería dentro de una LAN, y quisieramos detectar qué PC cliente se está comunicando con el programa servidor para evitar que lleguen los mensajes a destino), ¿Ese programa tiene alguna capacidad de servidor?

Porque es la única manera en que se me ocurre que un PC externo se comunique con el ...

Salu2


P.D: Dicho sea de paso... ¿Qué hace el famoso spice.exe? XD.

El problema de la migración definitiva a los 64 bits, por lo menos según mi punto de vista, es el siguiente:

Está claro que hay que ir modernizándose, progresando, etc... y dicho progreso estaría muy bien visto... si fuera como tiene que ir.

Los 64 bits no son nuevos ni mucho menos, hace años que están entre nosotros (como apuntan, Windows XP mismo ya tenía una versión de 64 bits), y pese a llevar con nosotros tanto tiempo:

- Todavía existe hardware para el que no existen drivers de 64 bits.
- En cuanto a  software, tanto aplicaciones como juegos están presentes en un buen porcentaje solo en 32 bits.

Si todos los dispositivos de ahora, incluyeran drivers para 64 bits, todos los dispositivos antiguos TAMBIÉN LOS TUVIERAN (que esa es otra, hay piezas de hardware previas a los 64 bits que probablemente nunca los tengan, porque a los desarrolladores no les ha dado la gana de hacerlos), y el software evolucionase al completo a los 64 bits, el progreso a los 64 bits se vería de otra manera, sería posible en efecto hacer una migración total.

Vale que ahora mucha gente no necesita los 64 bits, pero llegará un momento en que sí, y en Informática hay que pensar mirando al futuro.


El tema de los 64 bits me recuerda a la TDT aquí en España, dimos el salto a ella porque nos venía impuesto que tenía que ser así, pero el resultado ha sido cuanto menos desastroso, porque en muchos sitios no se recibe, en los que se recibe la señal no tiene una calidad decente y se recibe la misma entrecortada, etc ...

En definitiva, hemos dado el salto a la TDT, cierto, pero no estábamos preparados para ello, y no lo estábamos porque, para no perder la costumbre, la gente que se encargaba de ella no ha hecho los deberes, deberían haber sido más previsores, etc (de hecho, ahora mismo en mi casa, cuando se supone que ha tenido lugar ya el apagón analógico... nuestra TV, aparte de la señal digital, sigue pudiendo captar perfectamente varias cadenas (que no son pocas) en analógico, ¿Donde está el famoso apagón que iba a desterrar a la analógica cual un Satanás a los infiernos?, Yo no lo veo).

Pues con los x64 otra de lo mismo, quisieron dar el salto, pero el tema es que no se pueden aprovechar decentemente porque el software fundamentalmente no está preparado.

Salu2

Esto... ¿Y que hay de los PCs gamers que tienen que tener instalados en sus máquinas más de 4 GB de RAM?

Muchos de los últimos juegos requieren 2GB de RAM, y si te vas a los requisitos recomendados la cifra aumenta.

Y según recuerdo, los S.Os de 32 bits no pueden direccionar más de 4 GBs de RAM. De hecho, si intentas usar 4 GBs en un S.O de 32 bits te muestra menos memoria que esa. Es necesario tirar a los 64 bits para poder pasar la barrera de los 3,X GBs disponibles.

Salu2


P.D: Yo actualmente uso Windows 7 Ultimate x64, y mi PC es bastante corriente: Athlon X2 3800+, 2 GBs RAM, y una GeForce 9600 GT que todavía ando estirando todo lo que puedo.

Y sobra decir que el Windows me va de PM .

Madre mía... no se si será imaginación mía, pero me parece que la herencia en C++ tiene más lío que en Java o C# .

Entonces, si te he entendido bien... y he entendido bien lo que he mirado en la web de C.Conclase, ¿la manera correcta de realizar el constructor de Player sería esta?:

Player(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive): Entity(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive)
 

¿O esta?:

Player(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive): Entity(SDL_Surface* graph), Entity(Sint16 x), Entity(Sint16 y), Entity(int speed), Entity(int acceleration), Entity(bool alive)
 

Según de lo que he me he enterado, el constructor de la clase derivada tiene que proporcionar los datos necesarios al constructor de la clase base, puesto que se llama primero al de la clase derivada, y luego al de la clase base...

Salu2


P.D: Jo, al final tengo que tener, en ambas clases, un constructor que es calcado al 99% .

El tema es, que ese constructor al principio no lo tenía, es más, no lo necesito para nada, puesto que Entity tiene ya el constructor que quiero usar (y el que esperaba que usase la clase Player... antes de leer por algunos sitios que la clase hija no hereda los constructores y destructores de la padre ).

La cosa es que, eliminando ese constructor vacío, y dejando la Entity con el suyo, y la Player con el suyo, el compilador me da el error ese de "no matching function for call to 'Entity::Entity()'.

Por una parte, no entiendo por qué narices se pone a buscar ese constructor vacío... y todavía me deja más a cuadros, el hecho de que el compilador me marque como error la línea en la que empieza la implementación del constructor de Player.

O sea, yo declaro y construyo mi toad, y en cuanto se intenta construir (yendo a su constructor), el compilador me dice que nanai, y me habla de un constructor vacío Entity... no lo entiendo la verdad .

Salu2

Esto... ¿Qué errores te marca?

La parte de la comparación yo la haría así:

if(strcmp(parte, "OLA") == 0)
cout << "si" << endl;
 

Usando strstr buscas la posición de la cadena 'parte' en la que se encuentra la cadena "OLA".

Aunque en el caso en que la cadena existente en 'parte' fuese "OLA" funcionaría, creo que es mejor usar strcmp, pues lo que hace es una comparación entre la cadena 1 y la cadena 2.

Si son iguales, devuelve 0, y sino, es que hay diferencias.

También creo que podrías simplemente hacer una comparación con ==, al estilo de:

if(parte == "OLA")

SAlu2

Bueno, dado que estoy estudiando C++, y dado que me interesa aprender a desenvolverme minimamente con la SDL para realizar juegos sencillos en 2D, me he puesto a intentar programar un jueguecillo de naves simple (aprendo SDL y gano experiencia con C++, 2 pájaros de un tiro ^^ ).

Estoy desarrollando con la última versión de Code::Blocks, liberada hace nada (la 10.05), y con la copia de MinGW que traía (sip, me interesa que lo que haga sea multiplataforma).

Bueno al lío, resulta que estoy teniendo un problema con Herencia que no consigo resolver. Hay que decir que, en lo que llevo estudiado de C++ hasta ahora en la "uni", todavía no hemos tocado herencia, pero dado que he tenido contacto con ella en Java y C#, pues, leyendo un poco por ahí y otro poco por allá... van saliendo las cosas.


En fin, el problema es el siguiente: Tengo una clase Entity, la cual es esta:

 
#ifndef _ENTITY_H
#define _ENTITY_H
 
#include <iostream>
#include <SDL_Image.h>
 
class Entity{
	protected:
		SDL_Rect canvas;
		SDL_Surface* graph;
		bool alive;
		int speed, acceleration;
 
	public:
        Entity();
		Entity(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive);
		void moveX(Sint16 amount);
		void moveY(Sint16 amount);
		SDL_Rect getCanvas();
		SDL_Surface* getGraph();
		int getSpeed();
		int getAcceleration();
		void setSpeed(int newSpeed);
		void setAcceleration(int newAcceleration);
 
};
 
#endif
 

 
#include "Entity.h"
 
Entity::Entity(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive){
    this->graph = graph;
 
	canvas.x = x;
	canvas.y = y;
	canvas.h = this->graph->h;
    canvas.w = this->graph->w;
 
    this->speed = speed;
    this->acceleration = acceleration;
    this->alive = alive;
}
 
void Entity::moveX(Sint16 amount){
	canvas.x += amount;
}
 
void Entity::moveY(Sint16 amount){
	canvas.y += amount;
}
 
SDL_Rect Entity::getCanvas(){
    return canvas;
}
 
SDL_Surface* Entity::getGraph(){
	return graph;
}
 
int Entity::getSpeed(){
    return speed;
}
 
int Entity::getAcceleration(){
    return acceleration;
}
 
void Entity::setSpeed(int newSpeed){
    speed = newSpeed;
}
 
void Entity::setAcceleration(int newAcceleration){
    acceleration = newAcceleration;
}
 

Y una clase Player:

#ifndef PLAYER_H_INCLUDED
#define PLAYER_H_INCLUDED
 
#include "Entity.h"
 
class Player: public Entity{
    private:
        bool mouseEnabled;
        bool keyboardEnabled;
        bool joystickEnabled;
 
        bool keyStates[233];
 
    public:
        Player(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive);
        void enableControl(bool keyboard, bool mouse, bool joystick);
        void keyboardHandler(SDL_KeyboardEvent keyEv);
};
 
#endif // PLAYER_H_INCLUDED
 

#include "Player.h"
 
Player::Player(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive){
    this->graph = graph;
 
	canvas.x = x;
	canvas.y = y;
	canvas.h = this->graph->h;
    canvas.w = this->graph->w;
 
    this->speed = speed;
    this->acceleration = acceleration;
    this->alive = alive;
}
 
void Player::enableControl(bool keyboard, bool mouse, bool joystick){
    this->keyboardEnabled = keyboard;
    this->mouseEnabled = mouse;
    this->joystickEnabled = joystick;
}
 
void Player::keyboardHandler(SDL_KeyboardEvent keyEv){
    if(keyEv.type == SDL_KEYDOWN){
        keyStates[keyEv.keysym.sym] = true;
    }else if(keyEv.type == SDL_KEYUP){
        keyStates[keyEv.keysym.sym] = false;
    }
 
 
    if(keyStates[SDLK_UP]){
        moveY(-speed + acceleration);
    }
 
    if(keyStates[SDLK_RIGHT]){
        moveX(speed + acceleration);
    }
 
    if(keyStates[SDLK_DOWN]){
        moveY(speed + acceleration);
    }
 
    if(keyStates[SDLK_LEFT]){
        moveX(-speed + acceleration);
    }
}
 

(Perdonad el supertocho, pero la culpa es del foro por no tener una mala etiqueta Spoiler para "plegarlo" )

Bueno, como se puede ver, mi intención es que la clase Player herede de la clase Entity, añadiendo ciertas cosas que tienen sentido para un jugador, pero que no tienen porqué existir para entidad genérica (vease bicho, bonus, etc ...).

Esta es la parte del main donde creo el objeto:

Player* toad = new Player(graphPool->getGraph(0), 100, 100, 10, 0, true);
 

(Lo de "toad" es simplemente porque... porque me ha dado la gana de hacer las pruebas de superficie con el personajillo del mario XD)


En fin, me pongo a compilar el "invento", y el Code::Blocks me dice que nanai:

Los errores de la discordia son los ennegrecidos. Es decir, se ubican en la tercera línea del Player.cpp, justo donde comienza el constructor de la clase.

Llevo no se el tiempo ya tratando de intuir qué demonios me está queriendo decir el compilador con lo de "referencia sin definir" ...

¿Alguna idea? .

Salu2


P.D: Se me ha ocurrido hacer un cambio, eliminar el Entity(); del Entity.h:

public:
        Entity();
	Entity(SDL_Surface* graph, Sint16 x, Sint16 y, int speed, int acceleration, bool alive);
 

Y el error que da ahora la compilación es este:

¿Las llaves de la segunda y última línea a qué corresponden?

No veo ningún while, if, for, etc ... por ahi .

Por otra parte, podrías poner simplemente un using namespace std, en vez de los 2 using que has colocado.

Aquí te dejo un ejemplo de la web de cplusplus, no aparece la comparación, pero bastaría con ubicarla en el sitio adecuado:


Salu2

Esto... Chonk, la etiqueta del code hay que cerrarla para que surta efecto, y según te puse en mi anterior mensaje, yo puse un espacio entre el '[' y la 'c' porque sino no podía mostrar la etiqueta, pero ese espacio lo necesitas quitar.

Es decir, sería de esta forma la cosa:

[/code]

Salu2


P.D: Bueno, no me ha salido exacto como quería que apareciera, pero da igual, se ve bien a lo que me refiero.