- Código: Seleccionar todo
class Clase
{
// Contenido de la clase
} ;
Para ir aprendiendo iremos haciendo una clase, al igual que hicimos a la hora de aprender las estructuras. Crearemos una clase que será nuestro personaje:
- Código: Seleccionar todo
class Personaje
{
// Contenido de la clase
} ;
Las clases tienen otra clasificación de las variables. Hay varias, pero usaremos las más usadas, las private y las public. En realidad las estructuras también las tienen, pero no importa.
Las variables public son las que se pueden acceder desde cualquier lado. Son por ejemplo las que solíamos utilizar en las estructuras, por ejemplo bala.x. Podíamos acceder a la variable x desde la función main.
En cambio, si las variables son privadas, serán accesibles mediante métodos de la clase. Los métodos no son más que funciones de las clases. Por defecto las variables serán privadas, así que deberemos indicar que usaremos variables públicas, así:
- Código: Seleccionar todo
class Personaje
{
public:
// Variables y métodos públicos
} ;
Por ahora no vamos a usar nada privado. Las variables de las clases son denominadas como “miembros”. Y las funciones se llaman “métodos”.
Las funciones de una clase son simples. Y para ejecutarlas hay que respetar lo siguiente; clase.metodo(argumento1,argument2).
Un poco de notación. Las variables de las clases (miembros) se les suele identificar con la letra m antes del nombre. De modo que queda de esta manera:
- Código: Seleccionar todo
int mX, mY ;
floar mVelocidad, mDireccion ;
Es una notación que se fue adaptando entre los programadores. No es obligatorio, pero es altamente recomendable.
Para hacer nuestra clase deberemos pensar que tipo de juego que querríamos hacer, nosotros imaginaremos que será para un juego de 4 direcciones. Algo simple, ya que no necesitaremos muchos datos.
Vamos a añadir constructores a nuestra clase, crearemos uno por defecto, y otro con el que podremos indicar la posición inicial:
- Código: Seleccionar todo
class Personaje
{
public:
int mX, mY ;
Personaje()
{
mX = 0 ;
mY = 0 ;
}
Personaje(int aX,int aY)
{
mX = aX ;
mY = aY ;
}
} ;
Esto ya deberíamos saber hacerlo teniendo en cuenta lo aprendido en el tema de las estructuras. Bien, ahora aprenderemos algo útil para evitar el uso de dos constructores cuando en este caso podemos hacerlo solamente en uno, para que así no tengamos que usar muchos constructores.
A los argumentos de un constructor (en este caso método), podemos darle un valor por defecto por si no le hemos especificado nada en él.
- Código: Seleccionar todo
Personaje(int aX = 0, int aY = 0)
{
mX = aX ;
mY = aY ;
}
Si nos fijamos en los argumentos, los hemos declarado dándoles un valor. Entonces si no especificamos nada en los argumentos, el valor de aX y xY será 0.
De todas formas hay un inconveniente de usar valores por defecto en los argumentos, y es que no podemos dar un valor al último argumento sin dar otro al anterior. Lo entenderemos mejor con ejemplos, crearemos un “personaje”:
- Código: Seleccionar todo
Personaje humano ;
En este caso, el constructor daría el valor por defecto a los dos argumentos, y la posición sería (0,0).
- Código: Seleccionar todo
Personaje humano(5,10) ;
En este segundo caso, hemos indicado los valores de los argumentos, de modo que la posición sería (5,10).
- Código: Seleccionar todo
Personaje humano(5) ;
También lo podemos hacer de esta manera, indicándole solamente el primer argumento y dejando el segundo por defecto. La posición sería (5,0).
Y aquí lo que no se puede hacer:
- Código: Seleccionar todo
Personaje humano(,10) ;
No está permitido realizar esta acción esperando a que la posición sea (0,10). De todas formas este inconveniente no nos da ningún problema.
Ahora vamos a añadir unos cuantos métodos (constructores de las clases) para realizar el movimiento en las 4 direcciones. Y antes de eso cambiaremos el tipo de variables a flota, ya que necesitaremos que se muevan a más velocidades y no solo con números enteros.
Vamos a crear el primer método, quedaría algo así:
- Código: Seleccionar todo
void MoverDerecha(float aVelocidad)
{
x += aVelocidad ;
}
Se supone que se entiende fácilmente, tenemos en cuenta de que como la función no nos devuelve valor lo declaramos como void. Por lo tanto sigamos a hacer los métodos de las demás direcciones, y al final nos quedaría así:
- Código: Seleccionar todo
void MoverDerecha(float aVelocidad)
{
mX += aVelocidad ;
}
void MoverIzquierda(float aVelocidad)
{
mX -= aVelocidad ;
}
void MoverArriba(float aVelocidad)
{
mY -= aVelocidad ;
}
void MoverAbajo(float aVelocidad)
{
mY += aVelocidad ;
}
Ahora continuamos dentro del main. Para empezar crearemos un “personaje” en la posición (400,400), por ejemplo.
- Código: Seleccionar todo
Personaje humano(400,400) ;
Vamos a hacer un simple sistema para mover a ese personaje por sus coordenadas, y veremos como cambia su posición. Aquí el main completo:
- Código: Seleccionar todo
int main()
{
Personaje humano(400.0f, 400.0f) ;
bool loop = true ;
float vel = 1.0f ; // Velocidad para mover al personaje
printf("1) Mueve al personaje hacia la derecha\n") ;
printf("2) Mueve al personaje hacia la izquierda\n") ;
printf("3) Mueve al personaje hacia abajo\n") ;
printf("4) Mueve al personaje hacia arriba\n") ;
printf("5) Salir\n") ;
while (loop)
{
printf("La posicion del humano es: (%f; %f)\n", humano.mX, humano.mY) ;
char opcion ;
opcion = getchar() ;
if (opcion == '1')
{
// Movemos al humano hacia la derecha
humano.MoverDerecha(vel) ;
}
else if (opcion == '2')
{
// Movemos al humano hacia la izquierda
humano.MoverIzquierda(vel) ;
}
else if (opcion == '3')
{
// Movemos al humano hacia abajo
humano.MoverAbajo(vel) ;
}
else if (opcion == '4')
{
// Movemos al humano hacia arriba
humano.MoverArriba(vel) ;
}
else if (opcion == '5')
{
// Terminar el programa
loop = false ;
}
}
return 0 ;
}
Bueno, vamos a analizar el código. Se supone que entendemos bien lo que ocurre hasta llegar al bucle while. Nos fijamos en que hemos iniciado el personaje en la posición (400,400).
Ahora entramos en el bucle while que no para de ejecutarse hasta que el valor de loop sea 0 (false). De modo que el programa no finalizará hasta que se pulse la tecla 5.
Dentro del bucle obtenemos la tecla pulsada mediante la función getchar(), que se encuentra en stdio.h, y lo guardamos en una variable char. Luego dependiendo de la tecla pulsada accederemos a los métodos correspondientes indicando su único argumento. De modo que se ejecutará esa función cambiando las variables que representan la posición del personaje.
Si se ha entendido bien llegamos al final. Eso es todo de momento sobre las clases, aunque hay mas cosas como herencia, polimorfismo etc., muy útil en los juegos.
saludos
