LitioPixel

Seguimos trabajando...

2012-02-13T14:17:00.018+01:00

Tras actualizar toca seguir escribiendo código.

En la captura se puede ver la disposición final del marcador de puntos, así como un marco "listbox" de desarrollo propio.

Actualizando GLB 10.118 -> 10.244

2012-02-13T13:48:00.000+01:00

Demasiado tiempo sin actualizar... quizás por aquello de "si algo va bien, no lo toques".

:-P

(fichero log_e.gbas)
// 10.244
// OpenAL (Mac, iOS):
// Sound engine was broken. It's fixed now.
// ISSOUNDPLAYING works. Buffer-count is supported.

// 10.241
// Core:
// Slightly faster internal arrays.
// Faster FOREACH.
// FOREACH can iterate all items in multi-dimensional arrays.
// 3D:
// X_COLLISIONRAY set the wrong face for X_GETCOLLISIONFACE
// if the negative direction face was closer than the returned
// face in positive direction.

// 10.237
// Core:
// Missing initialization could have caused a crash for arrays.
// SHELLEND was fixed.

// 10.231
// Pandora:
// Postprocessing crashed for long pathes.

// 10.230
// New Command:
// X_GETCAMERAMATRIX

// 10.209
// Caanoo:
// Linker error is fixed.
// WebOS:
// PLATFORMINFO$("DEVICE") failed for 1.4.5 devices.

// 10.205
// Compiler:
// Distributing Apps will exclude media subdirectories that contain
// .xcl files (See "GLBasic intern/.App folder" )
// Compiler/Compile Multiplatform -> Win32,Linux,WinCE will also copy to "distribute".
//
// Core:
// SOCK_TCPACCEPT - IP was wrong byte order.
// SOCK_TCPACCEPT - accepted sockets stored wrong info
// for SOCK_GETREMOTEIP.
//
// Editor:
// Ctrl+Tab has been fixed.
//
// WebOS:
// New libs included. Can use WebOS 3.x features now. Please check for
// PDL_GetPDKVersion() > 100 if you want features unavailable on 1.4.5

// 10.191
// Desktop:
// MOUSESTATE used hidden pointer coords for mouse position.
//
// Core:
// Fixed bug in SPRCOLL that might even have led to a crash.
// Using state variables for OpenGL states. "Should" be slightly quicker.
//
// New command:
// X_ENABLE_Z
// ALPHATESTING
//
// GP2X, Wiz, Caanoo
// Media is copied to distribution

// 10.179
// Core:
// a[-1] did not fail for empty arrays.
// ASC has optional index parameter.
// SOCK_GETREMOTEIP() was broken.
// VIEWPORT reset some 2D setting (SMOOTHSADING...). Fixed now.
// NEWWEBGET crashed for URLs > 900 chars.
//
// Caanoo:
// CLEARSCREEN 0 - was ignored.

// 10.159
// Android:
// Using fastest screen format with Z-buffer now. (might be RGB565 -> no GRABSPRITE).
// DRAWRECT is bound to work now.
// DRAWLINE is working always now.
// Removed glError() checks for more speed.

// 10.156
// Caanoo:
// button layout was not correct.
//
// Core:
// SAVEBMP, SAVESPRITE as jpg -> red/blue was swapped
// SAVEBMP, SAVESPRITE as bmp -> red/blue was swapped for transparency.
// LOADSPRITE: bmp files caused Android to crash. (Byte alignment problem)
//
// Win32:
// PLAYSOUND - volume is linear now (used to be logarithmic).
//
// New command:
// LOGN(x) - logarithm to the base "e".
// SWAP a,b - swaps the variable values
// X_OBJSETFRAME id% - switch to another frame when creating objects
//
// Compiler:
// Fixed a bug, where folded code did not compile.
//
// WebOS:
// HP Touchpad WebOS 3.0.4 - acceleration did no longer work.
//
// Editor:
// Goto and Jumplist clicks jump to the right position, again.
// Incredibuild was broken for more than 10 files.
//
// Android:
// Better screen mode selection. Try to get RGBA 8888 with Z-buffer.
// Z-Buffer is fixed.

Rutina Control Bot Terminada

2012-02-01T00:06:00.001+01:00

He terminado la rutina que decide el orden de ejecución de bots así como el control principal de los mismos por el mapa, así que tras bastante trabajo en ella la doy por finalizada -de momento para esta versión-.

Trabajando (2)...

2012-01-22T10:12:00.002+01:00

Probando mapas...

2012-01-17T23:41:00.001+01:00

Trabajando en el editor de mapas que he incluído...

Y más cambios internos...

2011-12-29T23:40:00.001+01:00

Sigo modificando muchas rutinas internas, sobretodo añadiendo bastantes puntos de control para intentar evitar el uso indebido ó torpe del usuario final y que descontrole la aplicación.

También he añadido un rótulo con el nombre temporal del juego, ElectricRPG. :-P

Ipad Test ElectricRPG GLBasic video

2011-12-21T08:37:00.000+01:00

Rutina LOAD/SAVE incluida... y más.

2011-12-02T00:28:00.001+01:00

Sigo cada día escribiendo código. He añadido la rutina de LOAD/SAVE para las variables de configuración del juego así como de los mapas escritos con el EDITOR.

Poco a poco estoy haciendo modificaciones al aspecto gráfico. También he optimizado internamente la rutina de timming que controla la velocidad de las animaciones.

El editor de mapas

2011-11-28T23:51:00.001+01:00

Quiero probar todos los movimientos de los enemigos en situaciones diversas; para esto necesito diseñar algunos mapas (los generados aleatoriamente no sirven ya que no cumplen algunas condiciones de distribución que busco).

Así que he incluido a la aplicación un sencillo editor de mapas... de paso añadiré las rutinas de SAVE/LOAD de los ficheros.

Vídeo - Test velocidad GLBasic en iPad

2011-11-24T10:03:00.001+01:00

Sencillo test de velocidad de movimiento en iPad.

Trabajando...

2011-11-21T23:25:00.001+01:00

Código y más código...

Limpiando el código

2011-11-19T23:18:00.001+01:00

He terminado de programar la parte de control de los bot enemigos y todo parece funcionar como debe. La prueba realizada en iOS no ha dado ningún problema.

Voy a limpiar el código de comentarios y rutinas obsoletas en preparación de la siguiente fase; desarrollar las reglas del juego para el jugador y bots.

En esta parte es donde se deciden los puntos a aplicar, las normas de comportamiento de cada tipo de bot dependiendo de su situación particular, el control de la partida por los diferentes mapas, etc.

Quiero buscar algún momento para grabar un vídeo del juego en el iPad...

Ejecutando en iPad

2011-11-19T13:07:00.003+01:00

Más capturas de pantalla...

2011-11-15T01:50:00.002+01:00

Findpath en Bots enemigos

2011-11-14T14:41:00.004+01:00

Buscando la posición del jugador con respecto a los enemigos...

[OT] Recopilatorio TodoUMPC Magazine

2011-11-14T13:50:00.000+01:00

Recopilatorio de todos los ejemplares de la posiblemente única en el mundo revista sobre UMPC que ha existido...

ENLACE

Programando los Bot enemigos

2011-11-12T08:55:00.003+01:00

Llevo unos días sin publicar nada en el blog, aunque lógicamente sigo trabajando en el juego. Actualmente me encuentro en la parte dedicada a la IA de los bot enemigos.

Tengo que tener en cuenta multitud de factores a la hora de dotar de inteligencia a los enemigos en el juego; hay que controlar el estado de cada bot, su posición con respecto al personaje controlado por el jugador, el tipo de acción y/o ataque a realizar (y las consecuencias que conlleven), etc.

En cuanto esta parte de la programación esté solventada, posiblemente publique una Alpha con creación de mapas aleatorios... así los betatesters interesados podrán trabajar en encontrar bugs.

Sigo programando... :)

Explotando sprites...

2011-11-07T12:34:00.002+01:00

Inspirado por los efectos del juego Voxatron, esta semana pasada he empleado algunos ratos en montar mi propia rutina de efectos de explosiones.

Se pueden apreciar que los vectores de desplazamiento se entrecruzan unos con otros. Esto ya está solventado para la versión final implementada, que se expande como corresponde.

Además el movimiento de píxeles en mi caso es más brusco (cada 5px).

Añadiendo la "IA" de los bots

2011-11-03T00:30:00.000+01:00

Estoy insertando todo lo relativo a las acciones de los bots. No quiero complicarme la vida así que pienso programar alguna rutina sencilla. La idea es realizar una busqueda del recorrido en el mapa y luego mover los enemigos hacia la posición de nuestro personaje para atacarle.

También he añadido la opción de pasar a pantalla completa; por otro lado he rediseñado las diferentes pantallas de opciones que ahora han pasado de una a tres.

Añadiendo Bots enemigos...

2011-10-31T13:27:00.001+01:00

He empezado a añadir los Bot enemigos, para ello he creado esta estructura (no definitiva):

TYPE Bot_Enemigo
PosX
PosY
Activado
Tipo
Grafico
Grafico_Inicial
Energia
Ataque
Defensa
Estado
Accion
ENDTYPE

Modificando la pantalla de juego

2011-10-24T23:28:00.001+02:00

He ajustado los diferentes componentes del panel de juego encajándolos dentro de un marco que he decidido esté en todo momento.

Ahora el mapa es más pequeño; puedo jugar con los parámetros de posición XY para centrarlo en la pantalla si es necesario.

"Working"

2011-10-20T00:24:00.002+02:00

Preparando Botonera

2011-10-18T14:54:00.001+02:00

Ya he modificado las rutinas de control de botones para que funcionen en "modo gráfico" y no simulado con un recuadro y textos como hasta ahora.

Así que ya estoy preparando los gráficos correspondientes a los botones...

App GLB identificada como PDM.Keylogger

2011-10-17T10:24:00.003+02:00

Lo que faltaba... ahora salta el Antivirus Kaspersky y me dice que la aplicación compilada con GLB es peligrosa y que contiene el código malicioso correspondiente a PDM.Keylogger.

Desde el foro de GLB, me aconsejan que envíe el EXE a Karspersky para que actualicen sus firmas...

Pffffffffffff

Trabajando en el proyecto

2011-10-16T23:11:00.000+02:00

Terminada la parte de teñir los sprites, actualmente me encuentro modificando las capas de renderizado de la aplicación.

He estado poniendo en orden el diferente pintado de los fondos, sprites personaje, objetos, etc... Internamente se pintan las cosas en diferente orden en comparación al principio del proyecto. Ahora dejo para el final de todo la impresión de la máscara de efectos.

Esta semana ya me enfrento a la IA de los enemigos y poco más... quiero avanzar en todo lo posible. Las pruebas realizadas con la última versión de todo (GLB, Lion, Xcode) han funcionado perfectamente en el iPad.

Sigo adelante!!!

Compilado en MacOS X Lion

2011-10-07T22:35:00.000+02:00

Primer test de compilado en MacOS X Lion. Perfecto.

:)

DEP Steve Jobs

2011-10-06T08:12:00.003+02:00

Jugando con los colores

2011-10-04T23:39:00.002+02:00

Se me ha ocurrido la tontería de añadir diferentes paletas de colores a la aplicación. :-P

Las pantallas corresponden a mis primeros test con una rutina propia que simplemente modifica el fondo RGB y la transparencia de los sprites que se pintan encima.

Comentándolo con el amigo Javier, éste me propone una rutina de cosecha propia alternativa; teñir los sprites.

Próximamente en este blog...

Sprites de personajes

2011-10-04T00:47:00.009+02:00

Diseños correspondientes al gráfico del protagonista principal. Realizados con la herramienta Sprite Something para iPad.

Añadiendo items al mapa

2011-10-01T11:00:00.000+02:00

Este juego utiliza una rutina para generar el mapa aleatoriamente a modo de laberinto.

Una vez tengo el mapa creado inserto los objetos también de forma aleatoria mediante una función que comprueba si la posición X/Y está libre u ocupada ya por un objeto ó personaje.

FUNCTION Inserta_Mapa_Datos_OBJETOS: Codigo_Objeto, Cantidad_Objetos

LOCAL Objetos_Insertados
LOCAL PosX_Insertar
LOCAL PosY_Insertar
Objetos_Insertados=0

WHILE Objetos_Insertados < Cantidad_Objetos
  PosX_Insertar=RND(MAPA_Ancho-1)
  PosY_Insertar=RND(MAPA_Alto-1)

  IF MAPA_Datos_BLOQUEO[PosX_Insertar][PosY_Insertar]=1 AND MAPA_Datos_OBJETOS[PosX_Insertar][PosY_Insertar]=0
  MAPA_Datos_OBJETOS[PosX_Insertar][PosY_Insertar]=Codigo_Objeto
  Objetos_Insertados=Objetos_Insertados+1
  ENDIF

  IF PosX_Insertar=HEROE_PosX AND PosY_Insertar=HEROE_PosY
  MAPA_Datos_OBJETOS[PosX_Insertar][PosY_Insertar]=0
  Objetos_Insertados=Objetos_Insertados-1
  ENDIF
WEND

ENDFUNCTION

Retomando el proyecto...

2011-09-29T13:36:00.003+02:00

He recuperado el proyecto que comentaba en el post anterior...

Como hacía tiempo que no abría este desarrollo, me ha tomado un par de ratos el ponerme al tanto del código fuente que escribí en su momento.

Tras repasar los procedimientos y funciones que incluye, me encuentro actualmente revisando las variables que utilizo y eliminando todo aquello que no es necesario ó que no está al 100% implementado (o funcionando como debiera).

Seguramente para el fin de semana ya tendré lista una versión todavía muy Alpha.

Tomando decisiones...

2011-09-26T13:17:00.002+02:00

He estado repasando entre todo el material de mis backup los proyectos que he ido desarrollando desde la creación del blog...

Tras el disgusto del disco duro me he propuesto terminar como mínimo uno de los juegos ya mismo, sin más pausas ni esperas... tengo varias opciones:

El juego principal y objeto inicial del blog se me antoja como un proyecto demasiado largo; sólamente la parte de diseño de mapas se puede alargar casi un año más... creo que es demasiado tiempo para un desarrollo en solitario.

De momento lo voy a aparcar. Siempre puedo volver a él ya que tengo todo el código fuente guardado y comentado para futuros usos.

De éste diseño casi no hay explicaciones en el blog. No he comentado ni el gameplay ni el objetivo del juego, aunque sí algunos post sobre el diseño del mismo (ya que en este caso es la parte importante del desarrollo).

Lo voy a dejar a un lado... los diseños de éste proyecto son los que he perdido en la tragedia; ahora mismo no pienso repetirlos. Quizás más adelante...

Finalmente me queda esta otra idea... se trata del juego que escribí mientras estaba con mi madre, durante su convalecencia por causa del accidente que sufrió.

Tengo montado el gameplay, los gráficos... faltaría implementar un sistema de menús, la parte iOS y pulir ciertos detalles para terminar. Creo que me voy a quedar con ésta opción; me apetece bastante terminar este proyecto con píxeles gordos...

... Más noticias en breve.

SYSTEM FAILURE

2011-09-23T12:38:00.004+02:00

Como en la película Matrix, la máquina principal donde programo se ha "detenido"... el ordenador llevaba varios dias avisándome con inestabilidades, cuelgues, reinicios automáticos, etc...

Finalmente (y como era de preveer) el sistema ha fallado y ahora me toca renovar el equipo...

Lo peor es que he perdido el disco duro y los últimos avances de mis desarrollos con GLB/Photoshop...

Ahora me planteo recuperar/retomar algún proyecto del backup ó por el contrario seguir con lo que tengo "a medias", aunque ésto puede significar el repetir las últimas versiones de todo (sinceramente no me apetece nada).

La verdad es que estoy bastante bajo de moral... :-(

Vuelta al trabajo...

2011-08-29T10:05:00.000+02:00

He desconectado por casi tres semanas. Cero programar. Cero diseñar. Cero TI.

Había que descansar un poco...

Hoy... vuelta al trabajo...

Lógica terminada, peparando interface

2011-08-08T10:59:00.001+02:00

He terminado la programación básica de la aplicación. Falta por retocar algunos detalles bastante sencillos que iré puliendo a medida que implemento el aspecto gráfico final.

Como ya he comentado, el proyecto es muy simple... ;)

GLBasic v10.057 - Fichero log_e.gbas

2011-07-26T09:52:00.000+02:00

A continuación los cambios introducidos en el lenguaje así como los diferentes avances (y solución de bugs) para las "nuevas" plataformas soportadas.

Ahora podemos compilar para: Win32, Win32-DLL, Linux, OsX, iOS, WebOs, Android, WinCE, GP2X, Wiz y Pandora... :D

(fichero log_e.gbas)
// 10.057 *** RELEASE V10 ***
// WebOS:
// Bugfix for MOUSESTATE.
//
// Android:
// NETWEBEND works.

// RC 10.053
// Core:
// LOADSPRITEMEM pixels were not returned.
//
// Android:
// Compiling failed.
// Compiler warning in ant/main_rules.xml has been solved.(Release)
// Cleaning works even if ADB is running.
//
// WebOS:
// SYSTEMPOINTER TRUE is forced.

// RC 10.051
// Core:
// GETPIXEL ignored SETORIENTATION.
// KEY() slightly faster.
// GRABSPRITE didn't work on some platforms when out of screen.
// MOUSESTATE/MOUSEAXIS code reqritten from scratch.
// Acceleration values are correct now.
//
// WebOS:
// KEY() for gestures works better.
//
// Android:
// CREATESCREEN can fallback to GRABSPRITE method if unsupported.
// Icon gets shiny default frame.
// PLATFORMINFO$("DEVICE") returns "KEYBOARD" or "TOUCHSCREEN".

// RC 10.042
// 3D:
// X_SCALING and shadows work together (very small speed impact).
// X_SPOT_LT -3: first call sets light colour. It's flushing shadows
// when you turn that light off.
//
// WebOS:
// DECLARE calls will fail now. HP disallows the use of dlopen/dlsym API.
// You can submit to the HP store again, now.
// Icons are 64x64 pixels (as required for WebOS). Must restart device to
// regenerate icon cache.

// RC 10.013
// Editor:
// Fixed a code folding bug.
//
// Win32:
// F10, LAlt do no longer pause/lock the application.
//
// DDgui:
// Combo uses list for the box. Scrolls item into view.
//
// 3D:
// X_LINE changed colour of 3D objects drawn afterwards.
// Shadows where covering lit side of flat objects.
// X_SPOT_LT -3: The shadow is tainted with the colour now.

// RC 10.012
// New command:
// SOCK_GETREMOTEIP, SOCK_GETREMOTEPORT // remote computer info (also UDP)
// SOCK_SETBLOCKING // blocking mode of socket
// X_GETMATRIX // Get current matrix for X_DRAWOBJ position
// SETORIENTATION iMode // Set the screen rotation (iPag e.g.)
// GETORIENTATION() // ... and get that value.
//
// Editor:
// New function File/Project/Clean up
// that cleans out build files.
// User keywords must be 2 characters long at least now.
// Icons must be transparent PNG for transparency now.
// Icons are scaled using bicubic filter -> excellent quality.
// gbas/gbap files have different icons now.
// Mac-Icons are generates from the icon.png file.
//
// Project options -> Version number is available.
// You can query it with PLATFORMINFO$("VERSION").
//
// All platforms except Win/Linux build into "distribute" directory now.
// .app/Media is copied into distribute on build.
//
// Core:
// Programs also try to load Media/smalfont.png and Media/smalfont.bmp
// on startup.
// INKEY$ works much better and buffers multiple
// key presses druing one showscreen cycle (up to 16).
// INKEY$/INPUT$ returned \r instead of \n. Bug is fixed.
// URLENCODE$/URLDECODE$ caused wrong output with
// codes>127. It will be converted ISO 8859-1 to UTF-8 first
// so php can properly interact with GLBasic now.
// Shoebox leaked memory.
// CONSTANT yielded compiler errors (assign to const object).
// GRABSPRITE id,0,0,0,0 frees the memory. Was a bad leak.
// Fixed bug in loading JPEG images.
// PLATFORMINFO$("APPDATA") is added.
// VIEWPORT on USESCREEN was using wrong y values.
// NET... commands might have dropped packages.
//
// 3D OpenGL|ES (mobile platforms):
// X_SCREEN2WORLD and X_WORLD2SCREEN work now. glGetFloatv() was not supported.
// Clipping improved.
// Loading Fragment shaders only works again.
// Mipmapping ignored -> shows textures now.
//
// Compiler:
// Nested ?IFDEF might have caused trouble.
// ?DEFINE always was triggered.
// 2-pass-compiler implemented. GLOBAL declarations
// from other files are known in stage 2 now.
// This allows:
// INC foo.bar; TYPE Tfoo; bar; ENDTYPE; GLOBAL foo AS Tfoo
//
// Win32:
// SHELLCMD did not return to fullscreen.
//
// MacOSX:
// INKEY$ returned improper stuff for cursor and del keys.
//
// iPhone:
// SLEEP is working properly now.
// HiRes (iPhone 4) icons are generated.
// Default~.png images from .app directory are copied to XCode project.
//
// Pandora:
// GLBasic builds a full featured .pnd package for you.
// The screen size is not fixed anymore, allowing it to run
// on OMAP-3 devices as well.
//
// WebOS:
// appinfo.json is filled with version number and proper strings.
// Fixed crash on 2.1.0 in SPRITE2MEM, SPRCOLL and GRABSPRITE.
// Mousecount limited to 5. More seems to be inaccurate.
// SOCK_GETIP() crashed.
// Ports on firewall for listening were not opened.
// -> internally done with PDL_SetFirewallPortStatus() now.
//
//
// Android:
// possible crash at startup fixed.
// Fix with spaces in path (GLBasic installation and project path)
// Pause does not crash anymore.
//
// Wiz:
// Fix of crash on startup.

Primera pantalla del "proyecto turbo"

2011-07-26T00:15:00.000+02:00

Con la programación principal en un 70% (luego sólo quedarán los detalles de implementación del GUI final), presento aquí la primera captura del juego de programación rápida (no invertir un año) para plataforma iPad en el que me he metido.

Espero tenerlo listo en 15 días... Luego vendrá la mejor parte... el diseño del GUI... y los posibles problemas con la Appstore.

GLBasic v10.057 publicado

2011-07-24T22:00:00.000+02:00

Descargando la última versión del programa. En cuanto instale comento las novedades que se incluyen. (La actualización desde el IDE indica erróneamente que v9.040 es la más actual).

Trabajo, trabajo, trabajo... :(

2011-07-21T11:22:00.001+02:00

Ni dos minutos para rascarme... :-/

Foro GLBasic - Haz un juego en 3,5 horas

2011-07-08T11:17:00.000+02:00

Killy Hello ha publicado un tutorial mostrando las excelencias de GLBasic. Según el post del foro, en 3,5 horas es posible realizar un juego "como Dios manda".

El hilo sobre este tema esta aquí.

El enlace para descargar el juego Frogs 1x1 está aquí.

"Mini pausa" para nuevo proyecto...

2011-07-05T11:02:00.000+02:00

He pensado en realizar una prueba con la appstore de Apple. Para esto se me ha ocurrido desarrollar un juego sencillo, con un gameplay también sencillo. Gráficos pixel y jugabilidad rápida. ;-D

Quiero probar el funcionamiento de la tienda, posibles problemas que me puedo encontrar, qué material necesito en el momento de publicar (banners, imágenes, instrucciones, requerimientos web), etc.

No me gustaría terminar el "mega proyecto" y encontrarme con problemas a la hora de publicar.

Preparando Bots para el juego

2011-06-25T13:27:00.000+02:00

Toca, además de diseñar los niveles... incluír personajes NPC que poblarán los mapas. Habrá bots diferentes, cada uno programado para una función específica.

La imagen corresponde a uno de los primeros diseños; como se aprecia el look está basado en el personaje principal, ya que no quiero variar el estilo de dibujo.

Montando mapas...

2011-06-14T02:03:00.001+02:00

Primeras pruebas con el mobiliario inicial.

Amueblando los mapas...

2011-06-10T13:39:00.001+02:00

Como si de un IKEA se tratara, estoy redecorando los mapas. Diseño los muebles y luego los posiciono en el mapa mediante mi propio editor...

Un trabajo relajadito para unos cuantos días...

Diseñando los muebles...

2011-06-06T08:39:00.000+02:00

Ha llegado el momento de convertir los aburridos tiles de prueba, en gráficos a la altura de la aventura...

Rutina alternativa a la función SLEEP

2011-06-02T00:05:00.000+02:00

Encuentro en el foro de GLBasic la siguiente rutina para reemplazar la función SLEEP.

finishTime%=GETTIMERALL()
WHILE ABS(GETTIMERALL()-finishTime%)<1000
WEND

Creo que voy a emplearla mientras modifico el main loop, ya que GETTIMERALL() sí funciona sin problemas en iOS.

Añadiendo Twitter "Botón de Seguir"

2011-06-01T13:37:00.000+02:00

Twitter ha presentado el "Botón de Seguir", así que lo he incorporado al blog, para así facilitar el seguimiento de la cuenta. Gracias Twitter!!!

Más info sobre cómo implementar el botón en el Blog de Twitter.

SLEEP no funciona en iOS

2011-06-01T08:15:00.001+02:00

Comprobado. Definitivamente, parecer que la función SLEEP no funciona en iOS, o por lo menos en la versión de GLBasic 9.040 que es sobre la que estoy trabajando en la actualidad.

En el foro de GLB algunos usuarios presentan una solución basada en un bucle y el timer de la máquina; con lo que se simula la función que falla. Válido como parche temporal pero opino que no es el remedio ideal para mi app.

La mejor opción en mi caso, es replantear todo el bucle principal. He de gestionar muchas variables en tiempo real, por lo que necesito que el main loop funcione mejor que un reloj suizo.

T-Shirt Litiopixel modelo 2

2011-05-27T12:13:00.001+02:00

Nueva camiseta del proyecto... hay que estar guapo para recibir a las visitas... ;D

Mini KDD en Barcelona...

2011-05-27T12:07:00.002+02:00

He quedado con mi amiguete Javier (socio mío en el difunto proyecto Monkeydreams.net, ver sección Abandonware) que viaja desde Valencia a pasar el fin de semana.

Obligada charla geek y muestra de la evolución del proyecto en el iPad...

Y como no, aprovecharemos para dar una vuelta por la Apple Center de la Maquinista, a ver qué tal...

Versión test para GP2X / WIZ

2011-05-27T01:56:00.003+02:00

He preparado una versión especial para GP2X y WIZ. He reducido todos gráficos del fondo a un ancho de 320 píxels para reducir la carga de memoria. Aún así el 90% de los gráficos son los originales para iPad.

El juego funciona perfectamente, aunque tiene un fallo de flickering (parpadeo de pantalla) bastante notable. Sólo he adaptado la ventana de render a 320x240, el resto del código es el mismo y por tanto los cálculos de reloj y frames están pensados para una máquina más potente.

ACTUALIZACIÓN: Javier ha probado el código en WIZ y no funciona. ¿Alguna pista?

Test Movimiento y control de objetos 2

2011-05-24T10:34:00.002+02:00

Segundo test de control de movimiento e interactividad con los objetos del mapa. Recomendada reproducción a 720p.

NOTA: La velocidad de reproducción no corresponde con la realidad ya que la herramienta para capturar vídeo más luego una conversión compatible con Youtube ralentiza el vídeo.

Grabador / reproductor de acciones

2011-05-23T14:31:00.001+02:00

He desarrollado una sencilla función destinada a implementar como IA a los bot que voy a utilizar en el juego. Almaceno en una matriz una serie de acciones que se reproducen de forma encadenada cuando "la situación de la historia" llega a un punto concreto.

Ideal para representar escenas, acciones automáticas e incluso lo puedo emplear si lo veo necesario a modo de tutorial.

Mapas con persistencia

2011-05-18T20:52:00.000+02:00

Estoy creando ya algunos mapas. Para el juego, he pensado en definir un mapa por habitación/zona en lugar de declarar un mapa gigantesco delimitado por zonas.

La ventaja de utilizar mapas reducidos frente a enormes matrices es que de esta forma me permite cargarlos rápidamente. La gestión de objetos y eventos la realizo por cada zona... hay muchas variables que se mantienen constantes por mucho que se cambie de mapa, como por ejemplo la luz global.

Lo más complicado es mantener una coherencia con el entorno. Una puerta que se abre en cierta zona, debe permanecer abierta hasta que se cierre, por mucho que cambiemos de habitación. Esto me obliga a almacenar el estado de un mapa cuando el jugador pasa a otra sala.

Finalmente lo he solventado almacenando en el disco un fichero backup.x por cada zona que se visita (x es el número que corresponde al mapa).

Cuando el jugador vuelve a un mapa que ya se ha visitado, recupero el fichero backup correspondiente, ya que contiene el estado de items/traps que anteriormente he guardado.

Dos tipos de movimiento

2011-05-16T19:33:00.000+02:00

He incluído dos tipos de movimiento de mapa con respecto al personaje principal. Por una parte tenemos que el que se mueve es el protagonista (captura de pantalla izquierda) y por la otra parte (derecha), que el que se mueve es el mapa, quedando el personaje principal siempre en la misma posición.

En función del tipo de mapa seleccionaré un movimiento u otro.

Vamos que nos vamos!!!

2011-05-14T00:27:00.004+02:00

Ya! Por fin! rutina TouchControl finalizada por fin, así que... PODEMOS AVANZAR! ...esta vez de verdad ;)

El blog se estaba convirtiendo casi en un monólogo sobre el tema del control de pantalla. Rutina reescrita hasta la saciedad y probada en inumerables pruebas...

Creo que ya está terminada, no la toco más... Amigos que han probado el programa también lo confirman así que la doy por cerrada. Gracias por probar la app!!!! ;)

Creo que con esto de "retocar y retocar y retocar el código" he aprendido a no obsesionarme y centrarme en una sola rutina, sobretodo si se trabaja solo como es mi caso. Quizás he dedicado demasiado tiempo desarrollando en exceso una función que ya funcionaba correctamente en versiones anteriores... hmmm.

Un mundo en "capas"

2011-05-13T21:40:00.005+02:00

He organizado mi mundo por capas. Cada capa está alojada en una matriz. Cada matriz es diferente dependiendo de la cantidad de contenido a almacenar. Veamos cómo se me ha ocurrido organizar todo esto.

He creado varias matrices que contienen todos los datos referentes al mapa; suelos, objetos, triggers, etc. Cada capa tiene un tamaño diferente para así poder acceder más rápidamente a datos específicos de cada ítem.

MAPA_Matriz_Graficos%[] Contiene los datos de los gráficos del decorado.
MAPA_Matriz_Bloqueos%[] Capa obstáculos. (Muros).
ITEMS_Mapa[] Matriz lineal cantidad n de objetos.
TRAP_Mapa[] Matriz lineal triggers.

Primero cargo la matriz principal MAPA_Matriz_Graficos%[], empleando el típico bluce:

FUNCTION Carga_Datos_Mapa:
  LOCAL Disco=OPENFILE(1,MAPA_Fichero_Matriz_Graficos$,TRUE)
    IF (Disco)
      FOR Contador_Temp_Y=0 TO MAPA_Tamano_Alto-1
        FOR Contador_Temp_X=0 TO MAPA_Tamano_Ancho-1
          READBYTE 1,MAPA_Matriz_Graficos[Contador_Temp_X][Contador_Temp_Y]
        NEXT
      NEXT
      CLOSEFILE 1
    ENDIF
ENDFUNCTION

Es necesario también definir los muros del mapa:

REDIM MAPA_Matriz_Bloqueos[0][0]
REDIM MAPA_Matriz_Bloqueos[MAPA_Tamano_Ancho][MAPA_Tamano_Alto]
RESTORE LISTADO_DATOS_MAPA_0_BLOQUEOS

LOCAL Dato$
FOR m=0 TO MAPA_Tamano_Alto-1
  READ Dato$
  FOR n=0 TO MAPA_Tamano_Ancho-1
    MAPA_Matriz_Bloqueos[n][m]=MID$(Dato$,n,1)
  NEXT
NEXT

STARTDATA LISTADO_DATOS_MAPA_0_BLOQUEOS:
  DATA "0000000"
  DATA "0001000"
  DATA "0001000"
  DATA "0011100"
  DATA "0011100"
  DATA "0011100"
  DATA "0011100"
  DATA "0011100"
  DATA "0011100"
  DATA "0011100"
  DATA "0001000"
  DATA "0001000"
  DATA "0000000"
ENDDATA

A continuación cargo todos los datos referentes a los objetos y triggers:

ITEMS_Cantidad=9
REDIM ITEMS_Mapa[0]
REDIM ITEMS_Mapa[ITEMS_Cantidad]

RESTORE LISTADO_OBJETOS_MAPA_0

FOR n=0 TO ITEMS_Cantidad-1
  READ ITEMS_Mapa[n].PosX
  READ ITEMS_Mapa[n].PosY
  READ ITEMS_Mapa[n].Grafico
  READ ITEMS_Mapa[n].Evento
  READ ITEMS_Mapa[n].Activado
  READ ITEMS_Mapa[n].Tipo
  READ ITEMS_Mapa[n].DatoExtra
  READ ITEMS_Mapa[n].DatoExtra_B
NEXT

STARTDATA LISTADO_OBJETOS_MAPA_0:
  DATA 3,4,2,2,0,1,0,0
  DATA 3,1,4,4,0,1,3,1
  DATA 3,2,3,3,0,1,3,1
  DATA 3,6,2,5,0,1,2,0
  DATA 2,3,8,7,0,0,0,0
  DATA 3,10,4,0,0,1,0,0
  DATA 3,11,3,0,0,1,0,0
  DATA 4,4,8,7,0,0,0,0
  DATA 4,6,8,7,0,0,0,0
ENDDATA

TRAP_Cantidad=4
REDIM TRAP_Mapa[0]
REDIM TRAP_Mapa[TRAP_Cantidad]

RESTORE LISTADO_TRAPS_MAPA_0

FOR n=0 TO TRAP_Cantidad-1
  READ TRAP_Mapa[n].PosX
  READ TRAP_Mapa[n].PosY
  READ TRAP_Mapa[n].Salto_Mapa
  READ TRAP_Mapa[n].Salto_PosX
  READ TRAP_Mapa[n].Salto_PosY
  READ TRAP_Mapa[n].Direccion_Vista
  READ TRAP_Mapa[n].Activado
  READ TRAP_Mapa[n].Tipo
  READ TRAP_Mapa[n].Grafico
NEXT

STARTDATA LISTADO_TRAPS_MAPA_0:
  DATA 3,7,0,0,0,0,1,1,16
  DATA 2,4,0,0,0,0,1,2,17
  DATA 2,8,0,4,2,0,1,3,18
  DATA 4,2,0,2,8,0,1,3,18
ENDDATA

El porqué de cargar todos los datos por separado es principalmente por la necesidad de almacenar más de un valor en una posición del mapa XY.

Inicialmente pensé en realizar una matriz bidimensional y que con diferentes valores ya se definirían los ítems y cómo interactuar con ellos. Más tarde se me ocurrió que un mismo objeto no tenía porqué reaccionar siempre igual. Un botón en el mapa realiza siempre la misma acción (visual), pero en cambio puede "realizar" acciones diferentes (encender la luz, abrir una puerta, etc). decidí hacerlos "programables".

Pensando en alguna forma de almacenar más de un dato en una posición determinada del mapa llegué a lo siguiente...

Como ya se ha visto, cargo los datos referentes a los muros en una matriz bidimensional que corresponde al ancho y alto del mapa. Luego cargo los datos de los objetos y también los triggers en una matriz lineal sobre un objeto definido por TYPE, tal como se ve en el código.

Los objetos que son NO movibles ni recogibles son insertados en la matriz principal y me olvido de ellos, puesto que se comportan como muros a nivel del Algoritmo A* aunque siguen puediendo provocar eventos.

A todos los objetos se les puede asignar una acción (evento) que se declara también. El mismo método es el empleado para los triggers pero a diferencia de los objetos, son invisibles y SIEMPRE traspasables por el jugador.

Cuando el personaje encuentra una posición del mapa que contiene un objeto, un trigger ó ambos, se recorre la matriz lineal del objeto/trigger para localizar el ítem en cuestión y cómo ha sido programado éste. Si se ha definido un evento se ejecuta, en caso contrario se devuelve el control al jugador.

Finalmente señalar que de esta forma consigo dos cosas: la matriz de objetos es más pequeña por lo que consume menos memoria siendo más rápido su acceso y por otra parte poder almacenar hasta 7 variables en una posición XY del mapa.

Supongo que se ha entendido... :-P

Presentando progresos...

2011-05-11T14:26:00.000+02:00

15 días sin publicar ningún avance en el blog...

Como ya comenté en el post anterior, he estado trabajando en la sombra y es hora de hacer públicos los avances de tanto trabajo oculto. (Nota mental para mí: modificar hoja de ruta ;))

En la última publicación del blog estaba en la versión 04a y actualmente ya he avanzado hasta la actual número 23 (la anterior, 22Clean es la última cargadita de líneas REM sin "limpiar").

Tanto número de versión puede parecer muy liante, pero encuentro que es una forma de tener organizado todo el desarrollo del proyecto. En lugar de andar con SVN y similares, realizo manualmente la copia del proyecto cada día en una carpeta que luego guardaré en un DVD (o dos).

El proyecto está muy avanzado. He reescrito mucha parte del código y también he modificado algunas rutinas sobre las que no estaba muy satisfecho. La rutina de ControlTouch (encargada de gestionar DÓNDE y QUÉ hacer al pulsar en pantalla) la he vuelto a desarrollar desde cero y no he parado de probarla hasta la saciedad.

La definición del "mundo" y los mapas ha sufrido alguna que otra variación. Es un tema que dejo pendiente para una posterior publicación en el blog, ya que me gustaría explicar cómo he diseñado toda esta parte.

La animación del personaje así como su interacción con el "mundo" también ha sido modificada; actualmente el protagonista puede detectar que tipo de objeto ha tocado y consecuentemente realizar la acción que corresponda. También detecta si hay objetos recogibles, traspasables, etc...

Ah! Y he añadido un trigger para teletransportación... :D

Avanzando poco a poco...

2011-04-26T22:42:00.000+02:00

Trabajando en la sombra... cortar, pegar, eliminar, añadir... estoy a nada de tener la versión recon finalizada.

Llegado a este punto puedo proseguir por fin con el diseño de mapas.

GLBasic actualizado a 9.040

2011-04-13T19:14:00.005+02:00

El pasado mes de Febrero, Gernot anunció en el foro de GLBasic la actualización a la versión 9 tal como ya comenté en el blog. Esta semana he actualizado a la última versión.

Aprovecho para publicar el log completo de actualizaciones desde la versión 8.x.

A destacar la incorporación de Android en el SDK.

(fichero log_e.gbas)
// 9.040
// Kern:
// NETWEBGET$ returned nothing when the buffer was too small.

// 9.033
// Pandora:
// Windows compiler included. Please install
// setup>=9.033.
//
// Core:
// INPUT with optional font kerning option.
// ENCRYPT$ with empty strings was broken.
// Fixed memory leak in GRABSPRITE with
// landscape mode on mobiles.
//
// Using proper character translations for
// INKEY$ (works for äöü, éèê and others)

// Editor:
// Can include any text files to your project now.
// Sorting project files by file name now.

// 9.026
// Win32:
// Sound was broken.

// 9.024
// Win32:
// Crash of 021 update is fixed.
// iPhone:
// Retina display returns proper touch coords.
// Mac OSX:
// No more SDL_mixer dependency. MP3 runs!
// Remove compiler\platfofm\Mac\runtimes\frameworks\SDL_mixer
// to get smaller builds.

// 9.018
// WebOS:
// lib was missing.

// 9.015
// Editor:
// Strange flickering should be fixed.

// 9.014
// Core:
// TRIM$, right trim and iniopen had problems
// with umlaut characters (ascii > 127)
//
// DECLARE was buggy. The libraries will be loaded after
// initialization of the GLBasic core now. Debug output is
// made for errors.
//
// ENCRYPT$ could have crashed (internal memory overflow)
//
// 3D: Shadows for scaled objects were totally wrong.
//
// WinCE:
// DOESFILEEXIST didn't work.
//
// Pandora:
// Framebuffer object was not linked properly.
//
// Editor:
// Last edited platform is remembered for project options.
// Scrolling with mouse wheel is limited to visible text.

// 9.006
// Core:
// License problems solved.
// Pandora-lib was old.

// 9.003 - RELEASE 9
// Core:
// Problems with memory allocation in arrays fixed.
//
// New Command:
// PAUSEMUSIC
// LOADSPRITEMEM() - load image pixels to DIM array.
//
// WebOS:
// Landscape mode implemented
//
// WebOS/Linux/Mac:
// SLEEP with < 1000 ms failed. Bug is fixed. // // Core: // INSTR had a bug when both string lengths were identical. // // Win32: // Using DirectX 8 for input (was DX 5 before) // // Editor: // Fixed flickering on document tabs. // Fixed some minor Windows 7 issues. // Debugger works on Windows 7. // Debugger does no longer lock the file. // Mouse works better when debugging. // Docked windows remember their position. // Minor IDE fixes with new compiler and runtimes. // New runtimes - no more external runtime setup. // Colour selection is applied to all documents at once. // Ctrl+C was assigned to Compiler/Stop building instead of Copy.

LitioPixel versión "ReCon 04a"

2011-04-13T13:41:00.000+02:00

Muchos días sin actualizar el blog... pero sin dejar de trabajar en el proyecto.

He cogido todo el listado que tengo impreso y he empezado a copiar/pegar las funciones que ya están "cerradas" (sin cambios por el momento) y las he colocado en un nuevo proyecto LP con nombre en clave "ReCon" (ReConstruyendo).

Estoy obteniendo una "nueva" versión de LitioPixel muchísimo más optimizada, que trabaja más rápido y con muchos menos líos de bucles aprovechando las funciones del proyecto que ya tengo.

Por otro lado estoy renombrando algunas variables para tener el código fuente bien claro (necesario siempre que se quiera revisar el trabajo a posteriori).

Sinceramente, ya tengo ganas de terminar todo el entorno del juego y dedicarme 100% al diseño de mapas, etc...

Buscando bichos

2011-03-27T23:32:00.001+02:00

Siempre imprimo mis listados cuando tengo el proyecto en un estado estable y avanzado. Se descubren muchas sorpresas en el código en no pocas ocasiones. Yo he encontrado muchas secciones que puedo limpiar bastante y así poder eliminar de paso bastantes variables innecesarias tras la optimización.

Como ya tengo la estructura del juego definida esta semana empezaré repasando el listado del juego y poniéndo en práctica las notas que he realizado en lugar de proseguir con el desarrollo del guión. He encuadernado el todo lo impreso para poder consultar las anotaciones de forma cómoda en un futuro. Nunca se sabe si hay que rebobinar.

Problemas con el IDE...

2011-03-25T00:08:00.000+01:00

He perdido dos días detrás de la "tontería" del IDE. Como se ve en la imagen perdí en el último upgrade los textos correspondientes a las pestallas del ControlTab de los ficheros.

Realmente imposible el programar así... aunque finalmente hallé la solución CAMBIANDO EL TEMA DE ESCRITORIO DE WINDOWS. Algún fichero del sistema se habrá corrompido...

Enlace al foro donde comento el asunto y al final, la solución (UK).

Hora de escribir el guión...

2011-03-20T14:20:00.001+01:00

Bien, tras bastantes pruebas de objeto+evento+reacción satisfactorias, creo que ha llegado el momento de aparcar el ordenador por algunos días y empezar a desarrollar sobre el papel, el guión de la aventura.

Tengo descrito en mi cuadernillo de bolsillo la base de la historia y tengo más o menos claro las dificultades, puzzles y trampas que tendrá que superar el protagonista de la aventura, pero ahora toca diseñar los mapas con cierta lógica y sobretodo con una estructura sólida en ambientación y coherencia.

Quiero planificar todo muy bien para evitar que el jugador se quede atrapado dentro del juego y se tropiece con algún punto muerto sin salida... por falta de algún objeto o acción no realizada en orden u omitida...

Test Movimiento y control de objetos

2011-03-19T12:45:00.000+01:00

Test de control de movimiento e interactividad cn los objetos del mapa. Se prueban los triggers y el guardado de partida. Recomendada reproducción a 720p.

NOTA: La velocidad de reproducción no corresponde con la realidad ya que la herramienta para capturar vídeo ralentiza el juego.

iPad Test Movimiento 003 - GLBasic - 60 FPS

2011-03-17T23:58:00.000+01:00

Video prueba en iPad. Muestra del desarrollo en vertical. Efecto de luz y "trampas" objeto.

Compilando con Xcode 4

2011-03-15T09:57:00.001+01:00

Por fin todo funcionando de nuevo; he estado muy entretenido actualizando la máquina, realizando backups, etc... y ya tengo todo de nuevo instalado correctamente.

A saber:
- Ipad actualizado a iOS 4.3
- Máquina virtual Windows actualizada*.
- GLBasic actualizado a la última versión 9.x
- XCode actualizado a 4.x

Como se puede ver en la captura, XCode ha sido modificado en su aspecto sustancialmente recordando mucho al interfaz de iTunes y tras el susto inicial (sobre el que ya estaba bajo aviso) de redistribución DE TODO... estuvé 20 minutos viendo los cambios y finalmente compilé la aplicación para el Ipad sin más pegas.

* NOTA: Probadas aplicaciones Parallels y VMware para MacOS... me sigo quedando con VirtualBox; yo diría que es el más rápido en mi máquina entorno.

"Run with Performance Tool"

2011-03-10T22:16:00.003+01:00

He puesto a prueba una de las utilidades que mejor he encontrado a la hora de programar algún aparato conectado al ordenador. La experiencia recuerda mucho a Palm, que también dispone de monitores similares.

Como muestra la captura, estoy consumiendo casi 64 mb de memoria RAM. Creo que es demasiado así que habrá que ver cómo descargar ésos gráficos que no se necesitan durante el juego como el fondo del menu, etc. En cuanto a velocidad, perfecto como un reloj suizo.

El momento correspondiente en el juego...

Modificada hoja de ruta

2011-03-09T23:20:00.002+01:00

Añadidos cambios por corregir, entre otros:

- Reescribir rutina SWITCHES para simplificarla.

- Implementar control de Script de la historia.

- Organizar variables y eliminar sobrantes en rutina carga mapas.

- Reducir datos para rutinas Save_Slot()n.

- Optimizar control bucle principal.

- Limpiar código de datos obsoletos y líneas con comentario //.

Datos "geek" sobre el proyecto

2011-03-09T13:12:00.001+01:00

Como curiosidad solamente, ya que en la práctica no sirve para nada, presento algunos datos inútiles sobre el proyecto:

1.918 Comandos.

6,1 Segundos para compilar en un PC Windows Vista Basic(32). Intel Core2 Quad 2.66 Ghz, 4Gb Ram.

18 Ficheros *.gbas.

71 Funciones declaradas.

108.245 Carácteres.

Y seguimos adelente... ;-)

Gestión de objetos y eventos

2011-03-09T08:26:00.002+01:00

He preparado tres mapas sencillos para test. La idea es probar las interconexones entre diferentes salas así como la interactividad de los diferentes objetos con el entorno.

Tengo que tener en cuenta bastantes variables cuando se trata de preparar un entorno de juego coherente. Las luces, el comportamiento de los diferentes ítems así como muchos parámetros que se arrastran de una habitación a otra...

De paso voy autodocumentando mis funciones de generación y gestión de eventos relacionados con los objetos. Hay que tener en cuenta muchas cosas... ;-)

Boceto de mapa

2011-03-05T00:13:00.001+01:00

Aprovecho unos minutos libres para bocetar alguna posible distribución del mapa...

Probando iOSMessageBox()

2011-03-01T15:02:00.004+01:00

El amigo David me invita a probar su función para mensajes tipo MsgBox de Windows, que está implementando en el proyecto Xcode+GLB:

iOSMessageBox(const char*,const char*, const char*, const char*)

Se trata de una función para mensajes de alerta totalmente personalizable que emplea llamada a la función nativa de iOS. Lo curioso del asunto es que en iPhone 4, iPhone 3Gs, y iPod funciona sin problemas... pero en el iPad se obtiene un error de lo más curioso:

2011-02-27 23:07:28.120 msgbox[2697:6003] bool _WebTryThreadLock(bool), 0x14eb90: Tried to obtain the web lock from a thread other than the main thread or the web thread. This may be a result of calling to UIKit from a secondary thread. Crashing now...

La verdad, no acabamos de entender porqué en unas máquinas iOS sí funciona y en el iPad no.... ¿culpa de GLB? ¿XCode? ¿La mezcla de ambas? hmmm.

David por su parte sigue en la brecha... ¡adelante!

NOTA actualización: Me comenta el compañero que al parecer la función no trabaja correctamente con iOS 4.2.1 y sí en la versión anterior... hmmm ¿cambios del Xcode? ¿algún fix de GLBasic que no funciona?

Ops! Volviendo a orientación vertical....

2011-03-01T10:23:00.000+01:00

Estos últimos días he estado realizando algunos test con la orientación de pantalla y la barra de aplicaciones...

Como ya comenté en un post anterior (y también en el Foro de GLBasic), existe un problema extraño con GLB y la resolución horizontal en el iPad (desconozco si el problema se reproduce en el iPhone).

Se supone que si en Opciones declaramos la resolución 1024x768, el iPad debe funcionar en pantalla con horizontal... en realidad es así, aunque he observado que al pulsar en el botón home, éste se presenta en una orientación que NO corresponde...

Total, que tras algunas pruebas he decidido pasarme a modo vertical 768x1024.

A fin de cuentas, la zona de juego de la aplicación está ubicada en un recuadro de 768x768 pixels, lo que me permite emplear la resolución vertical modificando tan sólo la ubicación de los paneles de información y algunos botones del juego.

A redistribuir espacios tocan...

Versión 0.50 Clean b

2011-02-24T01:19:00.000+01:00

Algunos días sin postear. He estado trabajando en limpiar el código. He llegado a la número 50 de esta versión, lo que quiere decir mínimo 50 días de trabajo. Cambio de número cada noche, ya que estoy continuamente retocando la fuente...

Estoy contento por la evolución del proyecto. He avanzado mucho estos últimos días, y aunque aparentemente no parece haya muchos cambios externos, la programación abierta que he escrito me permitirá avanzar mucho en poco tiempo.

Han sido dos noches eliminando sentencias repetidas, recortando funciones, eliminando variables que sobran, retocando algunos detalles de las tipografias, etc.

Trabajando desde la cueva.... ;-D

MsgBox y Teclado Virtual

2011-02-21T09:57:00.000+01:00

Este fin de semana he terminado de implementar las rutinas referentes a guardar partidas y configuración de la aplicación, que como ya he comentado aqui son rutinas totalmente transparentes al usuario.

He optado por crear dos Slots (ó zócalos) así el usuario tiene la opción de guardar hasta dos partidas diferentes.

Inspirado por los e-mails de David, he decidido también introducir un teclado virtual que no empleee ninguna función nativa de iOS. Esto me permite personalizarlo a mi gusto y según mi propio diseño.

De todas formas, no descarto utilizar algunas funciones de iOS, siempre y cuando no desentonen (en cuanto a diseño y aspecto) con el resto de la aplicación.

Renovando las "keys"

2011-02-17T14:41:00.007+01:00

Esta pasada noche intentando compilar la aplicación para iOS me encuentro con un error de los más simples que puede mostrarnos xCode; licencia caducada.

Renové hace unos días la licencia "Apple Developer Program", pero aún no me he puesto a generar las nuevas keys necesarias para firmar las aplicaciones...

Así que hoy toca precisamente eso, generar las claves, pasarlas a los iDevices y ya estará todo de nuevo listo para probar en la misma máquina. ;-)

Añadiendo el menú y opciones

2011-02-13T12:19:00.002+01:00

He montado un sencillo sistema de botones y control de menú. Ahora la aplicación arranca mostrando un menú con diferentes opciones.

Como en la pantalla opciones se pueden modifcar dos variables, he añadido también una función de guardado de configuración (automático y transparente al usuario).

Esta función se ejecuta al iniciar la aplicación y comprueba que exista un fichero con las variables mínimas de configuración. En caso contrario, se genera "litiopixel.cfg" con los parámetros por defecto.

Video HD - Test Movimiento y carga de mapas 1

2011-02-10T10:55:00.002+01:00

Sencillo test de movimiento y control de personaje. Test "tocar y recoger" objetos. Test de carga de niveles y variables que se transfieren de nivel a nivel (Luz).

Recomiendo activar la versión 720p en el reproductor de YouTube.

"GLBasic V9 is out"

2011-02-08T23:12:00.001+01:00

Hello Kitty anuncia en el blog oficial de GLBasic la publicación de la versión 9 del entorno. Como siempre con novedades interesantes. En dos días actualizo, ahora mismo tengo el asunto complicado...

Imágenes para el blog

2011-02-08T22:49:00.001+01:00

Esta tarde estaba buscando imágenes de calidad para el blog, cuando el amigo Google me ha llevado a una página muy interesante para mí por tratar el tema de síntesis de imágenes por ordenador.

La web es ignorancia.org, un sitio donde Jaime Vives muestra sus diseños con POV-Ray y MegaPOV.

Su trabajo es muy bueno y me recuerda que tengo muy olvidado a Curly Egg 3D, el blog sobre modelos de diseño propio con SketchUp que comparto con mi hermano.

Desde aquí, muchas gracias Jaime. ;)

Mejorando la función CODEPRINT

2011-02-08T13:03:00.002+01:00

Como ya he comentado, he desarrollado una función propia para pintado de textos multicolor en pantalla. La idea es muy simple... envío a la función CODEPRINT un texto similar a esto: "^C^THello^E^TWorld".

El funcionamiento de la función es muy simple; se recorre el contenido de la cadena de texto y se extraen los "comandos" para su interpretación.

De esta manera, basta con hacer una llamada a CODEPRINT Texto$,X,Y,Color_Base para tener el texto en pantalla con los añadidos programados. (Color_Base es la tinta empleada para escribir por defecto, aunque por comando se puede modificar como se muestra en la imagen).

Los comandos hasta el momento son éstos:

^T - Cadena de texto.
^E - Retorno de carro (enter).
^C - Color del texto.
^+ - Sangría a la derecha n espacios.
^- - Sangría a la izquierda n espacios.

Los introducidos en esta ocasión son los encargados de "sangrar" los textos.

Código empleado para la muestra de la pantalla adjunta:

CODEPRINT("Texto de muestra^E^+02^TTest de Alineación^E^-08^TDesplazando ^C2^Ttextos",290,300,5)

Hoja de ruta modificada

2011-02-04T12:18:00.001+01:00

Actualización de la hoja de ruta del blog con los nuevos cambios que ha sufrido el programa.

¡A por los objetos!

2011-02-03T14:15:00.001+01:00

Una vez finalizada toda la lógica de control del personaje principal, así como la detección de trampas y puertas... viene el momento de activar las funciones de control de objetos en el mapa.

Voy a reutilizar todo el código que desarrollé para la versión iPhone, así que espero que esta operación sea de lo más rápida.

¡AL ATAQUE!

Función TOUCH reparada...

2011-02-03T12:11:00.000+01:00

Llevaba unos días volviéndome loco; la función de detección de pantalla funcionaba aparentemente correctamente. Al compilar para iOS detecté en el dispositivo que en ocasiones el personaje se detenía y quedaba bloqueado sin posibilidad de ordenarle otro punto de destino.

Afortunadamente ayer encontré la causa del error: si se selecciona una posición de destino NO válida (por ejemplo un muro), las variables TOUCH_Pulsacion_Pantalla y TOUCH_Pulsacion_Pantalla_Mapa se quedan con valor 1. Evidentemente si se deja de pulsar la pantalla éstas deben contener 0.

Problema solucionado. Un tema menos.

Modificando la rutina Control_TOUCH

2011-02-02T14:02:00.000+01:00

Pues nada, que como soy ¿demasiado? perfeccionista, he vuelto a darle vueltas a la rutina que controla tocar la pantalla.

Hoy mismo la dejo lista ya al 100%

iPad Test Movimiento 002 - GLBasic - 60 FPS

2011-01-31T10:38:00.000+01:00

Segunda prueba de rendimiento para iPad. Muestra el desplazamiento del mapa asi como el funcionamiento de la función FINDPATH, las luces, sistema de puertas y rotación de pantalla. 58-60 FPS.

Acelerón de fin de semana...

2011-01-31T01:06:00.000+01:00

Fin de semana con muchos avances. He probado la aplicación en el iPad, que ya había avanzado bastantes versiones que no lo hacía. Todo correcto.

El problema de velocidad que se me presentó con la función FINDPATH ha sido solventada. Enlace del foro donde comento el asunto aquí.

Avances realizados en el proyecto:

- Rutina CODEPRINT para pintado de textos en colores y con tiempo/trigger para activación y desactivación terminada y depurada.

- Función de control de puertas terminada y depurada. Integrada en fichero mapa al guardar.

- Rutina de detección de trampas finalizada y depurada.

- Reajustados parámetros de matrices para velocidad y optimización del bucle principal.

- Sistema de interruptores de luz ambiente simple terminado.

- Implementación de rutina de rotación de pantalla con OpenGL. Ver imagen para el bug que me ocupa ahora... La correcta orientación con respecto a la barra de aplicaciones.

-Control de eventos terminado. Implementada AUTOPAUSE y multitarea para iOS 4.x.

Como se puede ver... un fin de semana de lo más productivo ;)

Pequeñas novedades...

2011-01-27T09:32:00.000+01:00

Aunque parezca que estoy desconectado, en realidad sigo trabajando en la sombra... He optimizando el código de animación del mapa+personaje principal y la interactividad de éste con el entorno.

Los "switch/traps" (trampas) introducidas en el escenario ya funcionan como deberían, así como la apertura/cierre de puertas...

Inspirado por los clásicos juegos de aventuras de Lucasarts (Wikipedia), he decidido implementar una tipografía similar. He añadido también al código general una pequeña función mía que sirve para poder representar los textos en diferentes colores dentro de una misma línea... ésto me permitirá resaltar nombres u objetos dentro de un mensaje...

Captura del código fuente de la rutina mencionada de tipografías que utilizo para los diferentes colores dentro de una frase/párrafo... No tiene más misterio que lo que se muestra. ;-)

Otra de las novedades es la inclusión de una "luz ambiente" al mapa que se puede modificar en tiempo real por switches. La captura muestra la sala a oscuras y simula un haz de luz de linterna (siempre que se posea el objeto, claro está)... poco a poco... ;-)

Scanlines?

2011-01-14T02:07:00.001+01:00

Planteándome si añado la opción de scanlines...

Estado actual del proyecto...

2011-01-11T05:47:00.039+01:00

Resumo aquí los cambios más destacados realizados al programa.

La causa principal de éstas modificaciones es la adaptacion del juego al formato de pantalla del iPad (1024x768 pixels). Como he ido narrando en el blog, he hecho test independientes de algunas rutinas que en Windows/iPhone ya tenía controladas sobretodo en cuanto al rendimiento y tamaño de la pantalla.

Inicialmente el tamaño de pantalla objetivo era la de iPhone. Se dedicaba casi 1/3 de ésta para alojar los botones de acción y panel con datos del juego. Dada la resolución elegida sólo se podia representar una sección del mapa de 7x7 tiles de 46x46 pixels.

Hay que recordar que al inicio del proyecto, GLBasic no soportaba Retina Display en iOS. (Esta resolución de vídeo quiero tratarla más adelante, cuando tenga el juego finalizado; parece ser que actualmente se han detectado algunos problemas de coordenadas).

El control de movimiento del personaje también ha sido cambiado. He dejado a probar a algunas personas el antiguo control de trazar el camino y la mayoría de ellas preferían la opción de hacer tap para marcar la posición de destino en contra del control propuesto. No descarto incluir también el otro modo de forma opcional. De esta forma he decidido controlar al personaje con la función FINDPATH.

He limpiado el código para optimizar y simplificar en lo más básico, intentado no emplear más variables de las justas. Tras algunos debugeos se puede ver en las capturas la totalidad de variables que se emplean.

Actualmente el juego carga un mapa del tamaño XY que se quiera, tan sólo hay que pasarle las coordenadas de salida y entrada del personaje y el tamaño ancho-alto del nivel. Éste se carga y representa adecuadamente en pantalla en función del tamaño y se recorta para dibujar sólo los tiles que se necesitan. El control de timer también se ha optmizado para el iPad, así como la animación del personaje principal. Editor de muros añadido...

Lo siguiente es afrontar la inclusión de objetos, así como otros personajes en el mapa... también voy a implementar la rutina de triggers de puertas y objetos en breve ya que es una función que ya tengo preparada; espero avanzar bastante en poco tiempo...

De momento, voy a ir pasando por caja... a renovar mi licencia del programa iOS.

iPad Test Movimiento - GLBasic - 60 FPS

2011-01-10T23:55:00.001+01:00

Dibujado completo del mapa en el iPad. Muestra el desplazamiento del mapa asi como el funcionamiento de la función FINDPATH. 58-60 FPS. Multitarea funcionando.

La calidad de la iluminación y enfoque en el vídeo es pésima, aunque se aprecia el movimiento del personaje.

Actualizada hoja de ruta

2011-01-08T12:22:00.001+01:00

Actualización de la hoja de ruta del blog. He modificado algunos de los textos que describen el proyecto.

Navidad 2010!

2010-12-24T00:00:00.005+01:00

Upgrade Retina Display GLBasic (8.174 -> 8.200)

2010-12-23T13:33:00.002+01:00

Una interesantísima actualización sobretodo para aquellos que desarrollamos para dispositivos iOS; Gernot ha añadido a GLBasic soporte para Retina Display, lo que permitirá realizar aplicaciones universales y aprovechar la pantalla como toca.

A probarlo ya!

La nueva versión incluye también un nuevo comando sencillo para tratamiento de cadenas de texto: REVINSTR.

(fichero log_e.gbas)
// New command:
// REVINSTR() - reverse find in a string.
//
// Editor:
// Undo/Redo groups are set properly now.
//
// iPhone:
// Retina display supported. Must set Project options
// resolution and check with GETSCREENSIZE if it's
// a high res device.
//
// [ Resolution Matrix ]
// XCode GLBasic iPod iPhone iPad
// iPhone+iPad,320x480 320x480 320x480 768x1024
// iPhone+iPad,640x960 320x480 640x960 768x1024
// iPhone ,320x480 320x480 320x480 320x480
// iPhone ,640x960 320x480 640x960 320x480
//
// Legend:
// XCode: Settings in the XCode project
// GLBasic: Project options in GLBasic IDE
// iPod: iOS 3.x or iPhone 2G, 3G, 3G[S]
// iPhone: iOS4.2+ and Retina display device
// (iPhone 4, iPod 4th gen)
// iPad: iPad with iOS <= 4.2 (so far)

Litiopixel para iPad

2010-12-16T13:57:00.000+01:00

Bien, de momento creo que ya he realizado las pruebas que quería; comprobar rendimiento y funciones en el iPad con GLBasic.

Voy a rediseñar algunas rutinas internas de pintado del mapa y de control touch, para que la aplicación pueda ser universal (iPod/iPhone y iPad compatible).

Esto retrasará el proyecto un poquito más; a posteriori recuperaré el tiempo invertido en la adaptación ya que con el mismo código fuente podré generar las versiones para las diferentes resoluciones de pantalla.

Diseño de tipografía LCD Matrix

2010-12-11T11:48:00.000+01:00

Inspirándome en los displays electrónicos, he decidido crear una tipografía de estilo Dot Matrix con el programa Graphics Gale.

Para que el resultado final sea satisfactorio, he tenido que retocar los espacios laterales para el kerning así como los "huecos blancos" para que los carácteres no se junten unos con otros.

El resultado no está nada mal, además me encaja en pixeles perfectamente con el fondo de la aplicación, que es lo que más me interesaba.

Multitarea en iOS 4.2.1 iPad

2010-12-10T01:30:00.000+01:00

Es imprescindible que la aplicación funcione en multitarea, las últimas versiones del sistema operativo iOS ya soportan esta funcionalidad. GLBasic "incluye" algunas funciones que sirven para este propósito.

- Autopause (true/false).

- Allowscape (true/false).

Aunque los nombres ya indican bastante, su explicación es muy sencilla. Autopause permite que la aplicación se ponga en pausa cuando pierde el foco (se pincha en otra ventana ó en el caso del iPad, se pulsa el botón home y sale de la aplicación).

Allowscape hay que activarlo como false, lo que no permite cerrar la aplicación y la deja a disposición de ser pausada.

Para gestionar los eventos de pérdida y recuperación de foco tenemos las siguientes subfunciones predefinidas: GLB_ON_QUIT cuando la aplicación pasa a estar pausada y GLB_ON_RESUME para tomar el control cuando vuelve a GLB.

Funcionamiento perfecto y sin problemas. ;-)

Test actualización BlogPress

2010-12-09T11:24:00.009+01:00

Hace un tiempo adquirí la aplicación BlogPress para blogging en dispositivos con iOS. En principio parece que sirve para mis propósitos, aunque no me acaba de convencer cómo gestiona el asunto de subir fotos al blog... y sobretodo la forma que emplea para enlazar las mismas.

Subiendo imagen de prueba... Veremos si luego no me tocará editar el HTML del post.

...

Nota: Pues sí, he tenido que retocar manualmente el código web desde el iPad. :-(

Actualizando GLBasic (8.148 -> 8.174)

2010-12-02T11:40:00.000+01:00

Mientras espero la actualización que permitirá "tocar" algunos de los "objetos" que pertenecen al GUI de iOS, se presenta esta versión que incluye los siguientes cambios:

(fichero log_e.gbas)
// 8.174
// Core:
// Variable font spacing-space character is small as 'j'
//
// iOS:
// - (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url
// -> url will be what you get with GETCOMMANDLINE$()
//
// Compiler:
// Coexistance with MinGW is possible now.
//
// Editor:
// Ctrl+C works in the output window.