A finales de la década de 1990 Internet se hizo un hueco en nuestras vidas. El juego en red estaba de moda, los salones recreativos de capa caída y los cibercafés proliferaban como hongos por nuestras ciudades. Fue una época maravillosa en la que todo el mundo quería jugar al Quake, navegar por Internet o conocer gente hablando por el chat. Para charlar online el lugar preferido por la mayoría era el IRC-Hispano y, por lo general, nos conectábamos a los servidores utilizando el mIRC.

El mIRC cambió mi vida, se trataba de un programa capaz de interpretar scripts y gracias a esa característica aprendí a hacer una de las cosas que más me gustan: programar. Recuerdo que empecé sin manual y sin tener mucha idea leyendo códigos que me sonaban a chino y que poco a poco, a medida que pasaban los días, iba entendiendo cada vez mejor. Y así fui aprendiendo.

Por aquél entonces existían una serie de scripts que ya gozaban de cierta fama: 7th Sphere, Orbital, IRcap, El Brujo, Phanatic, Killer Zombie… Muchos de ellos estaban orientados a atacar a la gente con nukes, floods y demás. El IRC no era un sitio tranquilo y los enfrentamientos eran frecuentes por lo que convenía “estar armado”. Al menos hasta que la gente del IRC Hispano decidió ocultar las IPs de los usuarios acabando de un plumazo con la juerga.

En aquél entonces no había tarifas planas de conexión, así que mi ordenador (un flamante Pentium II @ 450 Mghz) se pasaba un montón de tiempo desconectado de la red, por lo que me monté en local un servidor de IRC y comencé a programar mi propio script. El Backbeat 3.2 (para mIRC 5.91) es el resultado de miles de líneas de código, de noches enteras sin dormir y de la evolución de las versiones anteriores (Jim Script, BeatleScript, BravoScript, Backbeat 2 y BaT). Hay que tener en cuenta que en aquél entonces tendría entre 15 y 18 años, y por lo tanto no disponía de ciertos conocimientos teóricos (orientación a objetos, algoritmos, recursividad…) que aprendí más tarde en la carrera y que de haberlos sabido en aquél entonces me hubieran facilitado enormemente la vida.

Descargar

• Backbeat 3.2

El script incluye el mIRC 5.91 y pesa poco más de un mega.

A continuación describiré las características más destacables del script y los paneles de configuración de los que disponía para adaptar al gusto de cada usuario cada una de sus características.

Panel de utilidades

Muchos scripts acabaron transformándose en “pequeños sistemas operativos” que disponían de casi todas las aplicaciones que hacían falta para estar en Internet. Incluso algunos implementaron mediante una librería DLL un navegador web dentro de una ventana. Lo cierto es que llegar a ese extremo siempre me pareció excesivo, sin embargo la tendencia de entonces marcó que el Backbeat 3.2 disponga de utilidades como una calculadora, un escáner de puertos, un visor de imágenes o un cliente télnet entre otras cosas.

Panel de control

La configuración es uno de los aspectos críticos de cualquier script que aspirase a ser utilizado por un amplio número de usuarios. Lo cierto es que el objetivo de muchos de los “scripters” era el conseguir tener una cuota grande de gente que utilizase tu script, sin embargo era complicado llegar al nivel de los “pesos pesados” (IRcap, Orbital, Phanatic…). Pero bueno, al menos en mi caso conseguí tener un número considerable de usuarios y decenas de miles de descargas.

Como uno no sabía muy bien qué era lo siguiente que le tocaría implementar en su día decidí crear un panel de control imitando un poco el de Windows a modo de índice de las secciones configurables y bueno, resultó ser un método cómodo que cumplió su objetivo.

Configuración de la titlebar

En la barra del título se solían mostrar valores como el lag, el número de privados abiertos, el topic del canal. Este formulario permitía al usuario configurar la información que estaría a la vista.

Theme manager

En la época en la que implementé este gestor de themes surgió una iniciativa en mIRCScripts.org y en diversos foros extranjeros para la elaboración de un sistema llamado MTU (creo). Se trataba de un intento de independizar el código del script del diseño y marcar unas pautas para la creación de themes que fuesen compatibles con todos los scripts que implementasen dicha característica. La idea era muy buena, pero no me arrepiento de no haber participado ya que los scripts que pasaron por mis manos que utilizaban dicho sistema estaban llenos de fallos, al igual que los themes. Yo opté por un sistema de themes propio que también independizaba código de diseño y que finalmente dispondría de sólo dos temas distintos: BaT (por defecto) e Illusion (un theme de un script extrajero que me gustó y adapté).

Lo cierto es que el tema “Illusion” (sin desmerecer al BaT de Fulg0re) era precioso, con su fondo negro y sus letras verdosas… Utilizaba el tipo de letra “Terminal”, pero la versión “gordita” de MS-DOS, ya que la tipografía “Terminal” de Windows era demasiado delgada, por lo que había que hacer un truco para poder borrar esa tipografía del sistema y utilizar la versión de la consola.

Telnet

El cliente telnet era el típico ejemplo que uno programaba cuando empezaba a trabajar con conexiones y puertos. Quizás lo único que tiene de especial el cliente es que es multisesión.

Teclas rápidas

Nunca he sido muy partidario de las teclas rápidas, aunque sí de las combinaciones de teclas. El caso es que este formulario permitía configurarlas al gusto del consumidor.

Servidor !seen

Los servidores !seen dentro de los clientes ofrecían una característica muy interesante que no cubrían los servidores de IRC. Servían para que un usuario pudiese consultar la última vez que había vista una persona concreta: !seen nickname.

Como la mayoría de scripts lo implementaron, yo también creé un servidor !seen con protección anti-flood, que en el canal #scripting había gente con muy mala baba intentando explotar las vulnerabilidades de los códigos de los demás.

Visor de logs

Los lectores de logs (lectores de conversaciones antiguas) se implementaban en una de las “ventanas nativas” del mIRC mostrando en la barra de la derecha los nicks y en la parte de la izquierda el texto.

Snake

Este mini-clón del Snake de los Nokia lo programé en una tarde y lo publiqué como AddOn el 06/05/01 (ya llovió) en la web mIRCScripts. Recuerdo que un tal Sharek me propuso que dejásemos de hacer AddOns y demás scripts “de gestión” y que nos dedicásemos a hacer videojuegos para el mIRC. Lo cierto es que quizás debí haberlo escuchado. En aquella época el tiempo no era un bien escaso y seguro que podría haber hecho algo interesante. De todas formas, tambień estuve programando otro juego simple, un 4 en raya que permitía el juego a dobles y que utilizaba una GUI propia, pero lamentablemente perdí el código cuando estaba casi acabado.

Protecciones de flood en canales

Las protecciones de flood de los canales siempre han sido uno de los aspectos que más valoran los operadores de canales grandes ya que el script puede encargarse de echar a la gente que está molestando.

Como echar a la gente de los canales se volvía repetitivo, los scripts solían disponer de un fichero “.txt” con frases divertidas y también de un contador de kicks para indicar el grado de bordería.

Protección de flood personal

Las protecciones personales del script eran bastante eficaces. La mayor dificultad que encontré a la hora de codificarlas fue integrarlas con otros servicios como el del servidor !seen.

Portscan

El 7th Sphere, uno de los scripts más emblemáticos y antiguos del mIRC, incluía por defecto una serie de herramientas de IRC-War como el famoso click.exe, capaz de lanzar nukes. Entre sus programas incluía un escáneador de puertos y por eso creé una versión nativa del programa.

Nick completion

Los nick completion valían para resaltar el nombre de alguno de los participantes de la charla, con diferentes estilos aunque casi todos bastante sencillos para no incordiar al personal.

Reproductor mp3

En el IRC además de charlar también se podían compartir archivos y una buena forma de compartir música era mostrar en el canal la canción que uno estaba escuchando para que, si a alguno le interesaba, pudiera pedirla. Lo normal es que el script se la mandara al usuario automáticamente. Recuerdo haber programado un bot cuya misión era entrar en redes inglesas al canal #beatles y solicitar automáticamente canciones, algunas de ellas eran versiones muy raras del cuarteto de Liverpool.

Pero el concepto inicial de mostrar lo que se reproduce y compartir desapareció rápidamente. Muchos scripts simplemente mostraban el título, duración y autor de las canciones pero no ofrecían una forma automatizada para solicitar el tema. Por lo tanto… ¿a quién le importaba saber lo que el resto estaba escuchando? A nadie, pero los canales se llenaron de colores mostrando los tags de los mp3. Por este motivo me negué a programar un reproductor mp3 para el script, sin embargo, por petición de ciertos usuarios me vi obligado a incluír uno, así que le pedí a Tig0ti el suyo porque funcionaba bien y porque no mostraba la reproducción activa en los canales.

Mensaje del día

El mensaje del día tenía muy pocas frases y consejos (andaba escaso de imaginación), por lo que convenía desactivarlo cuanto antes.

Modos de usuario

El formulario del mIRC para configurar los modos personales era excesivamente simple, así que creé una versión también bastate sencilla pero útil ya que automatizaba el cambio de modos.

Menús con iconos

El uso de librerías externas (DLL) para dotar al mIRC de más funcionalidades se puso muy de moda ya que permitía hacer cosas distintas, en este caso decorar con iconos los menús.

Medidor de lag

En aquella época el retardo en las conversaciones era frecuente y tener un buen medidor de lag (retraso) era fundamental para saber porqué se había parado todo de repente.

Lista de usuarios remotos

La lista de usuarios remotos identificaba a una serie de nicks por sus máscaras y realizaba acciones automáticas sobre ellos. Así quise yo crear una configuración de usuarios donde se pudiesen añadir BOTs, listas de auto-op, listas de kickban y otras cosas. En definitiva esto era un “todo en uno”, pero lo cierto es que lo hice bastante abstracto y había gente que me pedía que implementase de una vez una lista de kickban cuando ya estaba implementada. Lo admito, culpa mía.

Lista de redes y servidores

Casi todos los scripts de la época disponían de un formulario con redes y servidores que remplazase al del mIRC original, que por cierto no era nada cómodo.

Jezzball

El Jezzball es un clásico juego de Windows que llevaba en un disquete para entretenerme cuando se ponía aburrida la clase de informática (que en realidad era de ofimática). Como es un juego al que le tengo mucho cariño y además era perfecto para entretenerse cuando había mucho lag o cuando no había nadie conocido con quien charlar, lo incluí en el script.

Bat SMS!

A finales de la década de 1990 también se empezaron a popularizar los teléfonos móviles y los mensajes SMS. En un primer momento los SMS eran gratis y de esa época data esta utilidad para enviar mensajes que saqué también como AddOn independiente y que llegó a ser aplicación de la semana dentro de su categoría en Softonic.com.

Esta utilidad pudo haberse convertido en algo más popular, sin embargo recuerdo que cuando la programé cursaba 3º de BUP, año en el que mi madre me castigó sin tocar el ordenador entre semana para que estudiase para los exámenes. Cuando pude subir la versión final del Bat SMS! ya existían otras aplicaciones que hacían lo mismo, y la aplicación que al final se llevó la fama fue el genial WinSMS de Azrael.

Floodbots

El Floodbots también lo lancé como AddOn independiente. Se trata de una herramienta que permite cargar varios clones en un servidor para sembrar el caos realizando acciones masivas y ataques de flood. Lo utilicé para probar las protecciones de mi script y no le puse soporte para proxys porque el IRC-Hispano tenía un mecanismo de control de clones y, como era el lugar donde chateaba, no me apetecía que la gente utilizase mis armas contra mi. Sin embargo, esto suponía un problema con los cybercafés que habían contratado clones, ya que en ellos sí se podía utilizar esta aplicación. Hace unos años no sé quién me comentó que las altas esferas del IRC-Hispano habían incluso discutido mi baneo de la red. No entiendo porqué, si sólo se trataba de una inofensiva herramienta para la auditoría >:-)

Envío de emails

Esta utilidad de envío de emails resultó ser bastante divertida ya que permitía mandar mensajes anónimos a la gente o con un remitente falso a través de los servidores SMTP que no requiriesen identificación. Un utensilio perfecto para mover los hilos en las sombras o, simplemente, para enviar emails, al gusto de cada uno.

Encriptación de texto

Nunca llegué a utilizar esta característica pero la implementé porque podría resultarle útil a algún usuario. Requería un cambio de clave inicial y a partir de ahí todo lo que se hablase se codificaría utilizando una librería dll programada por ais.

Generador de DNIs

Como mucha gente sabe, las letras del final de los DNI son información redundante que sirve para comprobar que el número está bien. Es decir, a partir de un número de DNI se puede obtener la letra que le corresponde, y este cálculo lo empleaban algunos formularios de webs que requerían que la gente se diese de alta, así que era cómodo contar con un generador de DNIs válidos a mano para evitar proporcionar información personal.

Lista de archivos descargados

Este formulario simplemente lista todos los archivos de la carpeta de descargas. Lo cirto es que hubiera sido quizás más conveniente invocar directamente al navegador.

CTCP Reply

Linux entonces no era ni tan fácil de utilizar, ni tan fácil de instalar como ahora. De hecho, los que lo utilizaban eran considerados como “hackers” (bueno, a veces no tanto). Linux era un sistema raro y se rumoreaba en los cibercafés que era el mejor, el más rápido y el más estable, aunque sólo estaba al alcance de los mejores. Mientras, el resto de los mortales, nos conformábamos con el Windows 98.

El caso es que el final de los años 90 era una época en la que mucha gente quería aparentar, y por eso qué mejor forma de hacerlo que falseando el CTCP VERSION para que la gente pensase que utilizaban Linux en lugar de mIRC aunque no fuese verdad. Mucha gente vivía de la boquilla, de ir fantasmeando de un lado a otro, y cuando lo arrinconaban en un ciber y la gente descubría que en realidad no sabía nada (o al menos no tanto como presumía), pues el sujeto se iba a otro lado y volvía a fantasmear de nuevo (saludos, Spirou). Será por cibers, en Santiago de Compostela recuerdo haber contado más de 30 locales.

Configuración general

La configuración general quizá hubiera sido bueno modularla en formularios más pequeños puesto que su nombre es poco intuitivo teniendo en cuenta la modularidad del resto del script. Quizás mantuve esta estructura porque en la versión 2.1 del Backbeat disponía de un formulario enorme para configurar todos los aspectos del script.

El DCC era la forma de transferir ficheros en el IRC, y como es obvio siempre había gente malintencionada distribuyendo virus, por lo que una protección que rechazase archivos susceptibles de serlo por su nombre pues era fácil de implementar e interesante.

Una de las principales funcionalidades de todo script era intentar realizar acciones automatizadas para que el usuario pudiese concentrarse en lo que realmente importaba: chatear.

La autoentrada en canales era otro de esos pequeños detalles que mejoraban la experiencia, sin embargo se me pasó darle soporte para canales con password aunque se podía resolver con una pequeña chapuza que dejaba la clave visible. De todas formas hay pocas veces en las que se necesitaría esa característica.

Utilizar scripts era algo muy frecuente, especialmente en el caso del IRcap, Phanatic, etc, que inundaban los canales de publicidad en los mensajes de “quit”, es decir. Un buen sistema antispam era algo fundamental, y éste cumplía muy bien con su cometido: permitir conversar de una forma clara y limpia, sin interrupciones.

Calculadora

La calculadora era una utilidad que servía de bien poco ya que quizás fuese más interesante abrir directamente la calculadora de Windows. La programé porque se la vi a mi amigo Quetzal en su script, el Quetzal Script, que llegó a salir en un CD de una revista de informática de la época.

Away

El estado de away eran otra de esas cosas curiosas del IRC. A la gente le gustaba mostrar su presencia cuando estaba y también cuando no estaba, y los canales se inundaban de mensajes recordando, a veces de manera repetitiva, que un tal fulanitoAway se había marchado a comprar pan, por poner un ejemplo irrelevante. Y por culpa de esta manía de la gente, la de anunciar que no estaban, los sistemas de away tenían que ser altamente personalizables.

Había determinados canales elitistas en los que se prohibían un montón de cosas, entre ellas molestar al personal los sistemas de away, por lo que había que dar la opción a mostrarlos en unos sitios y en otros no.

El log registraba ciertos eventos interesantes (como ser nombrado en un canal, ser expulsado, haber recibido mensajes privados…) para mostrar un resumen al usuario de todo lo relevante que había pasado cuando volviese a su equipo.

Lo cierto es que esta característica casi nadie la utilizaba. Era una forma de avisar remotamente al usuario que estaba away para que volviese si se encontraba cerca de la máquina, y es también la única característica del script que utiliza sonido.

Autoidentificación

Identificación automática en los servidores del IRC-Hispano y de DalNet. Pensé en añadir más redes, pero lo cierto es que tampoco merecía la pena hacerlo. Había pocos usuarios del Backbeat en otras redes y además triunfaban otros scripts extranjeros. Que yo recuerde, el más internacional era el IRcap con su siempre cuidado apartado gráfico.

Créditos

Y por último, la ventana de créditos del script con los reconocimientos a toda la gente que había colaborado de una u otra forma en el proyecto. Con algunas personas aún a día de hoy mantengo el contacto pero con otras lo he perdido. Son cosas que forman parte de la vida y, aunque pasen los años, siempre recordaré con mucho cariño la época del IRC, del chat y de los scripts.

NoTsCaPe betatester
chungo y a bocapo por sus gráficos
Tonic por el detector de clones
^MoRpH-x^ por el trivial
Tig0ti por el addOn de mp3
Estepario por los ASCII
Quetzal por la calculadora
Hommer__ por estar ahí (en todos mis canales )
Tambien me ayudaron: Fulg0re, hPm, tabo, Sharek, Locorl y DraZen
Por las dll a ais, DragonZap, Necroman y danielson
Y a los canales #100scripts, #fiesta, #ayuda_IRC y #scripting

Un abrazo de vuestro amigo Jimmy_RAY

Dejando a un lado al simplísimo Pong, podemos pensar en el Snake como en uno de los juegos más fáciles de programar. A continuación expongo el código fuente de una simplísima versión del juego que programé en lenguaje Java, aunque admito que quizá no está muy ordenado ya que lo escribí de madrugada.

Descargar

• Snake.java.zip

Snake.java

/*
 * SNAKE en Java (1.0 alpha)
 *
 * Autor: Juan Gestal (Jimmy)
 * Fecha: 16/09/09
 *
 * Web: http://www.gestal.es
 */

package org.sp.Snake;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;

public class Snake extends JFrame implements Runnable {

	// Altura y anchura de la ventana
	public static int W = 600;
	public static int H = 400;

	// Tablero
	public static int CV = 15; // Casillas verticales
	public static int CH = 28; // Casillas horizontales
	public static int CT = 20; // Tamaño de las casillas
	public static int CX = 20; // Posición X del comienzo del tablero en la
								// pantalla
	public static int CY = 60; // Posición Y del comienzo del tablero en la
								// pantalla

	// Juego

	public static int juego[][] = new int[CH][CV];
	public static int MAX_LONG_SNAKE = 40;
	public static int snake[][] = new int[MAX_LONG_SNAKE + 1][2];
	public static int snakeLongAct;
	public static int snakeMov = 1;

	// Comprobaciones

	public static boolean gameOver = false;
	public static int puntuacion = 0;

	// Tecla pulsada
	public static int tecla = snakeMov;
	// Retardo

	public static int retardo = 200;

	public void pintarTablero(Graphics g) {

		for (int x = 0; x < CH; x++) {
			for (int y = 0; y < CV; y++) {

				switch (juego[x][y]) {

				case 0: // La casilla está vacía
					g.setColor(Color.white);
					g.fillRect(x * CT + CX, y * CT + CY, CT, CT);
					break;
				case 1: // La casilla es un borde
					g.setColor(Color.black);
					g.fillRect(x * CT + CX, y * CT + CY, CT, CT);
					break;
				}
			}
		}
	}

	public void pintarSerpiente(Graphics g) {

		for (int i = 0; i < snakeLongAct; i++) {

			int x = snake[i][0];
			int y = snake[i][1];

			if (i == 0)
				g.setColor(Color.blue);
			else
				g.setColor(Color.magenta);

			g.fillRect(x * CT + CX, y * CT + CY, CT, CT);
		}
	}

	public void paint(Graphics g) {

		g.setColor(new Color(255, 0, 0));
		g.fillRect(0, 0, W, H);
		pintarTablero(g);
		pintarSerpiente(g);
		g.setColor(Color.black);
		g.drawString("PUNTUACION:" + puntuacion, 20, 50);

		if (gameOver) {
			g.drawString("GAME OVER: Pulsa la tecla R para volver a jugar",20,380);
		}
	}

	public static void main(String[] args) {

		Snake snk = new Snake();
		crearVentana(snk);

		inicializarJuego();
		inicializarSerpiente();
		ponerManzana();

	}

	public static void crearVentana(Snake snk) {
		snk.setVisible(true);
		snk.setBounds(0, 0, W, H);
	}

	public static void inicializarJuego() {

		// Inicializamos el tablero de juego

		for (int x = 0; x < CH; x++) {
			for (int y = 0; y < CV; y++) {
				juego[x][y] = 0;
			}
		}

		// Fijamos los bordes
		for (int x = 1; x < CH; x++) {
			juego[x][0] = 1;
			juego[x][CV - 1] = 1;
		}
		for (int y = 0; y < CV; y++) {
			juego[0][y] = 1;
			juego[CH - 1][y] = 1;
		}

	}

	public static void inicializarSerpiente() {

		// Situamos la serpiente en su posición inicial

		int mitadVertical = CV / 2;

		snake[0][0] = 4;
		snake[0][1] = mitadVertical;

		snake[1][0] = 3;
		snake[1][1] = mitadVertical;

		snake[2][0] = 2;
		snake[2][1] = mitadVertical;

		snakeLongAct = 3; // Fijamos la longitud inicial

	}

	public Snake() {

		Thread hilo = new Thread(this);
		hilo.start();

		this.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				super.keyPressed(e);
				tecla = e.getKeyCode();

				// Tenemos que comprobar siempre que no vaya en dirección
				// contraria
				switch (e.getKeyCode()) {
				case 39: { // Derecha
					if (snakeMov != 3)
						snakeMov = 1;
					break;
				}
				case 40: { // Abajo
					if (snakeMov != 4)
						snakeMov = 2;
					break;
				}
				case 37: { // Izquierda
					if (snakeMov != 1)
						snakeMov = 3;
					break;
				}
				case 38: { // Arriba
					if (snakeMov != 2)
						snakeMov = 4;
					break;
				}
				case 'r':
				case 'R': {
					puntuacion = 0;
					snakeMov = 1;
					gameOver=false;
					inicializarJuego();
					inicializarSerpiente();
					ponerManzana();
					break;

				}
				}

			}
		});
	}

	public void run() {

		while (true) {

			try {
				Thread.sleep(retardo);

			} catch (Exception e) {

			}

			// Comprobar movimiento
			comprobaciones();

			if (!gameOver) {
				movimientoSerpiente();
			}
			repaint();
			// Repintar
		}
	}

	public void comprobaciones() {

		int sx = snake[0][0];
		int sy = snake[0][1];

		switch (snakeMov) {

		case 1:
			sx = snake[0][0] + 1;
			break;
		case 2:
			sy = snake[0][1] + 1;
			break;
		case 3:
			sx = snake[0][0] - 1;
			break;
		case 4:
			sy = snake[0][1] - 1;
			break;
		}

		for (int x = 0; x < CH; x++) {
			for (int y = 0; y < CV; y++) {
				if ((x == sx) && (y == sy)) {
					if ((juego[x][y] == 1)) { // Choca contra la pared
						gameOver = true;
					}
					if (juego[x][y] == 1000) { // Comemos manzana

						juego[x][y] = 0; // Quitamos la manzana

						if (snakeLongAct < MAX_LONG_SNAKE) { // Si es posible
																// crecer,
																// crecemos
							snakeLongAct++;

						}
						puntuacion += 10; // Aumentamos los puntos
						ponerManzana(); // Colocamos una nueva manzana
					}
				}
			}
		}
		for (int i = 0; i < snakeLongAct; i++) {

			if ((sx == snake[i][0]) && (sy == snake[i][1]))
				gameOver = true;
		}
	}

	public void movimientoSerpiente() {

		for (int i = snakeLongAct; i > 0; i--) {
			snake[i][0] = snake[i - 1][0];
			snake[i][1] = snake[i - 1][1];
		}
		switch (snakeMov) {

		case 1:
			snake[0][0] = snake[0][0] + 1;
			break;
		case 2:
			snake[0][1] = snake[0][1] + 1;
			break;
		case 3:
			snake[0][0] = snake[0][0] - 1;
			break;
		case 4:
			snake[0][1] = snake[0][1] - 1;
			break;
		}
	}

	public static void ponerManzana() {

		boolean manzanaPuesta = false;

		while (!manzanaPuesta) {

			// Generamos una posición aleatoria en el tablero

			int xManzana = (int) (Math.random() * CH);
			int yManzana = (int) (Math.random() * CV);

			// Comprobamos que no haya nada en la posición

			if (juego[xManzana][yManzana] == 0) { // Es una casilla libre, hay
													// que mirar que en ella no
													// se encuentre la serpiente
				boolean estaSerpiente = false;

				for (int i = 0; i < snakeLongAct; i++) {

					if ((snake[i][0] == xManzana) && (snake[i][1] == yManzana))
						estaSerpiente = true;
				}
				if (!estaSerpiente) { // Podemos poner la manzana
					juego[xManzana][yManzana] = 1000;
					manzanaPuesta = true;
				}

			}
		}

	}

}

En una de las prácticas que me propusieron hace tiempo, cuando cursé la asignatura de Estructura de Datos, fue precisamente la implementación de una bicola con la particularidad de que ésta tenía que ser circular y estar implementada sobre un array que, a medida que se introdujesen los valores, se fuese redimensionando solicitando más memoria al sistema para poder almacenarlos.

Así que a continuación dejo el código fuente, por si a algún estudiante le sirve de ayuda y para probar de paso la inserción de código fuente en el blog con el plugin SyntaxHighlighter Plus.

Descargar

• bicola-cpp.zip

Breve explicación

• Para hacer circular el array he utilizado dos métodos privados: goLeft() y goRight(), que utilizo para desplazarme para un lado o otro (izquierda o derecha) a partir de un puntero pasado como argumento (pi o pd).
• pi Es un puntero que siempre apunta al elemento de la izquierda.
• pd Es un puntero que siempre apunta al elemento de la derecha.
• p Es un puntero que apunta a la primera posición del array.
• Si intento desplazarme a la derecha y no hay más posiciones, el método goRight() me mandará al principio del array (“p”).
• El método goLeft() hace justo lo contrario: si intento avanzar hacia la izquierda y no hay más posiciones me mandará al último elemento del array.
• Con los métodos goLeft() y goRight() solvento el problema del desplazamiento circular por el array.
• getMem() Es el método encargado de pedir memoria.
• getLeft() Nos devuelve el elemento izquierdo.
• getRight() Nos devuelve el elemento derecho.
• putLeft() Inserta un elemento por la izquierda.
• putRight() Inserta un elemento por la derecha.

Bicola.h

/*
 * Programa:	Bicola
 * Autor:		Juan Gestal
 * Web:			http://www.gestal.es
 */

class Bicola {

      int t;
      int n; 

      int *p,*pi,*pd;

      void Bicola::goLeft(int **q);
      void Bicola::goRight(int **q);
      void Bicola::getMem();

      public:
             Bicola();
             ~Bicola();
             void putLeft(int e);
             void putRight(int e);
             int getLeft();
             int getRight();
};

Bicola.cpp

/*
 * Programa:	Bicola
 * Autor:		Juan Gestal
 * Web:			http://www.gestal.es
 */

#include "bicola.h"

Bicola::Bicola() {
               t=5; //tamaño
               n=0; //número de elementos
               p = new int[t]; //"p" apunta a un nuevo array de enteros de tamaño t
               pi=pd=p; //El puntero izquierdo "pi" y el puntero derecho "pd" se inicializan a "p"
}
Bicola::~Bicola() {
                delete []p;
}

/*
 * putLeft() Introduce un elemento en la Bicola por la izquierda. Si no hay memoria
 * llama a la función getMem() para pedirla.
 */

void Bicola::putLeft(int e) {
     if (n >= t)
        getMem();

     if (n == 0) {
        p[0]=e;
     }
     else {
          goLeft(&pi);
          *pi=e;
     }
     n++;
}

/*
 * putRight() Introduce un elemento en la Bicola por la derecha. Si no hay memoria
 * llama a la funciÛn getMem() para pedirla.
 */

void Bicola::putRight(int e) {
     if (n >= t)
        getMem();

     if (n == 0) {
        p[0]=e;
     }
     else {
          goRight(&pd);
          *pd=e;
     }
     n++;
}

/*
 * getLeft() devuelve el elemento izquiedo de la bicola.
 * Si se produce un error por que no hay elementos devuelve -1.
 */

int Bicola::getLeft() {
    if (n > 0) {
       int i=*pi;
       if (n > 1) goRight(&pi);
       n--;
       return i;
    }
    else return -1;
}

/*
 * getRight() devuelve el elemento de la derecha de la bicola.
 * Si se produce un error por que no hay elementos devuelve -1;
 */

int Bicola::getRight(){
    if (n > 0) {
       int i=*pd;
       if (n > 1) goLeft(&pd);
       n--;
       return i;
    }
    else return -1;
}

/*
 * goLeft() desplaza el puntero recibido como argumento una posición a la izquierda.
 * En el caso de que se le pase un argumento que apunte al principio del array "p",
 * lo manda a la última posición.
 */

void Bicola::goLeft(int **q) {
    if (p == *q)
       *q=&p[t-1];
    else
        (*q)--;
}

/*
 * goRight() desplaza el puntero recibido como argumento una posiciÛn a la derecha.
 * En el caso de que se le pase un argumento que apunte al final del array "p",
 * lo manda a la primera posiciÛn.
 */

void Bicola::goRight(int **q) {
     if (&p[t-1] == *q)
        *q=p;
     else
         (*q)++;
}

/*
 * getMem() es la funciÛn que pide memoria. Cada vez que se le llama amplia la capacidad del array "p"
 * en 5 posiciones.
 */

void Bicola::getMem() {
     int i;
     int *q = new int[t+5];

     for(i=0;pi != pd;i++) {
             q[i]=*pi;
             goRight(&pi);
     }
     q[i]=*pi;

     delete []p;

     pi=p=q;
     pd=p+(n-1);
     t=t+5;
}

(Link directo al archivo sokoban.swf, para jugar a pantalla completa o descargar el título.)

El Sokoban (encargado de almacén en japonés) siempre ha sido uno de mis puzzles favoritos. Lo cierto es que tenía ganas de hacer mi propia versión, y cuando el verano pasado aprendí a utilizar Flash, fue en el primer juego en el que pensé para afianzar los conocimientos de programación en ActionScript adquiridos con los (totalmente recomendables) libros:

• VAN DER SPUY, Rex. Game Design with flash.1a ed. New York: Friendsof, 2009. 586 p. ISBN: 978-1-4302-1821-0
• SHUPE, Rich; ROSSER, Zevan. Learning ActionScript 3.0 a beginner’s guide.1 ed. Canadá: O’Reilly Media, Inc., 2008. 363 p. ISBN: 978-0-596-52787-7

Si algo me sorprendió de la plataforma de Adobe es la posibilidad de desarrollar de una forma tan rápida y cómoda juegos y aplicaciones. Ya la había tocado hace años, aunque desde un perfil más cercano al de animador que al de programador.

Y con esta versión preliminar del Sokoban me quito en parte una espinita que tengo clavada desde hace tiempo. De todas formas debo admitir que el juego no está finalizado, todavía me queda por implementar las siguientes características principales:

• Sonido: Actualmente el juego es muy silencioso, diría yo.
• Paso atrás: No hay nada más frustrante que equivocarte al desplazarte a una casilla y que por culpa de ella, no se pueda solucionar el puzzle. Por ahora el que se equivoque lo pagará caro.
• Escena final: Si alguien supera todos los niveles se encontrará con un error en lugar de unas felicitaciones.

En cuanto solvente estas dos características y ponga un poco de orden en el código fuente, también lo publicaré en la página para el que quiera utilizarlo de ejemplo. De todas formas el juego es perfectamente “jugable”. Así que estás invitado a echar una partidita. El objetivo es sencillo, hay que cubrir los pentágonos amarillo anaranjados con las cajas y así ordenar el almacén.

Para el que no me conozca, me presento. Me llamo Juan Gestal (aunque mucha gente en Internet me conoce como Jimmy) y me encanta la informática, el mus y el zumo de naranja natural (y quizás muchas otras cosas, aunque no tantas). Empecé a programar cuando tenía 14 o 15 años haciendo scripts (BaCKBEAT o BAT) y addons (una especie de plugins) para el mIRC. En aquella época había tiempo para todo. También mantenía una página web personal que actualicé varias veces en html estático (web 1.0 le llaman) pero con más clase que las de GeoCities: no tenía un obrero diciendo “en construcción” ni estaba optimizada sólo para Netscape. Una de las versiones aún sigue online, rodeada de esos molestos banners de publicidad y con otra URL diferente a la original.

Ya ha llovido desde entonces, y a lo largo de estos años he hecho cosas interesantes y otras no tanto. He finalizado proyectos y he dejado otros a medias por falta de tiempo. Intentaré recopilarlos y subirlos, por si a alguien le interesan o le sirven de ayuda.

Actualmente soy el administrador de Pixfans.com, donde escribo artículos sobre la cultura y la historia de los videojuegos. Puedes pasarte a leerlos, quizás alguno te parezca interesante. También ando haciendo mis pinitos en Flash, donde trato de programar algún videojuego interesante aunque creo que este tema irá para largo…

Y con esta breve presentación doy por finalizada la primera entrada de este blog personal. Voy a pasarme por galerías de themes a ver si encuentro alguno sencillo y claro ¡y a poner esto un poco en orden!