Pixel Thief Grupo: Zrilon (Daniel Alcaraz Cases, Lidia Díaz Mateos, Nicolás Scalerandi Pezzolo) Presentado: #CPCRetroDev 2014 Clasificación: 13 / 16 Plataforma: Amstrad CPC 464 Lenguaje: C Tamaño: 10 KBs Controles: CURSORES: moverse; ESC: Sair del juego

Introducción

En la asignatura de Videojuegos I nos propusieron realizar un videojuego para Amstrad CPC464 y participar en el concurso de retrogame, de este modo nos embarcamos en la aventura de programar para Amstrad.

Decidimos hacer un juego de infiltración en el que el personaje tiene que conseguir avanzar por el mapa hasta la salida sin que los enemigos lo detecten.

En este caso es un ladrón que quiere robar un objeto de una casa y tiene que pasar por dos mapas: el del jardín y el de la casa.

Los guardias patrullan ambos mapas y tienen una distancia de visión hacia donde están mirando. En el momento en que detectan al personaje se termina la partida.

Historia

Nos ponemos en la piel de un escurridizo ladrón de guante blanco que se ha encaprichado de un objeto de gran valor que un rico magnate posee en su gran mansión. Para ello deberá sortear varios guardias que vigilaran la zona del jardín y el interior de la casa sin descanso. ¿Conseguirá nuestro ladrón su objetivo?

Personajes

• Ladrón: El protagonista del juego llamado Thief
• Guardias: Encargados de proteger la gran mansión y sus posesiones valiosas por orden del
  magnate.

Funcionamiento y controles

El funcionamiento del juego es muy sencillo. El jugador deberá llevar al ladrón durante dos niveles vigilados por guardias. Su objetivo: No ser detectado. Los guardias tienen un campo de visión limitado, y el ladrón deberá evadirlo sino quiere que le atrapen. Una vez llegado a la puerta de la casa, pasado el jardín, deberá pasar desapercibido una vez más hasta llegar a su botín.

• Movimiento:
  – Arriba -> Flecha arriba
  – Derecha -> Flecha derecha
  – Abajo -> Flecha abajo
  – Izquierda -> Flecha izquierda

Desarrollo del juego

Primeros pasos

Antes siquiera de comenzar a diseñar o pensar en el juego, el profesor de la asignatura nos instó a aprender como funcionaba el Amstrad: los comandos, leernos los manuales e investigar y aprender ha hacer cosas sueltas.

Nos propuso realizar un pequeño programa que mostrase por pantalla un sprite de mínimo 16×16 sin usar ninguna librería, solo con el comando de Amstrad “POKE”, para de esta forma, aprender el complejo y enmarañado sistema de memoria de los ordenadores Amstrad.

Después de eso, pintamos el sprite con la librería cpcrslib.

Capturamos el teclado y permitimos que el usuario pudiera mover el sprite. Con estos conocimientos empezamos a implementar el juego.

Pasamos de usar el modo 1 al modo 0.

Primero repartimos el trabajo. El mapeado con las colisiones, los enemigos patrullando con la detección y la creación de los sprites.

Generamos dos ejecutables y archivos de sprites.

Tanto el movimiento de los enemigos como el movimiento del personaje los diseñamos preparados para detectar las colisiones, así que integramos las partes muy facilmente.

Errores y problemas del desarrollo

Los errores y problemas en el desarrollo del juego no fueron pocos, por otro lado los pasos realizados anteriormente de investigación y aprendizaje nos sirvieron de mucho.

Uno de los primeros errores graves que cometimos fue que nos obcecamos con crear los sprites a mano como hicimos en el ejemplo del uso del comando POKE, cuando para el videojuego no era necesario hacerlo a mano (lo cual era una locura) y podíamos usar librerias.

Otro de los problemas que puede conllevar el uso de Amstrad es su limitada memoria, estamos acostumbrados a programar casi sin importarnos el uso que estemos haciendo de memoria ya que los ordenadores de ahora “tiene de sobra”, pero con Amstrad es otro cantar.

Al principio intentamos hacer el codigo lo más eficiente posible, pero cometimos errores:

Intentamos crear un array bidimensional del mapa dentro del código de ejecución lo que hacía que nos quedaramos directamente sin memoria, la solución fue que como el array del mapa nunca iba a cambiar podíamos convertirlo en una constante en lugar de una variable y cargarlo en memoria al principio.

Otro fallo relacionado con la memoria fue declarar variables como enteros (int) cuando solo iban a tomar números pequeños y con un tipo carácter (char) nos era suficiente y no ocupábamos el doble de memoria.

En un principio, los enemigos tenían un camino diseñado para cada uno. Por falta de tiempo y al ver que se adaptaban bien al mapa, dejamos que todos siguieran los mismos movimientos. Resultó efectivo, pero a causa de eso el juego es demasiado fácil.

Resultado final

Teniendo en cuenta los retrasos y el escaso tiempo que nos quedó al final por desgracia no conseguimos crear el juego que teníamos en mente, pero si un esbozo funcional de la idea.

En el juego puedes manejar al personaje por dos niveles para conseguir robar el objeto, la IA de los guardias como se ha comentado anteriormente no quedo tan compleja como teníamos pensado, pero da la sensación de que patrullan y pueden ponerte en un aprieto de vez en cuando.

Gráficamente es muy simple pero se plasma bien cada elemento del juego.

El juego tiene una pantalla de introducción con los nombres de los creadores y si pierdes la partida porque te descubren tienes la opcion de reiniciar.

Conclusión

Lo más importante a tener en cuenta es la estructura de la memoria en amstrad.

El primer paso es ver los manuales para saber como se pintan las cosas en la pantalla, según los modos que hay, como se captura el teclado, la música.

Para este paso mirar el manual de cpc ha sido un paso esencial, puesto que tiene mucha de la información que necesitamos.

Otro punto muy importante es la memoria. Hay que optimizar al máximo usando los tipos de datos mínimos que necesitemos y también hay que optimizar el código.

Hay que tener en cuenta que datos vamos a modificar y que datos no. Si no vamos a modificar datos, como el mapa, podemos declararlos como constantes y esto también es esencial.

Por lo demás, el proceso es el mismo que en cualquier otro juego.

Como conclusión de esta experiencia, es que la recomendamos a todos, porque realmente de esta forma aprendes a tener muy en cuenta la memoria de los ordenadores y a programar de la manera más eficiente y correcta. Por otro lado, en cuanto a Amstrad aprendes cómo funcionaban los ordenadores de antes. Te das cuenta de las cosas que conseguían con las limitaciones que tenían y cómo solventaban esas limitaciones.

Ficha Técnica

Lenguaje utilizado: Programado en C++ con la librería CPCRSLIB
Tamaño en Kbytes: .CDT 11K, .DSK 200K
Modo gráfico: Modo 0 (16 colores)
Detalles técnicos de la implementación:

• Los sprites utilizados son propios (creamos un diseño simple)
• IA de los guardias, patrullan zonas y detectan enemigos dentro de su line de visión

Para compilar el juego:

• Escribir en la consola en el directorio del juego >> make DSK