Manejamos para el ejemplo una tabla entradas, que trata sobre la entradas de un blog y que almacena básicamente la siguiente información: identificador, título, cuerpo y tiempo de salida.

DELETE

Borra una serie de filas de la tabla. Podemos usar una claúsula WHERE para limitar las filas a borrar, a las que cumplan una condición. La sintaxis sería:

DELETE FROM nombre_tabla WHERE condicion

Para nuestro caso:

DELETE FROM entradas WHERE id = 2;

TRUNCATE

A diferencia de DELETE, TRUNCATE elimina todas las filas de la tabla sin borrar la tabla. También resetea los contadores de auto incremento a 0. No borra la tabla como tal, la llamada estructura, por lo que luego puede comenzar a hacer inserciones. La sintaxis es:

TRUNCATE TABLE nombre_tabla;

Y para nuestro caso:

TRUNCATE TABLE entradas;

DROP

Finalmente llegamos a DROP. A diferencia de la anterior, DROP no sólo elimina los datos, sino que también eliminar la estructura de la tabla.

DROP TABLE nombre_tabla;

Y para nuestro caso:

DROP TABLE entradas;

DROP DATABASE

A modo de bonus os traigo una instrucción más. Es idéntica a la anterior pero en lugar de borrar una tabla, borra una base de datos al completo. Podemos incluir en la sentencia IF EXISTS de forma que evitemos el error en caso de que no exista la base de datos (muy útil a la hora de hacer copias de seguridad de las bases de datos).

DROP DATABASE [IF EXISTS] nombre_base_datos;

Y para nuestro caso:

DROP DATABASE blog;

Señalar que en MySQL no eliminar la estructura de permisos asociada a la base de datos. Para ello usaremos GRANT, pero de eso ya hablaremos en otra entrada en la que comentaremos los permisos con MySQL.

La solución es usar un servidor SMTP externo, aquí mismo explicamos cómo hacer uso del servidor SMTP de Gmail para usarlo dentro de WordPress, pero vamos a explicaros un método válido para cualquier aplicación que desarrolléis con PHP.

Lo primero que tenemos que hacer es descargar la clase que se encargará del trabajo, es software libre bajo licencia GPL, hablamos del proyecto PHPMailer. Descargamos la última versión disponible para nuestra versión de PHP (aquí hablaremos de la versión más actual, la que corresponde con PHP 5) y descomprimimos.

La clase tiene otras funcionalidades, pero nosotros como sólo vamos a enviar correo, usaremos el código de los ficheros:

• class.phpmailer.php
• class.smtp.php

El procedimiento es el siguiente: incluimos los ficheros en cuestión, instanciamos un objeto, asignamos sus atributos (asunto, remitente, destinatario, cuerpo del mensaje) y finalmente ejecutamos un método que lo envía.

Veamos un ejemplo completo:

require(‘class.phpmailer.php’);
require(‘class.smtp.php’);
$mail = new PHPMailer();
$body = “Cuerpo del mensaje”;
$mail->IsSMTP();
// la dirección del servidor, p. ej.: smtp.servidor.com
$mail->Host = “direccion_servidor”;
// dirección remitente, p. ej.: no-responder@miempresa.com
$mail->From = “Dirección_remitente”;
// nombre remitente, p. ej.: "Servicio de envío automático"
$mail->FromName = “Nombre_remitente”;
// asunto y cuerpo alternativo del mensaje
$mail->Subject = “Asunto”;
$mail->AltBody = “Cuerpo alternativo
    para cuando el visor no puede leer HTML en el cuerpo”;
// si el cuerpo del mensaje es HTML
$mail->MsgHTML($body);
// podemos hacer varios AddAdress
$mail->AddAddress(“dirección_destino”, “Nombre_destino”);
// si el SMTP necesita autenticación
$mail->SMTPAuth = true;
// credenciales usuario
$mail->Username = “Usuario”;
$mail->Password = “Contraseña”;
if(!$mail->Send()) {
echo “Error enviando: ” . $mail->ErrorInfo;
} else {
echo “¡¡Enviado!!”;
}

A día de hoy, es básico integrar las redes sociales en nuestros sitios web para aprovechar todas las sinergias posibles. Un ejemplo de ello es Twitter y las posibilidades que nos ofrece: compartir enlaces, twittear, seguir, etiquetar o mencionar.

Podemos dejar al usuario, que copie nuestra URL y se encargue de difundirnos voluntariamente o podemos intentar facilitarle la vida. Si usas WordPress puedes usar uno de los múltiples plugins disponibles. Si no lo usas o quieres hacerlo a mano incluso con WordPress sigue los pasos que aquí vamos a comentar.

Primero, accedemos a la web de recursos pertinente de Twitter: Botones de Twitter. Elegimos el botón, por ejemplo “Seguir” y rellenamos en el formulario que aparece. Dentro de él:

• Nombre de usuario
• Si el botón es grande
• Idioma

Y nos devolverá el enlace listo para insertar en código HTML.

Imaginemos que guardamos las cantidades de un determinado importe en DOUBLE, al hacer una consulta nos sale una cantidad de números decimales demasiado grande. La idea es redondear el número de forma que sólo aparezcan sólo dos decimales:

SELECT ROUND(importe, 2)
FROM compras;

Si queremos formatear el número de forma que aparezca separado por comas los miles y por un punto la parte decimal (estilo americano), usaremos la función FORMAT. También le indicamos cuántos decimales queremos.

SELECT FORMAT(12332.1,4);

La salida sería: ’12,332.1000′ y será una cadena, no un número.

En MySQL esta operación puede ser directa, imaginemos una tabla personas con la siguiente estructura:

• DNI: varchar que es clave primaria
• Nombre: varchar
• Apellidos: varchar

Queremos hacer una consulta en la que aparezca el dni seguido de los apellidos y el nombre unidos y separados por una coma. Sólo tendremos que hacer lo siguiente, usar la función CONCAT():

SELECT dni, CONCAT(apellidos, ', ', nombre)
FROM personas;

La función acepta un número indeterminado de parámetros de tipo cadena y devuelve la concatenación de las mismas.

Sin embargo, no siempre será la misma ruta ya que nuestro plugin o tema puede que esté instalado en un directorio no estándar o que la llamada se haga estando en un directorio a un nivel distinto. Para ahorrarnos problemas de rutas os presento el método siguiente:

while(!is_file('wp-config.php')){
  if(is_dir('../'))
      chdir('../');
  else
      die('Could not find WordPress.');
}

Una vez lo habéis encontrado, podéis incluirlo:

include( 'wp-config.php' );

O mostrar el directorio en cuestión con la función oportuna:

getcwd()

Si hacemos una llamada del siguiente tipo (la dirección IP es la del servidor DNS de la UCO): http://www.geoplugin.net/php.gp?ip=150.214.110.3, obtenemos una salida en forma de cadena con un objeto de PHP serializado.

Por lo tanto nos limitaremos a:

1. Hacer una llamada a dicho servicio web
2. Descargar el resultado de la petición en forma de cadena con la función file_get_contents()
3. Usar el proceso inverso a serializar para recuperar los diferentes valores

Podemos usar $_SERVER['REMOTE_ADDR'] para obtener la dirección IP de nuestro visitante. Aquí tenéis un ejemplo completo:

$meta = unserialize(file_get_contents('
http://www.geoplugin.net/php.gp?ip='.$_SERVER['REMOTE_ADDR']));
$latitud = $meta['geoplugin_latitude'];
$longitud = $meta['geoplugin_longitude'];
$ciudad = $meta['geoplugin_city'];

Algunos plugins y temas nos proporcionan más códigos cortos de este tipo. Sin embargo, si manejáis la API de WordPress, a lo mejor vosotros mismos queréis crear vuestros propios shortcode. ¿Cómo?

Uniendo un shortcode a una función. Si no tenemos atributos es directo:

//[mishortcode]
function mishortcode_func( $atts ){
 return "Este es mi shortcode";
}
add_shortcode( 'mishortcode', 'mishortcode_func' );

En caso de que tengamos atributos, habrá que descomponer el array de atributos que recibe la función.

// [mishortcode miatributo0="mivalor0" miatributo1="mivalor1"]
function mishortocde_func( $atts ) {
	extract( shortcode_atts( array(
		'miatributo0' => 'mivalor_por_defecto_0',
		'miatributo1' => 'mivalor_por_defecto_1',
	), $atts ) );
	return "He recibido = {$miatributo0} y {miatributo1}";
}
add_shortcode( 'mishortcode', 'mishortocde_func' );

En este caso, soportará hasta dos atributos. Si no se le pasa ningún atributo, cogerá los dos por defecto y en caso de que se le pase uno o los dos, estos serán sus valores y el que no reciba valor, recibirá el valor por defecto que le hemos asignado. Igual que en PHP (en esta entrega del curso de PHP se explica cómo se puede simular la sobrecarga usando atributos por defecto).

Dentro de los modelos de negocio del software libre, la consultaría es un pilar básico. Existe el asesoramiento clásico, donde particulares o empresas ofrecen mediante comunicaciones a otros particulares o empresas; soluciones para problemas puntuales.

Sin embargo, gracias a los sistemas en la nube, es posible extrapolar este servicio para hacerlo llegar al gran público. WordPress Questions es un proyecto creado por Lawrence Krubner y Darren Hoyt. Nos ofrece una plataforma en la que todos podemos ser:

• Asesores de WordPress, recibiendo una recompensa económica por cada asesoramiento prestado
• Usuarios, podemos preguntar cualquier cosa sobre WordPress y obtener una respuesta rápida y fiable a cambio de un precio que nosotros fijaremos entre 1 y 100 dólares.

Os dejo un vídeo presentándolo (está en inglés):

Warning: Cannot modify header information – headers already sent by

Que también podemos encontrar como “Warning: session_start(): Cannot send session cache limiter – headers already sent” o “Warning: session_start() [function.session-start]: Cannot send session cookie – headers already sent by“. Se produce cuando intentamos modificar las cabeceras del paquete HTTP, cuando ya hemos dejado de emitirlas y estamos emitiendo el cuerpo del paquete.

¿Por qué ocurre esto? Podéis verlo dentro del protocolo. Para solucionarlo deberemos ser muy cuidadosos en dos aspectos:

• Nunca comenzar a emitir el cuerpo antes de tiempo, con un sólo espacio en blanco delante de <?php  ya habríamos provocado el problema (se empieza a emitir un espacio en blanco como parte del cuerpo).
• No emitir la cabecera en mitad del cuerpo. Es decir, no usar funciones que la puedan modificar como session_start, cuando estamos ya en el cuerpo de nuestro contenido HTTP.

Fatal error: Cannot redeclare nombre_función

En PHP no existe la sobrecarga (aunque podéis imitarlas), por lo tanto las declaraciones de las funciones serán únicas en todo el código. Si estamos trabajando en un proyecto grande y queremos asegurarnos que la función se declara cuando no exista y no se declare cuando sí exista hacemos lo siguiente, usar function_exists de PHP, veamos un ejemplo.

if(!function_exists('mi_funcion'))
{
    function mi_funcion()
    {
        /* */
    }
}

Notice: A session had already been started – ignoring session_start()

La situación es la siguiente, tenemos la sesión iniciada, con session_start() y debido a que cargamos otro componente de la página que no sabe si la sesión está iniciada, volvemos a hacer la llamada. No se trata de un error sino de una notice, pero aún así podemos evitarla:

if (!isset ($_COOKIE[ini_get('session.name')])){
    session_start();
}

Notice: Constant MI_CONSTANTE already defined in

Cuando usamos constantes en PHP (para guardar por ejemplo los datos de conexión a la base de datos), es posible que redeclaremos en dos script diferentes la misma variable y salte un aviso. Para evitarlo haremos lo siguiente:

if (defined('PRUEBA')){
    echo PRUEBA;
}

Notice: Use of undefined constant MI_CONSTANTE – assumed ‘MI_CONSTANTE’

Si a la hora de definir constantes cometemos el error de no usar comillas (me da la sensación de que alguna vez ha estado permitido), PHP no devuelve un error, pero sí un aviso. Os enseño el error y cómo solucionarlo:

define(DB_HOST, "localhost"); // notice
define("DB_HOST", "localhost"); // bien

Faltan muchos, ¿cuál quieres comentar?

Aunque esta entrada no forma parte del curso de Mono, sí está muy relacionada con esta entrega dedicada a tipos de datos.

Si tenemos una variable u objeto y no sabemos su tipo con seguridad, disponemos de dos métodos que usaremos para ver cuál es realmente el tipo del mismo. Veamos:

• getType(): obtiene el tipo de la instancia actual
• Type.GetType(“tipo de objeto”): lo usamos para obtener una referencia con la que comparar

Por ejemplo, ¿cómo saber si el objeto “auxiliar” es un entero con signo de 32 bits (el entero más estándar, el que usamos al poner int simplemente)?

if(auxiliar.GetType() == Type.GetType("System.Int32"))
   return true;
else
   return false;

Al igual que con enteros, podemos hacer la comprobación para cualquier tipo:

• Boolean: valor booleano
• Byte: ocho bits sin signo
• Char: carácter UNICODE
• DateTime: fecha con tiempo
• Decimal: número decimal
• Double: pnto flotante de precisión doble
• Int16: entero con signo de 16 bits
• Int32: ídem pero de 32 bits
• Int64: ídem pero de 64 bits
• SByte:  8 bits con signo
• Single: punto flotante de precisión simple
• UInt16: entero sin signo de 16 bits
• UInt32: ídem pero de 32 bits
• UInt64: ídem pero de 64 bits

Otras opciones además de Allegro y ClanLib de las que he hablado, son por ejemplo plataformas destinadas expresamente al desarrollo de videojuegos, como el Proyecto Fénix (el compilador alternativo al famoso DIV propietario). Sin embargo, como ya comenté anteriormente, estas opciones pueden parecer más fáciles pero son menos potentes que SDL.

En cuanto al juego que hemos creado, no sería difícil incluirle un sistema de puntuación, un sistema de vidas, un cálculo de la distancia crítica mejorado, distintos tipos de fases… un universo que se nos abre delante de nosotros de creaciones posibles con cada juego que creamos. El código en sí tampoco está demasiado depurado, pero el propósito era intentar realizar un código con la mayor legibilidad posible.

Otro punto importante a tener en cuenta es que SDL no sirve sólo para desarrollar videojuegos. Hemos usado SDL para hacer un juego, pero las mismas funciones que sirven para mostrar el avión por ejemplo, pueden servir para una aplicación multimedia de otra clase, además por supuesto del resto de funciones multimedia que nos proporciona.

En definitiva, espero que este artículo os haya introducido en un mundo al que antes de comenzar a conocerlo puede parecer más complejo de lo que es. Recordad también que SDL es multiplataforma y el código que compiláis para vuestro juego en Linux os sirve sin cambiar nada para Windows, sólo tenéis que compilarlo para dicho sistema operativo. Con entornos de desarrollo integrados como Dev-Cpp puede resultar realmente fácil compilarlo para el sistema de Microsoft.

¿Quién usa SDL?

Antes de finalizar el curso es buen momento para recordar ejemplos reales de juegos que han usado SDL y han conseguido (y consiguen) resultados realmente buenos. Algunos comerciales, otros muchos libres, engrosan una lista en la que nombres de gran fama saltan a la vista de todos los que hemos jugado alguna vez en nuestro sistema operativo GNU/Linux.

Como representante comercial podemos nombrar a Civilization “Call To Power”. En cuanto a ejemplos libres hay muchísimo, aquí os dejo algunos de los títulos más importantes:

• Battle For Wesnoth
• Solarwolf
• Secret Maryo Chronicles
• X-Moto
• Tower Toppler
• Super Mario War

Estos son sólo un ejemplo de un total de miles de juegos que han sido (y serán) programados con SDL. Con esto quiero daros sólo una visión de la potencia y de los resultados que se pueden llegar a conseguir haciendo uso sólo de esta librería.

for(i=0;i<numeroEnemigos;i++)
{
	if(posicionesEnemigos[i].y>=480)
	{
		posicionesEnemigos[i].x=rand()%590+1;
		posicionesEnemigos[i].y=60-rand()%40+1;
	}
	posicion.x=posicionesEnemigos[i].x;
	posicion.y=posicionesEnemigos[i].y;
	SDL_BlitSurface(enemigos[i], NULL, buffer, &posicion);
}

Como podéis apreciar dentro del bucle principal, incluimos la condición y en caso de ser cierta, la inicialización de nuevo de la posición.

Comprobando si existe colisión

Para comprobar si existe colisión calcularemos la distancia entre el jugador y cada uno de los enemigos. Para calcular la distancia, primero hallaremos el centro de cada uno de los enemigos y del jugador para posteriormente calcular la distancia euclidea entre ambos puntos.

Ya que las dimensiones son:

• Jugador: 59×42
• Enemigo: 50×40

El centro de cada uno de ellos debe estar desplazado de la posición en la que están dibujados (teniendo en cuenta que SDL dibuja desde la posición superior izquierda del objeto):

•  Jugador: (30,21)
• Enemigo: (25,20)

Veamos cuál es la distancia límite a la que pueden estar el jugador y un enemigo (si la distancia es menor se considerará que ha habido una colisión y por lo tanto el juego se termina):

• Distancia crítica=(30²+21²)^(1/2)+(25²+20²)^(1/2) aproximadamente 69.

Es decir el punto en el que se tocan los extremos de las superficie enemigo con la superficie jugador. Este modo de calcular la distancia no es el más exacto, pero es bastante orientativo. Si quisiéramos calcular la distancia de manera más exacta deberíamos estudiar mejor la geometría y las dimensiones reales de nuestro dibujo (despreciando la parte con transparencia en los extremos).

La función que hace esta comprobación sería la siguiente:

int existeColision(int x, int y, int numeroEnemigos,
   struct posicion* posicionesEnemigos)
{
   int i;
   int centroJugador[2]={x+30,y+21};
   struct posicion* centroEnemigos;
   double distancia;
   centroEnemigos=(struct posicion*)malloc
(sizeof(struct posicion)*numeroEnemigos);
   for(i=0; i < numeroEnemigos; i++)
   {
	centroEnemigos[i].x=posicionesEnemigos[i].x+25;
	centroEnemigos[i].y=posicionesEnemigos[i].y+20;
	distancia=sqrt(pow((double)centroJugador[0]-
centroEnemigos[i].x,2)+pow((double)centroJugador[1]-centroEnemigos[i].y,2));
	if(distancia <= 69)
		return 1;
   }
   return 0;
}

Una vez tenemos la distancia crítica pasemos a ver como ha quedado la función (devuelve 1 si existe colisión, 0 en caso contrario).

Tened en cuenta la diferencia entre centro y posición. El centro es el centro de la superficie y la posición su extremo superior izquierdo.

Paso por paso:

1. ¿Qué recibe?

• int x: entero con coodenada X de la posición del jugador.
• int y: entero con coordenada Y de la posición del jugador.
• int numeroEnemigos: número de enemigos.
• struct posicion* posicionesEnemigos: vector con las posiciones de los enemigos.

2.  Cálculo del centro (30 y 21, por las dimensiones de la superficie del jugador 59 y 42):

• int centroJugador[2]={x+30,y+21};

3. Declaración del vector con las coordenadas del centro de los enemigos. Aprovechamos la estructura de datos posición, ya que nos sirve para almacenar las coordenadas X e Y del centro:

• struct posicion* centroEnemigos;
• centroEnemigos=(struct posicion*)malloc(sizeof(struct posicion)*numeroEnemigos);

Para cada enemigo además:

1. Calculamos las coordenadas de su centro:

• centroEnemigos[i].x=posicionesEnemigos[i].x+25;
• centroEnemigos[i].y=posicionesEnemigos[i].y+20;

2. La distancia euclídea entre el centro del jugador y el centro que acabamos de calcular (la expresión no se ve demasiado bien pero es simplemente aplicar la raíz a la suma de los cuadrados de las diferencias de las coordenadas X e Y).

• distancia=sqrt(pow((double)centroJugador[0]-centroEnemigos[i].x,2)+pow((double)centroJugador[1]-centroEnemigos[i].y,2));

3. Vemos si la distancia es menor o igual que la distancia crítica:

• if(distancia<=68) return 1;

Para que el juego terminase en caso de que existiera colisión haríamos una llamada dentro del bucle

while(!terminar)
{
  ...
  if(existeColision(posicionJugadorX,posicionJugadorY,
numeroEnemigos,posicionesEnemigos))
    terminar=1;
  ...
}

Expliquemos la implementación de esta técnica sobre nuestro ejemplo:

1. Declamos un puntero a una variable del tipo SDL_Surface sobre la que “dibujaremos” y despues volcaremos sobre el screen:
   SDL_Surface *buffer;
2. Creamos este buffer:
   buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, 640, 480, 16,0,0,0,0);
3. Le indicamos al screen que vamos a usar la técnica de doble búfer:screen = SDL_SetVideoMode( 640, 480, 16, SDL_HWSURFACE | SDL_DOUBLEBUF);
4. Dibujamos los componentes del juego, fondo, jugador y enemigos sobre el búfer:
   SDL_BlitSurface(fondo, NULL, buffer, &posicion);
   SDL_BlitSurface(jugador, NULL, buffer, &posicion);
   SDL_BlitSurface(enemigos[i], NULL, buffer, &posicion);
5. Volcamos sobre la pantalla:
   posicion.x=0;
   posicion.y=0;
   SDL_BlitSurface(buffer, NULL, screen, &posicion);
   SDL_Flip(screen);

No mostramos el código completo, porque como estos cambios han sido menores y son fácilmente identificables. Para terminar esta entrada del curso sólo comentar cómo sería el caso de que quisiéramos hacer que el juego se ejecutase en pantalla completa en lugar de en una ventana. Con SDL solamente tendríamos que incluir en el último parámetro SDL_FULLSCREEN:

screen = SDL_SetVideoMode( 640, 480, 16, SDL_FULLSCREEN |
SDL_HWSURFACE | SDL_DOUBLEBUF);

Como podéis observar los valores se incluyen con OR lógicos (|).