Lo realmente interesante de la programación orientada a objetos es los fácil que resulta que las clases interactuen entre si, sin necesidad de complicarnos la vida. La forma mas sencilla de relacionar dos clases sería instanciando en la clase ClaseUno un objeto de tipo ClaseDos:

claseuno.php:

<?php
require_once('clasedos.php');

class ClaseUno
{

    public function miMetodo(){

        $objDos = new ClaseDos();

    }

}

?>

clasedos.php:

<?php

class ClaseDos
{

}

?>

index.php:

<?php
require('claseuno.php');

$obj = new ClaseUno();
$obj->miMetodo();

?>

Como vemos solo hemos de requerir el script de ClaseDos en ClaseUno e instanciar el objeto dentro de uno de sus métodos, pero aun podemos complicar algo más la relación. Imagina que tienes una clase para representar un ordenador, el cual se compone a su vez de otros objetos como puede ser la pantalla, tarjeta grafica, ram, etcétera. Ninguno de esos componentes necesita la clase ordenador, pero la clase ordenador requiere de todos ellos para funcionar correctamente, en este caso podemos declarar varios atributos privados para representar todas sus piezas y luego instanciar en el mediante el método mágico __construct() cada una de ellas:

ordenador.php:

<?php
require_once('grafica.php');
require_once('ram.php');
require_once('pantalla.php');
require_once('hdd.php');

class Ordenador
{

    private $_tarjetaGrafica;
    private $_memoriaRam;
    private $_pantalla;
    private $_discoDuro;

    public function __construct(){

        $this->_pantalla = new Pantalla();
        $this->_memoriaRam = new Ram();
        $this->_discoDuro = new DiscoDuro();
        $this->_tarjetaGrafica = new Grafica();

    }

    public function apagar(){

        $this->_pantalla->apagar();
        $this->_tarjetaGrafica->ventiladorOff();
        $this->_discoDuro->PararDeGirar();
        $this->_memoriaRam->limpiar();

    }

}

?>

De esta forma cada objeto que puede funcionar correctamente por separado son parte esencial de un objeto mucho mas complejo.

Disponemos de otra forma para relacionar nuestras clases, pasando a un método de ClaseUno por parámetro un objeto de ClaseDos, de esta forma el objeto ha sido instanciado fuera de la clase y nosotros nos limitamos simplemente a manipular sus métodos o atributos públicos:

<?php

class ClaseUno
{

    public function metodoPublico(){
        echo "Hola";
    }

}

class ClaseDos
{

    public function imprimir( $claseUno ){

        $claseUno->metodoPublico();

    }

}

$obj = new ClaseDos();

$obj->imprimir( new ClaseUno() ); //Imprime: Hola

?>

Pero ¿que pasa si le pasamos como parámetros una objeto de clase diferente?, posiblemente nos de un error relacionado con el método que queríamos usar o simplemente la aplicación no funcionará como debería. Para solucionar esto podemos restringir el tipo de objeto que queremos pasar como parámetro añadiendo en el método el nombre de la clase y luego el parámetro:

public function imprimir(ClaseUno $claseUno){}

Esto solo nos permitiría que le pasáramos un objeto de ClaseUno, si intentamos pasar un objeto de otra clase nos tiraría un error tipo “Catchable fatal error: Argument 1 passed to ClaseDos::imprimir() must be an instance of ClaseUno, instance of ClaseTres given …”. Debemos de tener en cuenta que una clase hija que ha heredado de su clase padre tiene dos tipos, el de la clase propia y el de su clase padre, por lo que si restringimos el tipo a la clase padre, podemos pasarle una instancia de esta y una de la clase hija siendo ambas validas, pero al revés no, si restringimos por clase hija no podremos pasarle un objeto de la clase padre.

Pero en ocasiones por mantener una lógica con los nombres, o porque nuestra aplicación tiene un tamaño considerable podremos necesitar tener dos funciones, clases, constantes, etcétera con un mismo nombre, para eso existen los namespaces.

Aunque este ejemplo es muy típico he de decir que es realmente sencillo de comprender al verlo, se trata de comparar los namespaces con directorios de archivos, donde en la carpeta A contenemos un fichero llamado miFichero.txt, por lo que no podemos tener otro fichero con el mismo nombre, pero en la carpeta B podemos si podemos tener otro miFichero.txt, y para referirnos a uno u otro usamos el nombre del directorio más el del fichero, A/miFichero.txt y B/miFichero.txt.

Para declarar un espacio de nombre debemos usar la instrucción namespace seguido del nombre que queremos “reservar”, y siempre ha de ser en la linea siguiente al tag de apertura de php:

es.php:

<?php

namespace EspacioDeNombreUno;

function prueba(){

    echo "Espacio Uno";

}

?>

Al hacer esto todas las declaraciones debajo del namespace estarán englobadas por el, y dentro del mismo fichero no hay necesidad de usar ninguna instrucción extra para referirnos a las constantes, funciones o clases declaradas en el.

Creemos otra script que comparta el nombre de nuestra función, por ejemplo:

esdos.php:

<?php

namespace EspacioDeNombreDos;

function prueba(){

    echo "Espacio Dos";

}

?>

Ahora si queremos usar ambas constantes dentro de un mismo script deberemos de indicar mediante la sintaxis “namespace” + “\” + “nombre del elemento a llamar”:

<?php

require('es.php');

require('esdos.php');

EspacioDeNombreDos\prueba(); //Imprime: Espacio Dos

EspacioDeNombreUno\prueba(); //Imprime: Espacio Uno

?>

Como puedes ver hemos llamado a la función prueba indicándole en que namespace estaba la que queríamos reclamar y no ha generado ningún error por repetir el nombre.

Al igual que con un árbol de directorios podemos crear un árbol de namespaces añadiendo la barra invertida y un nombre a la declaración, por ejemplo:

<?php

namespace EspacioDeNombreUno;

function prueba(){

    echo "Espacio Uno";

}

namespace EspacioDeNombreUno\SubEspacio;

function prueba(){

    echo "Sub Espacio";

}

?>

Y para llamar a la función se realiza de la forma normal pero añadiendo el subdirectorio:

<?php

require('es.php');

EspacioDeNombreUno\prueba(); //Imprime: Espacio Uno

EspacioDeNombreUno\SubEspacio\prueba(); //Imprime: Sub Espacio

?>

Todo esto es muy útil, pero el tener que añadir el nombre de espacio más el sub-espacio cada vez que llamamos a una función o a cualquier otro elemento hace pesado y lento el desarrollo, para solucionar esto podemos asignarle un alias para indicarle al motor cual vamos a usar:

<?php

require('es.php');

use EspacioDeNombreUno\SubEspacio as subEs;

subEs\prueba(); //Imprime: Sub Espacio

?>

En caso de que no incluyas en la sentencia el “as Alias”, el motor concluirá que el alias es la ultima parte del árbol de namespaces, por lo que use EspacioDeNombreUno\SubEspacio dará como alias SubEspacio.

Para lograr simular algo parecido a la herencia múltiple existen los Traits. La forma de declararlos es similar a como declaramos una clase, salvo porque un Trait no puede ser instanciado, como una interfaz, pero a diferencia de la interfaz sus métodos si contienen cuerpo, veamos un ejemplo:

trait MiTrait {

    public function metodoUno(){

        echo "Método uno. ";

    }

    public function metodoDos(){

        echo "Método dos. ";

    }

}

Para usarlos en una clase solo hay que usar la instrucción use después de declarar la clase:

class MiClase{

    use MiTrait;

    public function __construct(){

        $this->metodoUno();

    }

}

Tambien podemos definir métodos abstractos de la misma forma que se definen en una clase abstracta, y así obligar a definir ese método en la clase que use el trait:

class MiClase{

    use MiTrait;

    public function __construct(){

        $this->metodoUno();

    }

    abstract public metodoAbstracto();

}

Pero la potencia de los traits va mas allá, ya que php nos permite usar varios dentro de una misma clase separando sus nombres mediante una coma “,”:

class MiClase{

    use MiTrait , MiTraitDos;

    public function __construct(){

        $this->metodoUno();

    }

}

La forma de declarar una interfaz es similar a como declaramos una clase, salvo que en vez de class se utiliza la instrucción interface seguido del nombre de esta:

<?php

interface MiInterface {

    public function metodoUno( $parametro );

    public function metodoDos( $parametro );

}

?>

Hay que tener en cuenta que una interfaz no permite definir atributos a implementar en las clases, solo métodos, y estos deberán ser públicos siempre. Se podría decir que la razón de existir de una interfaz es mejorar la forma en que interactúan las clases entre si, conociendo que interfaz implementa una clase sabremos los métodos públicos que deberá tener.

Para implementar una interfaz debemos de añadir en la declaración de la clase la instrucción implements seguido del nombre de nuestra interfaz:

<?php

class MiClase implements MiInterface {

}

?>

Pero no debemos de olvidar declarar y asignarles un cuerpo a los métodos nombrados en la interfaz o nos devolverá un error tipo “Fatal error: Class MiClase contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (MiInterface::metodoUno, MiInterface::metodoDos)”, lo correcto sería:

class MiClase implements MiInterface {

    public function metodoUno( $parametro ){
        //Cuerpo aquí
    }

    public function metodoDos( $parametro ){
        //Cuerpo aquí
    }

}

Como ejemplo de uso de las interfaces imaginemos una moto y un balón de fútbol, aparentemente no tienen nada en común por lo que la idea de heredar de una misma clase no tiene demasiado sentido, pero ambos son objetos que en algún momento se romperán, se puede crear una interfaz que declare el método romper() y implementarlo en las clases de ambos objetos, de esta forma nos aseguramos de que los dos aunque hereden de padres diferentes contienen el método romper().

Las entidades vienen a ser cualquier elemento del juego capaz de interactuar con el jugador, con otras entidades o con el sistema en si. Por ejemplo un botón de pause sería una entidad, el personaje del jugador sería otra entidad, los enemigos, las balas, obstáculos, en definitiva todo lo que realice alguna acción de forma activa mediante un evento previo, como un click, un choque con otra entidad, un temporizador, etcétera.

Las entidades en ImpactJS son clases extendidas de ig.Entity y siempre se han de guardar en lib/game/entities/, su estructura básica es esta:

ig.module(
    'game.entities.miEntidad'
)
.requires(
    'impact.entity'
)
.defines(function() {

    EntityMiEntidad = ig.Entity.extend({

        //Constructor
        init: function(x, y, settings) {
            this.parent(x, y, settings);
        }

    });

});

Revisemos por partes el código, primero tenemos la instrucción ig.module:

ig.module(
    'game.entities.miEntidad'
)

La cual define el directorio y el nombre del script que contiene la entidad, en este caso game/entities/miEntidad.js, la siguiente instrucción incluye las clases necesarias para que funcione nuestra entidad:

.requires(
    'impact.entity'
)

Su forma de definir el script es idéntica a la anterior, en este caso requiere el script impact/entity.js, como es lógico es necesaria la clase ig.Entity para poder extender de ella. Por ultimo tenemos:

.defines(function() {

    EntityMiEntidad = ig.Entity.extend({

        //Constructor
        init: function(x, y, settings) {
            this.parent(x, y, settings);
        }

    });

});

Si nos fijamos el nombre de la clase de nuestra entidad es EntityMiEntidad, esto ha de ser siempre así, me refiero a que hay una nomenclatura establecida en el motor, que es “Entity” mas el nombre del script con la primera letra en mayúsculas y sin extensión, si mi script se llama mula.js, el nombre de la entidad debe ser EntityMula, si no lo hacemos así el motor simplemente no funcionará y se quedará en la barra de carga al inicio, dando un error en la consola javascript. Otro dato importante es que las clases se definen en formato JSON.

Siempre que nuestras clases (en este caso una entidad) herede de otra deberemos añadir this.parent() en los métodos ya declarados en la clase padre para que todos funcione como debe, si lo omitimos, el método no hará las funciones para las que por defecto fue definido.

El método init siempre deberá tener 3 parámetros, la posición de la entidad dada en coordenadas (x,y),  y las propiedades del objeto. Aunque de momento no vamos a explicar esto, pero si que vamos a establecer propiedades básicas en nuestra entidad.

A simple vista podemos ver en el juego que hay 4 entidades bien definidas, el jugador, los escudos, los marcianos y el ovni. Los sprites tienen un tamaño de 50x50 cada uno, pero los personajes tienen un tamaño menor, vamos a ver como trabajar con esto. Empecemos con nuestro personaje:

ig.module(
    'game.entities.jugador'
)
.requires(
    'impact.entity'
)
.defines(function() {

    EntityJugador = ig.Entity.extend({

        //Pre-cargamos los sprites
        animSheet: new ig.AnimationSheet( '/space/media/personajes.png',50 , 50 ),

        //Tamaño de la entidad
        size: {x : 40 , y : 26 },

        //Numero de pixeles que eliminamos de los bordes
        offset: {x : 5, y : 12},

        //Constructor
        init: function(x, y, settings) {
            this.parent(x, y, settings);

            //Definimos la animación
            this.addAnim( 'normal' , 9999999 , [6]);

        }

    });

});

Por un lado tenemos la propiedad animSheet, donde hemos indicado el fichero que contiene los sprites, y el tamaño de cada sprite:

//Pre-cargamos los sprites
animSheet: new ig.AnimationSheet( '/space/media/personajes.png',50 , 50 ),

Por otro lado le hemos indicado el tamaño de nuestra entidad, que es de 40 de ancho por 26 de alto, pero indicándole mediante la propiedad offset cuando debe de restar a los bordes del sprite. Recuerda que nuestra entidad es más pequeña que el sprite seleccionado, por lo que si no definiéramos el offset el motor mostraría la imagen desde la esquina superior izquierda hasta el numero de pixeles indicados, y por lo tanto nos saldría cortada.

//Tamaño de la entidad
size: {x : 40 , y : 26 },

//Numero de pixeles que eliminamos de los bordes
offset: {x : 5, y : 12},

Una vez le hemos indicado que fichero contiene los sprites, las dimensiones de cada sprite, y las dimensiones de la entidad en si, nos dirigimos al método init para añadir la animación que tendrá nuestro personaje, aunque en este caso no hay animación propiamente dicha porque consta solo de un sprite:

init: function(x, y, settings) {
    this.parent(x, y, settings);

    //Definimos la animación
    this.addAnim( 'normal' , 9999999 , [6]);

}

Usamos this.addAnim para indicarle la animación que queremos, pasandole el nombre que le queremos dar (normal), el tiempo para que cambie a la siguiente (como solo es una he puesto un tiempo largo), y los sprites que queremos que cargue en forma de array y en el orden deseado, en el jugador es solo uno, pero su hubieran más se podrian así [0,1,2]. Hay que tener en cuenta que el motor divide el archivo de sprites por las dimensiones que le pasamos, y numera cada sprite empezando en cero.

 Ahora que tenemos nuestra entidad jugador creada vamos a probarla, nos dirigimos a lib/game/main.js y añadimos ‘game.entities.jugador’ en la zona de require, para cargar la entidad el iniciar el juego, esta zona se debería de ver así:

ig.module(
    'game.main'
)
.requires(
    'impact.game',
    'impact.font',
    'game.entities.jugador'
)

Ahora vamos al método init de MyGame para crear nuestra entidad mediante el método ig.game.spawnEntity( NombreClaseEntidad , x , y , propiedades en JSON):

init: function() {

    //Tecla de disparo
    ig.input.bind( ig.KEY.SPACE , 'fuego' );

    //Teclas de movimiento
    ig.input.bind( ig.KEY.LEFT_ARROW , 'izquierda' );
    ig.input.bind( ig.KEY.RIGHT_ARROW , 'derecha' );

    //Tecla de reinicio
    ig.input.bind( ig.KEY.ENTER , 'reinicio' );

    //Creamos nuestro jugador
    ig.game.spawnEntity( EntityJugador, 300, 300, {});

},

Una vez hecho al abrir http://localhost/spaceinvaders tendríamos que ver algo similar a esto:

Ahí tenemos nuestra primera entidad creada, pero aun no hace nada, vamos a dotarle de los movimientos básicos derecha e izquierda. Primero nos dirigimos al método update del main.js para eliminar las pruebas de teclado que habiamos hecho anteriormente, de forma que lo dejemos así:

update: function() {

    // Update all entities and backgroundMaps
    this.parent();

},

Ahora nos dirigimos a la clase de nuestra entidad jugador lib/game/entities/jugador.js. Para controlar el movimiento del personaje debemos de modificar la propiedad this.vel (velocidad), la cual nos permite indicarle a la entidad hacia donde debe moverse mediante valores en los ejes x o y, de forma que “x” en un valor negativo movería la entidad hacia la izquierda y en positivo hacia la derecha, de la misma forma “y” en negativo haría subir la entidad y en positivo la haría descender. Vamos a crear nosotros dentro de EntityJugador el método update, y en su interior comprobar que tecla se está pulsando y modificar this.vel.x en consecuencia:

update: function(){
    this.parent();

    //Movemos el personaje
    if(ig.input.state('izquierda')){
        this.vel.x = -100;
    }

    if(ig.input.state('derecha')){
        this.vel.x = 100;
    }

    //Paramos el movimiento al soltar alguna tecla.
    if(ig.input.released('izquierda') || ig.input.released('derecha')){
        this.vel.x = 0;
    }

}

Nuevamente nos dirigimos a http://localhost/spaceinvaders y comprobamos como ahora al pulsar las flechas izquierda o derecha de nuestro teclado el personaje responde moviéndose hacia donde le indicamos.

En el próximo artículo empezaremos a trabajar con el editor de niveles donde colocaremos las entidades, creamos un fondo para el tapiz, ectétera.

Anterior: Primeros pasos con la librería.
Código: https://github.com/Nazariglez/spaceinvaders

Antes de nada deberías de familiarizarte con la estructura de directorios del motor. Al entrar en directorio donde lo hemos instalado vemos tres archivos y otros directorios en su interior, voy nombrarlos uno a uno:

• index.html: Este archivo contiene el elemento canvas y incluye la librería impact y nuestro juego, es a través del el por donde jugaremos a nuestra obra.
• LICENSE.TXT: No hace explicar, dentro contiene la licencia legal del motor.
• weltmeister.html: Este archivo hace las veces de editor de nivel a través del navegador.
• tools/: Este directorio contiene los scripts necesarios para llevar a cabo la empaquetación del juego antes de ser distribuido.
• media/: En este directorio es donde debemos ubicar todas nuestros sprites, imágenes, música, etcétera. No tiene subdirectorios definidos por lo que nosotros podemos organizar nuestros archivos como queramos.
• lib/: Este directorio contiene a su vez tres subdirectorios, que son:

1. weltmeister/: Contiene todos los archivos necesarios para que el editor de niveles funcione.
2. impact/: Es el corazón de la librería, en este directorio se encuentran todos los scripts que conforman el motor. Por lo general no necesitaremos modificar nada en este directorio.
3. game/: Es el directorio en el que trabajaremos, contiene el archivo main.js que se podría decir que es el script principal de nuestro juego, y dos directorios más, entities donde almacenamos las entidades que creamos y levels para almacenar los niveles que diseñamos.

Una vez entendemos como se distribuye el motor empezamos con nuestro juego, por lo general trabajaremos siempre sobre el directorio game/ y los archivos index.html y weltmeister.html.

Lo primero que vamos a hacer es modificar el tamaño de nuestro tapiz, para esto debemos de dirigirnos al archivo lib/game/main.js y buscar al final del mismo la siguiente linea:

// Start the Game with 60fps, a resolution of 320x240, scaled
// up by a factor of 2
ig.main( '#canvas', MyGame, 60, 320, 240, 2 );

La instrucción ig.main() es la encargada de iniciar el juego, se le pasa la id del elemento canvas (#canvas), la clase principal del juego, en este caso MyGame, el numero de frames por segundo deseados que suele ser 60, aunque las ultimas versiones de Impact usa requestAnimationFrame por lo que es posible que no tome en cuenta este parámetro, el ancho y el alto del tapiz, y el valor de escalado que es el factor por el que se multiplica el tamaño del tapiz. Nosotros vamos a modificar solamente el ancho, el alto y la escala dejándolo así:

// Ancho: 520, Alto: 600, Escala: 1
ig.main( '#canvas', MyGame, 60, 520, 600, 1 );

Si nos dirigimos ahora a http://localhost/spaceinvaders/index.html (recuerda que spaceinvaders es el nombre que yo le di a mi carpeta) veremos que el tapiz ha cambiado de tamaño y que la frase “It Works!” se ve más pequeña, esto es debido a que antes estaba aumentada por dos, y ahora el factor de escalado es 1.

El siguiente paso es definir que teclas vamos a permitir usar para interactuar con nuestro juego, esto lo haremos en el método init de la clase MyGame contenida en lib/game/main.js. El método init hace las veces de constructor de la clase, ejecutándose solamente al inicio de esta.

Para declarar que tecla queremos que se puedan usar utilizaremos la instrucción ig.input.bind( claveDeTecla , ‘nombrePersonalizado’), en este caso vamos a usar la barra espaciadora para disparar, las flechas izquierda y derecha para mover al personaje, y la tecla enter para reiniciar el juego cuando el personaje muera. El método init quedaría así:

init: function() {

    //Tecla de disparo
    ig.input.bind( ig.KEY.SPACE , 'fuego' );

    //Teclas de movimiento
    ig.input.bind( ig.KEY.LEFT_ARROW , 'izquierda' );
    ig.input.bind( ig.KEY.RIGHT_ARROW , 'derecha' );

    //Tecla de reinicio
    ig.input.bind( ig.KEY.ENTER , 'reinicio' );

},

Como de momento no tenemos ninguna entidad creada vamos a probar que las teclas funcionan correctamente mediante firebug, para esto vamos a añadir unas lineas al método update de la clase MyGame. Este método es el encargado de estar actualizando continuamente todo lo que sucede en el juego.

Para controlar el estado de una tecla la clase ig.input provee de tres métodos muy simples:

• ig.input.pressed: Se dispara solo en el momento en el que la tecla ha sido pulsada.
• ig.input.state: Devuelve true siempre que la tecla siga pulsada, a diferencia de pressed que solo salta una vez.
• ig.input.released: Se dispara cuando la tecla deja de ser presionada.

Para probar nuestras teclas vamos a dejar el método update así:

update: function() {

    // Update all entities and backgroundMaps
    this.parent();

    //Si se pulsan teclas de dirección
    if( ig.input.state( 'izquierda' ) || ig.input.state( 'derecha' ) ){
        console.log('Pulsando teclas de dirección.');
    }

    //Al pulsar la tecla de disparo
    if( ig.input.pressed( 'fuego' ) ){
        console.log('Un Disparo.');
    }

    //Al soltar la tecla de reinicio
    if( ig.input.released( 'reinicio' ) ){
        console.log('Reiniciando.');
    }

},

Ahora podemos dirigirnos de nuevo a nuestro juego en el navegador y abrir firebug o la consola javascript, al pulsar las teclas de dirección veras como se repite continuamente el mensaje de “Pulsando teclas de dirección”, al presionar la barra espaciadora verás por cada vez que es presionada el mensaje “Un Disparo.” y al presionar y luego soltar la tecla enter verás el mensaje “Reiniciando.”. De esta forma hemos probado que nuestras teclas funcionan correctamente y además hemos aprendido como funcionan los eventos relacionados con estas.

Visto esto hasta aquí empezaremos a crear entidades en el próximo artículo.

Anterior: Mecánica, reglas del juego e instalación de la librería.
Siguiente: Estructura básica de las entidades.
Código: https://github.com/Nazariglez/spaceinvaders 

PelotaBase.php:

<?php

class PelotaBase
{

    protected $peso = 0;
    protected $textura = 'lisa';
    protected $color = 'ninguno';

    public function rebotar(){

        echo "Estoy rebotando";

    }

    public function rodar(){

        echo "Estoy rodando";

    }

    public function __toString(){

        return "Soy " . get_called_class() . " y peso {$this->peso}, mi textura es {$this->textura}, y mi color {$this->color}";
    }

}

?>

Nótese que uso get_called_class() en vez de la constante mágica __CLASS__, esto se debe a que si usáramos la constante el nombre que nos devolvería seria el de la PelotaBase, y yo quiero el nombre de la clase que ejecuta el método, no donde se declaro, por eso usando get_called_class() obtenemos el nombre de la clase hija que lo esta ejecutando.

Veamos ahora las clases “hijas”:

PelotaDeTenis.php:

<?php

require_once('PelotaBase.php');

class PelotaDeTenis extends PelotaBase
{

    public $peso = 1;
    public $textura = 'Peluda';
    public $color = 'Verde';

}

?>

PelotaDeFutbol.php:

<?php

require_once('PelotaBase.php');

class PelotaDeFutbol extends PelotaBase
{

    public $peso = 2;
    public $textura = 'Cuero';
    public $color = 'Blanca y Negra';

}

?>

PelotaDeBaloncesto.php:

<?php

require_once('PelotaBase.php');

class PelotaDeBaloncesto extends PelotaBase
{

    public $peso = 3;
    public $textura = 'Rugosa';
    public $color = 'Naranja';

}

?>

Como ves son idénticas, las tres heredan de PelotaBase y la única diferencia de una a otras son los atributos para adecuarlos a sus propiedades reales, veamos el script:

script.php:

<?php

require_once('PelotaBase.php');
require_once('PelotaDeTenis.php');
require_once('PelotaDeFutbol.php');
require_once('PelotaDeBaloncesto.php');

$tenis = new PelotaDeTenis();
echo $tenis; //Imprime: Soy PelotaDeTenis y peso 1, mi textura es Peluda, y mi color Verde

$futbol = new PelotaDeFutbol();
echo $futbol; //Imprime: Soy PelotaDeFutbol y peso 2, mi textura es Cuero, y mi color Blanca y Negra

$baloncesto = new PelotaDeBaloncesto();
echo $baloncesto; //Imprime: Soy PelotaDeBaloncesto y peso 3, mi textura es Rugosa, y mi color Naranja

?>

De esta forma hemos conseguido que usando la misma clase como base tengamos comportamientos diferentes, los cuales podemos modificar a nuestro antojo, añadirle nuevas funcionalidades o sustituir las ya declaradas por otras más acordes a nuestro objeto.

Quizás no lo veas aun pero el polimorfismo es esencial, imagina una clase “trabajador”, que sirve de base para las clases director, albañil, programador, etcétera, todas comparten una base pero su misión final es muy diferente, esto nos ayuda a programar código mas eficiente, tenemos todo bien localizado y no es necesario modificar un sin numero de clases para realizar cambios simples porque lo haríamos en la clase “padre“.

Las clases abstractas se declaran con la instrucción “abstract”, estas no necesitan ser instanciadas, así que podemos acceder a sus métodos de forma similar a la que se accedería a un método estático. Veamos un ejemplo:

ClaseAbstracta.php:

<?php

abstract class ClaseAbstracta
{

    public function miMetodo(){

        echo "Método de una clase abstracta.";

    }

}

?>

script.php:

<?php

require_once('ClaseAbstracta.php');

ClaseAbstracta::miMetodo();

?>

Por lo general declaramos una clase como abstracta cuando sabemos que no ha de ser instanciada y que su función es servir de clase “padre” a otra clase mediante la herencia, donde la clase “hija” si será instanciada.

Podemos marcamos métodos como abstractos (siempre dentro de una clase abstracta) pero estos no podrán tener cuerpo o dará un error tipo “Fatal error: Abstract function ClasePadre::miMetodo() cannot contain body”, además al ser heredada, la clase “hija” estará obligada a declarar y asignarle un cuerpo a los métodos que hemos marcamos como abstractos en la clase “padre” o provocaremos un error.

ClaseAbstracta.php:

<?php

abstract class ClaseAbstracta
{

    //Declaro el método como abstracto sin cuerpo.
    abstract public function metodoDos();

    public function miMetodo(){

        echo "Método de una clase abstracta.";
    }

}

?>

ClaseHija.php:

<?php

require_once('ClaseAbstracta.php');

class ClaseHija extends ClaseAbstracta
{

    //Método declarado por obligación al heredar de ClaseAbstracta
    public function metodoDos(){
        //Lo que quieras
    }

}

?>

Ahora simplemente debemos de instanciar ClaseHija y tendremos nuestro objeto extendido de la clase abstracta. Hay que tener en cuenta que no es posible dentro de una clase normal (no abstracta) tener métodos abstractos.

Todos sabemos en que consiste un Space Invaders, el jugador debe eliminar uno a uno un conjunto de marcianos situados en una posición superior, los cuales se mueven como un bloque y disparan contra el jugador. También tenemos unos escudos a modo de protección para el jugador, que van destruyendo a consecuencia de los disparos, y de forma aleatoria aparece un ovni por encima del bloque de marcianos que otorga un bonus de puntuación si logramos alcanzarlo con un disparo.

No parece demasiado complicado, vamos por partes.

El jugador

El jugador tendrá los movimientos bastante limitados, las únicas acciones permitidas serán moverse a la derecha e izquierda y disparar un solo laser cada vez, esto es que mientras el laser siga en escena no se permitirá que realice otro disparo.

Los marcianos

Hay 3 tipos de marcianos, el pulpo, el cangrejo y la medusa. Todos ellos funcionan de forma similar, lo único que cambia de uno a otro es la probabilidad de realizar un disparo y la puntuación que otorga en caso de ser eliminado. La medusa otorgará 30 puntos, el cangrejo 20 y el pulpo 10. Se moveran como un bloque de forma que cuando uno de ellos “choque” con una de las “paredes” laterales del juego el y todos los demás se moverán en sentido contrario, también por cada “choque” descenderán toscamente un poco en la escena para ir ganando comiendo terreno hacia abajo.

El ovni

El ovni entra en escena basándose en un tiempo calculado al azar basándose en un máximo y un mínimo de tiempo posibles. No podrá disparar ni realizar ninguna acción que no sea atravesar la escena de izquierda a derecha. Su puntuación será calculada al azar, y cuando aparece se detiene la música para sonar una melodía diferente hasta que sale de la escena.

Los escudos

Los escudos serán pequeñas partículas que se podrán destruir dando igual que el laser provenga de los marcianos o del jugador. También se destruirán si un marciano los toca. En principio habrán cuatro bloques de escudos.

El laser

El láser es lo que dispara el jugador y los marcianos, su único cometido es eliminar todo lo que toque dependiendo de quien lo lance, ya sea eliminar los escudos, los marcianos o al jugador. Su movimiento será ascendente cuando el disparo lo produce el jugador o descendente cuando proviene de los marcianos. Si no impacta contra ninguna entidad el láser se eliminara al tocar el limite superior o inferior establecido.

Aumentando la dificultad

Cuando el jugador elimina todo un bloque de marcianos se reinicia el nivel aumentando las probabilidades de disparo de los marcianos, haciendo así más difícil el juego cada vez que se termina un nivel.

Fin del juego

El juego terminará cuando un laser marciano alcance al jugador, cuando un marciano baje tanto que toque al jugador o simplemente cuando un marciano toque el limite inferior establecido. Cuando pase algo de esto se pausara el juego mostrando un menú con la puntuación obtenida y se activara una tecla para reiniciar el juego.

Instalación de la librería

Primero debemos de dirigirnos a ImpactJS y comprar una licencia del programa, y empezar a descargar el zip de la librería. Para usar la librería debemos de tener un servidor web instalado, si no tienes ninguna puedes usar XAMPP.

Una vez descargada la librería en nuestro pc debemos de descomprimirla dentro de una carpeta del servidor, yo he creado una carpeta llamada “spaceinvaders”, ahora nos dirigimos a nuestro navegador web preferido y entramos en http://localhost/spaceinvaders (sustituye spaceinvaders por el nombre de tu carpeta) y deberíamos ver algo así:

¡Ya tenemos ImpactJS funcionando!, me gustaría añadir que aunque a diario suelo usar Chrome, prefiero usar para probar y desarrollar cualquier cosa en javascript Firefox + Firebug, pero esto ya es elección de cada uno.

Como ves hasta aquí es bastante sencillo, el proximo articulo será más practico, empezaremos a trastear con la libreria.

Indice: http://www.nazariglez.com/2013/02/23/desarrollando-space-invaders-en-html5-con-impactjs/
Siguiente: Primeros pasos con la librería.

ClasePadre.php:

<?php

class ClasePadre
{

    public $atributo = 'Atributo Padre';

    public function __construct(){

        echo __CLASS__;

    }

    //Método privado
    private function miMetodo(){

        echo "Método Padre";
    }

}

?>

ClaseHija.php:

<?php

require_once('ClasePadre.php');

class ClaseHija extends ClasePadre
{

    //Lamamos de forma interna al método miMetodo como si fuera de esta clase.
    public function llamarMetodo(){

        $this->miMetodo();
    }

}

?>

script.php:

<?php

require_once('ClaseHija.php');

$obj = new ClaseHija(); //Imprime: Clase Padre

echo $obj->atributo; //Imprime: Atributo Padre

$obj->llamarMetodo(); //Imprime error: Fatal error: Call to private method ClasePadre::miMetodo() from context 'ClaseHija'

?>

He intentado llamar de forma interna al método de la clase “padre” miMetodo() pero este al ser privado nos ha devuelto un error, como te imaginarás al marcar como privado un método o atributo no permite ni tan siquiera ser usado por una clase “hija”. ¿La solución es marcarlos como públicos?, no. Como ya explique en tema de “entendiendo la visibilidad” existe otro nivel de protección llamado protected, este nivel se puede decir que es similar a declarar como privado un atributo puesto que bloquea el acceso desde fuera de la clase, pero ahora si que nos permite que las clases “hijas” puedan acceder y manipular el atributo o método en cuestión, hagamos una prueba modificando la clase “padre”:

ClasePadre.php:

<?php

class ClasePadre
{

    public $atributo = 'Atributo Padre';

    public function __construct(){

        echo __CLASS__;
    }

    //Método Protegido
    protected function miMetodo(){

        echo "Método Padre";
    }

}

?>

script.php:

<?php

require_once('ClaseHija.php');

$obj = new ClaseHija(); //Imprime: Clase Padre

echo $obj->atributo; //Imprime: Atributo Padre

$obj->llamarMetodo(); //Imprime: Método Padre

$obj->miMetodo(); //Imprime error: Fatal error: Call to protected method ClasePadre::miMetodo() from context ''

?>

Ahora hemos realizado dos llamadas, una interna a través del método de la clase “hija” llamarMetodo() y una de forma externa. La llamada interna nos ha devuelto el resultado esperado que no es más que la impresión en pantalla de “Método Padre”, pero la llamada externa nos devuelve un error de acceso. Esto quiere decir que el nivel protected nos ha permitido heredar el método para acceder internamente desde la clase “hija” pero no de forma publica.

Hay que tener en cuenta que los niveles nunca pueden ser más restrictivos en la clase “hija” que en la clase “padre”, esto significa que si un método en la clase “padre” es publico en la hija deberá serlo, pero si en la padre es private o protected, en la hija podrá ser publico.

Podría darse el caso de que al diseñar una clase no quisiéramos que se pudiera heredar, para evitar la herencia provocando un error al intentarlo solo tenemos que añadir en la declaración de la clase el operador final:

ClasePadre.php:

<?php

final class ClasePadre
{

    public $atributo = 'Atributo Padre';

    public function __construct(){

        echo __CLASS__;
    }

    //Método Protegido
    protected function miMetodo(){
        echo "Método Padre";
    }

}

?>

Esto genera un error tipo “Fatal error: Class ClaseHija may not inherit from final class (ClasePadre)” debido a que hemos bloqueado la herencia para ClasePadre. Si lo que queremos es simplemente evitar que se sobrescriba un método, para así asegurarnos de que siempre se ejecutara tal y como se ha definido en la clase “padre” lo que debemos de hacer es añadir el operador final en su declaración:

ClasePadre.php:

<?php

class ClasePadre
{

    public $atributo = 'Atributo Padre';

    public function __construct(){

        echo __CLASS__;
    }

    //Método imposible de sobrescribir
    public final function miMetodo(){

        echo "Método Padre";
    }

}

?>

Por lo general el operador final no se suele usar, salvo raras excepciones dado que la potencia de los objetos reside en la posibilidad de heredar y extender las funcionalidades de las clases.