Gorilla 3D Framework

Me gustaria presentaros SantaWorkshop, un juego para Android que podeis encontrar en la Google Play Store desarrollado con Delphi Firemonkey.


Para este proyecto se ha utilizado en engine de Manaz Software, Gorilla3D framework para Delphi Firemonkey. Actualmente esta framework está en versión Alpha y soportará Berlin y Tokyo. La versión gratuita incrustará una marca de agua en las imagenes y la versión de pago tendrá un precio fijo. Actualmente está información no está aún disponible en la web oficial.

Estas són algunas de las características del framekork:
  • Skin-, Skeleton- und Vertexanimations for 3D Meshes (Key-Animations)
  • Integrated and fast Q3 Physics Engine (with collision detection)
  • Materials: textures, bump-mapping, vertex-color, phong-, blinn-, lambert-materials, water and reflection
  • Loading complex multi-mesh models with UV-textures
  • Logical model management (independent from FireMonkey tree), to manage a large amount of meshes and to instanciate separatly
  • Optimized mesh generation in multi-mesh models: number of vertices reduced to the necessary vertices
  • Flexible particle-system with influencer-classes (up to 100K particle at runtime)
  • Shadow-Volume rendering
  • Skybox-support
  • Terrain rendering: from height-maps and procedural algorithms (Diamond-Square, Perlin-Noise, ...)
  • New Point3D-, Quaternion-, Transformationsmatrix- und VertexKey-Animationen
  • AudioManager (threadsafe)
  • Flexible dialogue-system: load, save and edit at runtime
  • Fast 3D model loading
  • Less codesize for fast compilation (~50.000 lines of code)
  • Compatible with existing FireMonkey components
  • Platform-independent: WIN32, WIN64, ANDROID, iOS, MACOS, LINUX-x86 (by third-party product usage)
  • Formate: X3D, X3DZ, OBJ, DAE

Os tendremos informados cuando tenagamos más novedades del proyecto.


Simon, color vs. color (5)

En esta entrada del tutorial de programación usaremos el componente de cambio idioma que incorpora Delphi para hacer que nuestro juego sea multi idioma.


Empezaremos el tutorial terminando el sistema de notificación al usuario añadiendo los TGlyph de control y añadiremos el componente TLang para el sistema multi idioma del juego. A través del tutorial aprenderás como utilizarlo y tal como expliqué en una entrada anterior del blog, utilizando la función:

 function TGameForm.sTextManualF(sOrg: string): string;  

Acceder a los campos definidos en el TLang en tiempo de ejecución para que al incio del juego o cuando se acceda a la configuración el usuario pueda cambiar de idioma y dinámicamente la interfaz cambie.

Temas tratados en el tutorial:
  • Uso de TImageList
  • Uso de TLang
  • Uso dinámico del sistema multi idioma

Simon, color vs. color (4)

En esta entrada terminaremos la configuración de la aplicación para Android, así como definiremos funciones dinámicas para la caja de notificación visual para mostrar mensajes a los usuarios.



Para ser concretos, en este proceso, primero terminaré de configurar las opciones visuales de la aplicación, los iconos y la imagen de splah. Así mismo es necesario controlar el tipo de pantalla que se utiliza para ejecutar la aplicación. Todos sabemos que no es lo mismo ejecutar un juego en una tablet, en una phablet o en un pequeño smartphone. Cada tipo de dispositivo necesita una interfaz de usuario diferente, así como tamaños de fuente diferentes, etc.

Otro de los punto significativos en un juego son las ventanas de notificación. Los juegos a diferencia de otro tipo de aplicaciones tienen cajas propias, con más o menos diseño, para notificar informaciones al usuario. El problema recae en tener que diseñar el numero de cuadros para cada tipo de notificación. La mejor solución consiste en hacer tipos genéricos de cuadros y dinámicamente asignar la función que queremos que se ejecute al pulsar cada botón.

Temas tratados en el tutorial:

  • Configuración visual de Aplicaciones móviles
  • Ajuste de pantalla en función del dispositivo
  • Cuadros con funciones dinámicas para notificaciones al usuario
  • Uso intensivo de TGridPanelLayout
  • Propiedad HitTest
  • Propiedades de los TRectangle

BGM for free Shooting game

Desde Embarcadero Japón tenemos un ejemplo muy interesante de un juego sencillo pero interesante a nivel de programación desarrollado por Haruyuki Mohri. Básicamente es un shooter sobre móviles como ejemplo del uso de las liberias TBitmapAnimation y TFloatAnimation.



Artículo original:

Simon, color vs. color (3)

En esta sesión introduciremos las primeras funciones de control en la App, así como los primeros elementos gráficos.


Antes de empezar con el desarrollo de un videojuego para móviles, si se va a utilizar Internet, como es este caso, para acceder a bases de datos en la nube es necesario saber en algunos puntos del juego si disponemos de dicha conexión.

Así mismo deseamos saber que tipo de dispositivo utiliza el usuario del juego, ya que en el momento de definir la interfaz de usuario es importantes, al menos, en diferenciar lo que es una tableta o un teléfono inteligente. En este ejemplo muestro esta diferenciación, pero ustedes pueden ajustar estas variables según sus necesidades.

Una vez preparada las rutinas iniciales, mostraré como implementar la primera pantalla. Esta pantalla es la pantalla de carga. Muchas veces el tiempo de carga puede variar mucho dependiendo del tipo de dispositivo y funciones que se necesiten ejecutar al inicio de la aplicación, con lo cual, una pantalla inicial, además de mostrar información, si lo consideramos relevante (cargando, accediendo a la base de datos, etc.), ayuda a minimizar el tiempo de espera del usuario.

Temas tratados en el tutorial:
  • Acceso al la versión de la aplicación
  • Comprobación del acceso a Internet
  • Comprobación de las medidas de la pantalla (FMX FlyFilesUtils)
  • Uso de TListImage

Simon, color vs. color (2)

Presento la primera serie que publico sobre la creación de videojuegos con Delphi Firemonkey. En esta serie explicaré paso a paso como crear juegos usando esta gran herramienta de desarrollo. Hasta ahora he hablado sobre la concepción del juego y la fase de diseño.


En esta entrada presento el primer vídeo tutorial. En este vídeo explico la fase inicial del proyecto, la estructura de ficheros, la configuración del proyecto y los primeros pasos en la creación del juego. Espero que les guste.

Simon, color vs. color (1)

Cuando diseñé Simon, color vs. color, intenté aplicar las nociones de diseño que conozco. Seguramente el mayor error cometido es un exceso de complejidad en un juego diseñado para móviles. Así que en un ejercicio de autocrítica he rediseñado el juego y os presento un nuevo diseño a modo de ejemplo.

En un primer diseño, el juego tenia etapas, nieveles, 4 modos de juego, multijugador, etc. Seguramente este ejemplo de complejidad no es correcto para un juego de puzzle casual, para jugar un partida en cualquier lugar.

En un nuevo diseño he simplificado el modelo de juego a un solo modo de juego y un sistema muy simplificado. Además he potenciado el modelo de recompensas y de competitividad entre jugadores.



El menú general de la aplicación también es necesario simplificarlo para hacer mucho más accesible llegar al modo de juego.


Por lo que hace referencia al modo de juego también hacía falta simplificarlo ya que tanto el modo multijugador no se usaba a la práctica, como en los 4 modos de juego que algunas veces confundía al jugador.


En el nuevo diseño el menú principal da fuerza a la opción de jugar, dejando como elementos secundarios todas las otras opciones. Además se ha potenciado los elementos de recompensa como un ranking entro todos los jugadores para saber tu posición mundial, así como retos locales a corto plazo para retar al jugador a seguir mejorándose a si mismo.



Diseñando videojuegos

El error mas comun en el mundo de la programación de un videojuego es olvidar o no dar la importancia que realmente tiene el aprtado de diseño. Es comocido por todos los diseñadores de juegos que no se debe empezar a programar sin antes tener claro el diseño del mismo.

Yo personallmente perfiero el diseño analógico (lapiz y libreta) para hacer mis diseños. En el mundo del diseño de juegos hay mucha literatura al respecto, pero el concepto básico en todo juego és el deseo y la diversión. Una vez realizado el diseño deberiamos poder contestarnos a estas cinco preguntas:
  1. ¿Es divertido?
  2. ¿Es desafiante?
  3. ¿No es frustrante?
  4. ¿Hay recompensa?
  5. ¿Ofrece una experiencia nueva cada vez que se juega?
Según Durgan A. Nallar en su obra Diseño de videojuegos en América latina, expone los mecanismos básicos del placer lúdico en el ser humano como:
  1. Aceptación (ser aprobado)
  2. Curiosidad (aprender)
  3. Apetito (alimentos)
  4. Familia (tener descendencia)
  5. Honor (valores de clan o grupos)
  6. Idealismo (justicia social)
  7. Independencia (individualidad)
  8. Orden (organización, estabilidad y predicción)
  9. Actividad física
  10. Poder (influencia)
  11. Romance (sexo)
  12. Ahorro (recoger y acumular)
  13. Contacto social (amigos y relaciones)
  14. Estatus (sentirse importante)
  15. Tranquilidad (seguridad)
  16. Venganza (contraatacar y ganar)
En resumen podriamos decir que un buen juego debe satisfacer algunos de los deseos huamnos para obtener un binestar psíquico y con ello la felicidad en el juego y la diversión.

Un juego divertido que satisfaga estos deseos produce un placer que se convierteen un habito. La repetición de incentivos produce que este habito se convierta en fidelización.

¿Qué es divertido? ¿Que ingredientes debe tener un juego para que sea divertido?
  • Ganar
  • Resolver problemas
  • Explorar
  • Trabajo en equipo
  • Reconocimiento
  • Coleccionismo
  • Sorpresa
  • Imaginación
  • Compartir
  • Jugar a rol
  • Personalización
  • Perder el tiempo

Sin querer entrar en mas detalles, tened en cuenta estas ideeas cuando diseñeis vuestros juegos. Es un poco atrevido por mi parte cerrar el apartado de diseño aquí, ya que este tema importante que da para llenar centenares de páginas. Pero como este bloc está mas orientado a la programacón no me extenderé más. Os recomiendo que amplieis la información si realmente os gusta el mundo del diseño de videojuegos... es realmente apasionante.

Recursos

Uno de entre los principales problemas para los estudios pequeños, es que entre muy pocas personas hay que hacer un trabajo enorme donde muchas disciplinas distintas están involucradas. Es muy difícil ser un buen diseñador, programador, artista y músico a la vez para desarrollar un producto con un calidad suficiente si queremos comercializar el producto.

Para ello es importante tener un banco de recursos para poder utilizar si realmente tu fuerte es la programación y no tienes tiempo o infraestructura suficiente para invertir horas y mas horas en la parte artística del desarrollo de un juego.  

Yo recomiendo centrar el esfuerzo en la parte de diseño y la programación y utilizar bancos de recursos para los primeros proyectos mientras el equipo de trabajo sea pequeño. Un buen juego es como una película de cine; si el guión es sólido y los actores y actrices buenos el director tiene la mitad del trabajo hecho, pero si el guión es malo, lo mas probable será que el producto final no este a la altura de nuestras expectativas.

Gráficos
  • FreePik - Recursos gratuitos con atribución al autor, o por una cuota mensual, libremente sin mención.
  • Iconmonstr - Iconos gráficos libres sin necesidad de atribución del autor.
  • Icon Archive - Banco de iconos libres,

Música
  • ChipTone - Generador de efectos sonoros gratuitos y libres de distribución.
  • Bigsoundbank - banco de sonidos 100% gratuitos.
  • SoundBible - Banco de sonidos con diferentes tipos de distribución.



Delphi Boot Camp Day 4 - Game Development with Delphi


Para aquellos que os iniciéis, en el las sesiones del Boot Camp 2016, Embarcadero hizo una sesión especifica para el desarrollo de juegos utilizando Delphi. En esta sesión se mostraban 4 ejemplos de juegos desarrollados con Delphi donde a partir del mismo código funcionaban con Windows, Android y iOS.

El evento dirigido por Eli M. de FMXExpress.com da algunas pistas interesantes sobre los principios básicos de cualquier juego y es una excelente trampolín para todos aquellos que queráis hacer algun juego multiplataforma con la misma base de código utilizando Delphi.

Agenda
  • Game loop
  • Using TRectangle
  • Frames UI
  • Motion Sensor
  • High Scores via SQLite & LiveBindings
  • Object Pooling
  • Sprite Sheet Animation
  • App Tethering
  • Cross Platform Sound

Yo personalmente encontré muy interesante la solución que aporta a partir de Frames, el sistema de sonido multiplataforma y la gestión de Sprites con los Sprite Sheet Animations.



El código fuente de los ejemplos lo podéis encontrar aquí. (http://embt.co/DelphiGames2016)

Simon, color vs. color (0)

Después de un tiempo de inactividad debido a problemas médicos, retomo el Bloc que empecé con ilusión hace unos meses.

Mi propuesta consiste en hacer un conjunto de entradas con un paso a paso en la creación de algunos juegos utilizando Delphi desde el diseño inicial hasta la publicación y monetarización de la App a través de Google AdMob o otras plataformas.

Mi primera propuesta será una re edición de mi proyecto Simon, color vs color a partir del análisis de la aplicación, su re-diseño y la programación paso a paso de la nueva versión. Espero que les guste.

Simon, color vs color, es un juego basado en el clasico SIMON de Ralph Baer y Howard J. Morrison en 1978.  El juego es básicamente un juego de memoria. Simon enciende uno de los pads de colores y suena un tono, luego dos, luego tres, etc. Los jugadores intentan hacer coincidir a Simon presionando los pads en la secuencia correcta. Si alguien falla, obtienen una sonido de error y están fuera del juego. Por supuesto, Simon acelera a medida que avanza el juego, por lo que cada vez es más difícil.


Presentación al Cool Apps Contest

Esta mañana me he decidido a presentarme al Cool Apps Contest que Embarcadero ha promocionado estos días. Creo que es una buena plataforma para que la gente descubra las posibilidades que tiene RAD Studio como herramienta para la creación de aplicaciones móviles. Lamentablemente sólo se puede presentar una aplicación por desarrollador, así que he presentado Simon, color vs. color ya que creo que es la más interesante de todas. Espero que les gusten los vídeos.

Numbers Swap



Simon, color vs. color

Multilenguaje

Si queremos llegar al máximo número de usuarios en nuestros juegos es importante tener en cuenta de dominar el sistema de multilenguaje. Delphi dispone en las últimas versiones de un sistema de multilenguaje que nos puede resultar muy útil.



Los componentes TLabel, TButton, etc. disponen de una propiedad llamada Autotranslate que si esta activada podemos a través del componente Lang incorporar varios idiomas a la propiedad Text del los componentes.

Yo personalmente prefiero no utilizar la propiedad Autotranslate y tener un procedimiento que traduzca al idioma que el jugador haya seleccionado. Para ello utilizo una función como esta para asignar los Text de todos los controles del juego. Si sitúas esta función en el inicio del juego o cunado el jugador cambia de idioma tendrás un sistema multilenguaje muy funcional.


 function TForm1.sTextManualF(sOrg: string): string;  
 // translate a text, which is not in the automate translation process of TFmxObjects  
 begin  
  // first check, if the selected language has a mapping  
  if Lang1.Resources.IndexOf(Lang1.Lang)>=0 then begin  
   // get the resource stringlist of the current language and get the translation  
   result := Lang1.LangStr[Lang1.Lang].Values[sOrg];  
   if result='' then begin  
    // text not found in mapping - keep original text  
    result := sOrg;  
   end;  
  end  
  else begin  
   // language not found: must be the default language  
   result := sOrg;  
  end;  
 end;  


Función al inicio del programa para suministrar la traducción a todos los controles visuales:

 Procedure TForm1.FormCreate(Sender: TObject);  
 begin  
  TranslateText;  
 end;  
 Procedure TForm1.TranslateText;  
 begin  
   //Main  
   Text1.Text:= sTextManualF('sOpen');  
 end;  


El control Lang1 permite crear cadenas en múltiples idiomas.

Librerias de apoyo (App Version)

Otra herramienta útil para gestionar una aplicación móvil es conocer la versión de la aplicación. En cada entorno de desarrollo necesitamos funciones diferentes para conocer la versión en ejecución. El control de versiones es importante ya que una vez publicado un juego o aplicación todos los archivos adjuntos a la aplicación no se actualizarán.



Imaginemos que nuestra app utiliza un fichero de BBDD *.db que necesitamos actualizar al publicar una nueva versión en la tienda. Cuando los usuarios actualicen la app, no sabremos desde que versión están actualizando. Además los nuevos ficheros que de distribuyen con el fichero APK serán actualizados, pero aquellos que ya existían no serán actualizados. Tener un control de la versión de la app nos permitirá controlar los cambios y actualizar los ficheros manualmente que sean necesarios.


Para la gestión de versiones yo uso estas rutinas:

 unit AppVersion;  
 interface  
 {$IF DEFINED(iOS)}  
  uses Macapi.CoreFoundation;  
 {$ENDIF}  
 {$IF DEFINED(ANDROID)}  
  uses  
   Androidapi.JNI.JavaTypes,  
   FMX.Helpers.Android,  
   Androidapi.JNI.GraphicsContentViewText,  
   Androidapi.Helpers;  
 {$ENDIF}  
 {$IF DEFINED(MSWINDOWS)}  
  uses  
   SysUtils;  
 {$ENDIF}  
 function GetAppVersionStr: string;  
 implementation  
 {$IF DEFINED(MSWINDOWS)}  
 function GetAppVersionStr: string;  
 var  
  Rec: LongRec;  
 begin  
  Rec := LongRec(GetFileVersion(ParamStr(0)));  
  Result := Format('%d.%d', [Rec.Hi, Rec.Lo])  
 end;  
 {$ENDIF}  
 {$IF DEFINED(ANDROID)}  
 function GetAppVersionStr: string;  
 var  
  PackageManager: JPackageManager;  
  PackageInfo : JPackageInfo;  
 begin  
  PackageManager := SharedActivity.getPackageManager;  
  PackageInfo := PackageManager.getPackageInfo(SharedActivityContext.getPackageName(), TJPackageManager.JavaClass.GET_ACTIVITIES);  
  Result:= JStringToString(PackageInfo.versionName);  
 end;  
 {$ENDIF}  
 {$IF DEFINED(iOS)}  
 function GetAppVersionStr: string;  
 var  
  CFStr: CFStringRef;  
  Range: CFRange;  
 begin  
  CFStr := CFBundleGetValueForInfoDictionaryKey(  
   CFBundleGetMainBundle, kCFBundleVersionKey);  
  Range.location := 0;  
  Range.length := CFStringGetLength(CFStr);  
  SetLength(Result, Range.length);  
  CFStringGetCharacters(CFStr, Range, PChar(Result));  
 end;  
 {$ENDIF}  
 end.  

Librerias de apoyo (FlyFilesUtils)

Cuando te enfrentas a un proyecto profesional y tu equipo de trabajo no es extenso, necesitas herramientas de apoyo para poder hacer la vida un poco más fácil. En este post os quería presentar unas librerías muy prácticas cunado desarrollas juegos en Delphi o aplicaciones móviles en general.





La primera de ellas es FlyFilesUtils. Este proyecto opensource presenta algunas herramientas muy útiles para el desarrollo móvil.


Para el desarrollo de juegos y aplicaciones móviles en general podemos usar las rutinas de información de dispositivos ya que nos permitirá en tiempo de ejecución conocer qué tipo de dispositivo está corriendo nuestra aplicación.


 // Funciones  
 function GetScreenPixelsXY(const Context: TFmxObject = nil): TPoint;  
 function GetScreenClientPixelsXY(const Context: TFmxObject = nil): TPoint;  
 function GetScreenInchXY(const Context: TFmxObject = nil): TPointF;  
 function GetScreenDPIXY(const Context: TFmxObject = nil): TPointF;  
 function GetScreenDPI(const Context: TFmxObject = nil): Single;  
 function GetScreenInches(const Context: TFmxObject = nil): Single;  
 function GetFormXY(const AForm: TCustomForm): TPointF;  
 function GetFormClientXY(const AForm: TCustomForm): TPointF;  
 function GetFormClient(const AForm: TCustomForm): TRectF;  
 function GetFormPixelsXY(const AForm: TCustomForm): TPointF;  
 function GetFormClientPixelsXY(const AForm: TCustomForm): TPointF;  


A partir de etas funciones podemos calcular que tipo de pantalla se está ejecutando nuestra aplicación y ajustar la GUI al dispositivo. A partir de una función rudimentaria podemos conocer si la aplicación se ejecuta en una Tablet o un Smartphone.

  {$IF DEFINED(iOS) or DEFINED(ANDROID)}  
  if FlyFilesUtils.GetScreenInches>=6.5 then  
  begin  
   Tablet:= True;  
  end;  
  {$ENDIF}  



Además está librería tiene otras funciones relacionadas con acceso a ficheros en dispositivos móviles, así como funciones de conversión que nos pueden resultar útiles más adelante.

Energy Up: Cuando el pasado encuentra el futuro

Una vez me dijeron que la inspiración llega cuando menos te lo esperas. Después de terminar mi ultimo proyecto  Simón, color vs. color , qu...