lobo_tuerto » game development

lotu — Un framework para desarrollo de juegos en Ruby

lobo_tuerto — Sat, 06 Mar 2010 03:25:40 +0000

Pues aquí estoy con un nuevo proyecto.

Un framework para desarrollar juegos en Ruby.

Los antecedentes

Después de terminar mi clon de Tetris llamado rubytris, decidí darme a la tarea de implementar otro clon de los juegos de antaño —¡y uno de mis favoritos!: Missile Command.

Debo comentar que a medio camino se me ocurrió utilizar comportamientos de direccíón (steering behaviors) para modelar el movimiento de los misiles —y algunos otras entidades— para una experiencia más envolvente.

Así, le puse pausa al Missile Command y comencé a desarrollar otro proyecto llamado ruby_steering_behaviors que cuenta ya con los comportamientos necesarios para utilizarlo en mi juego nuevo).

Durante la implementación de esos dos proyectos comencé a desarrollar abstracciones y clases útiles que no tenía en rubytris (mi primer juego):

Estados de juego
Auxiliado por una máquina de estados es mucho más sencillo implementar las diversas pantallas de juego, entradas (splash screens) y menús.
Manejador de recursos
Para un fácil acceso a las imágenes, fuentes y sonidos.
Manejador de eventos
Un sistema de disparo y captación de eventos.
Funciones auxiliares
Para facilitar el despliegue de texto, imágenes, sonidos.
Clases útiles
Un contador de cuadros por segundo (FPS counter).
Un visor (viewport) para poder tener espacios virtuales de tamaños arbitrarios, con acercamientos, alejamientos y control de entrada.

Desgraciadamente el trabajo y otras actividades de mi vida cotidiana me absorbieron demasiado y dejé ambos proyectos abandonados por un rato.

Pero, ahora que logré hacerme de un tiempecito decidí retomarlos y me pregunté:
¿por qué no desarrollar un framework que incluya todo eso (más lo que salga)? ¿podría ser provechoso para alguien más? Creo que sí.

Y así nació lotu.

lotu

lotu es un framework naciente que está basado en gosu, una biblioteca para creación de juegos en 2D.

Siendo gosu una biblioteca, te provee únicamente con las funciones básicas para crear un juego y nada más.

lotu, por otro lado se encargará de hacer el proceso de creación de juegos simple e intuitivo. gosu provee las herramientas y lotu los medios. gosu da el con qué y lotu provee el cómo.

Sin un marco de trabajo (framework), eres totalmente libre de organizar tu código de la forma que más te plazca, pero corres el riesgo de caer en el caos completo.

Un framework impone ciertas convenciones, te enseña un estilo de trabajo. Si las convenciones ayudan a desarrollar de una manera más rápida y menos compleja tu proyecto, entonces podemos decir que el framework es exitoso.

Como experimento he decidido desarrollar a la par mi juego nuevo y lotu. Espero que de esta manera ambos se retroalimenten y así obtener un mejor resultado.

lotu gem

Nunca antes había hecho una gema en Ruby. Se me hacía un proceso esotérico y extraño (lotu es mi primera gema ¡que emoción!).

Pero jeweler realmente te la pone fácil, demasiado diría yo jeje. Si no me crees, checa este video:
Gemcutter & Jeweler

La gema la puedes instalar con:

1	sudo gem install lotu

Sin embargo si quieres ir al día con el desarrollo te aconsejo que lo cheques en github.

Otros frameworks

¿Por qué no usar un framework existente como chingu?

La razón principal es aprendizaje.

¡Es hora de programar!

Programando un PBBG en Ruby & Rails

lobo_tuerto — Tue, 17 Nov 2009 19:16:27 +0000

Después de mi corto regreso a la programación de videojuegos, y de haber visto por ahí y leído acerca de algunos PBBGs, finalmente he decido darme a la tarea de desarrollar uno.

PBBGs

Seguramente se preguntarán ¿qué es y cómo se juega un PBBG?

PBBG == Persistent Browser Based Game
Eso básicamente quiere decir: juego persistente para navegador.

La infraestructura y herramientas necesarias para desarrollar videojuegos en el ámbito del desarrollo web no son ni remotamente cercanas a las que existen para el desarrollo de escritorio.

Así, esto se convierte básicamente en un arte, hay que diseñar y desarrollar un videojuego alrededor de una estructura de operación ya establecida como lo es el protocolo HTTP, el modelo cliente-servidor y los tiempos de respuesta acostumbrados de una página web.

Por esta razón, la gran mayoría de los PBBGs se inclinan por uno de estos dos géneros:

Juegos de rol
Juegos de estrategia

O alguna mezcla rara entre ellos.

El modelo de participación preferido y más fácil de implementar es por turnos, aunque algunos de los PBBGs más modernos están incorporando un modelo de participación en tiempo real.

Si no conoces aún algún PBBG, aquí te dejo unos enlaces para que te des una idea de cómo son y cómo se juegan:

Los juegos de estrategia tradicionalmente se dividen en: por turno (TBS) [turn based strategy] y en tiempo real (RTS) [real time strategy]. En los PBBG he visto mucho el uso de tiempo instantáneo (ITS) [instant time strategy].

Instant Time Strategy (ITS)

Por lo que he visto la estrategia en tiempo instantáneo es muy popular entre los desarrolladores de PBBGs.

Modelan combates enteros con ecuaciones y obtienen de manera inmediata el resultado de las peleas.

Aunque adecuado a la situación, este nivel de abstracción se me antoja demasiado alto para mi proyecto. Me llama la atención el implementar algo más cercano al tiempo real (o una mezcla de tiempo real y turnos).

Ahora con tecnologías como Ajax, lenguajes como Ruby y frameworks como Rails, no es tan complicado hacer un PBBG.

Ya que andamos hablando de tecnologías, les presento mi stack de desarrollo.

Mi development stack

Aquí pongo la lista de las herramientas que estoy utilizando para llevar a cabo este proyecto:

Linux (nada mejor para el desarrollo en general)
PostgreSQL (una robusta base de datos)
Ruby (sigo enamorado de este lenguaje)
Rails (web development framework)
jQuery (javascript framework)
Formtastic (excelente para lidiar con formas)
Authlogic (para implementar la autenticación de usuarios)
Haml (lenguaje para escribir las vistas HTML de la aplicación)
Sass (lenguaje para escribir el CSS de la aplicación)
Compass (framework CSS para hacer el layout de la aplicación)
git (version control system)
emacs (editor de código)

Tengo grandes planes para este PBBG: misiones, peleas entre clanes, clases variadas, habilidades especiales, mercado, subastas y una vibrante comunidad a su alrededor.

Pero como todo: debe empezar por algún lado.

Modelando los combates

Veamos un elemento que considero fundamental para este PBBG: El sistema de batallas.

En mi caso particular, si algo deseo ver funcionando primero son los combates.

Había comentado antes que quiero mis batallas en tiempo real (o algo que se le acerque). El tiempo real que puedes conseguir en una aplicación web no es el común de 60 fps de los videojuegos tradicionales.

Aquí tienes que pensar en término de peticiones por segundo a tu servidor web. GET, POST, params, sesiones, etc.

A continuación pongo una lista con algunas de las características que me gustaría ver en el sistema de batallas:

Representar y llevar a cabo un combate entre varios participantes

Duelos entre jugadores
Duelos entre NPC y jugadores
Duelos entre grupos de jugadores

Durante el combate los personajes podrán hacer uso de habilidades especiales, objetos y armas

Un guerrero puede dar un golpe especial con su arma
Un brujo puede hacer uso de alguna magia
Un guerrero puede hacer uso de una poción para curarse

En la pelea, los jugadores podrán seleccionar un objetivo para atacar

Un guerrero puede seleccionar al enemigo de su preferencia para recibir sus ataques

En el próximo artículo pondré algo de código del sistema de batallas, las decisiones de diseño que se tomaron y una breve explicación de cómo funciona.

Suena bien para comenzar, ¿no?

Ruby steering behaviors

lobo_tuerto — Mon, 10 Aug 2009 14:39:23 +0000

O, como dirían en español:
Comportamientos de dirección en Ruby.

Estos sirven para crear agentes autónomos que navegan un ambiente. Un agente armado con estos comportamientos puede ir tras otro, huir de él, esconderse, ser parte de una formación, etc.

Unos de los más interesantes de observar son los comportamientos en manada (flocking behaviors), pero sobre eso ya vendrá otro artículo.

En este fin de semana programé estos cuatro:

Seek (búsqueda)
Flee (huir)
Arrive (llegar)
Pursuit (persecusión)

Espero poder incluir los demás pronto, aunque creo que refactorizaré un poco antes de implementar más cosas.

Estoy planeando usarlos en mi siguiente juego, que como les había comentado es un clon del Missile Commander (ese donde tenías que derribar los misiles enemigos con los propios antes de que tocaran el suelo y destruyeran tu base).

El código

No está comentado por el momento y seguramente se puede mejorar en muchas partes, ya lo iré limpiando y ajustando en las próximas semanas.

Entre las cosas que contiene hay una clase llamada Viewport que creé para poder jugar con mis agentes en un espacio más grande sin que el tamaño de la pantalla fuera una limitante. Velo como un sandbox que puedes configurar con un tamaño arbitrario.

Por ejemplo, puedes tener un espacio virtual de 4000×3000 pixeles dentro de un viewport que mide 800×600 pixeles (reales) dentro de tu pantalla configurada a 1024×768.

Además se comporta como un toroide, es decir, los agentes pasan de un lado al otro, no pueden salirse de él.

Esto lo implementé porque estoy pensando mostrar cada comportamiento en un viewport diferente, pero todos en la misma pantalla.
Creo que también se podría usar para implementar un mini mapa, ¿no?

El demo

Hay tres agentes de diferentes colores en el demo.

Usa tu ratón. Al dar clic en algún lugar de la pantalla se pondrá una marca verde y sucederán 3 cosas:

El agente verde huirá de ella.
El agente blanco llegará a ella.
El agente rojo perseguirá al blanco, prediciendo su posición futura, ésta se muestra como una marca blanca enfrente del agente blanco.

Presiona D para ocultar el texto informativo.
Presiona Esc para salir del demo.

Pueden bajar la aplicación demo de GitHub: ruby_steering_behaviors

Estoy usando como referencia el excelente libro: Programming AI by Example.

Implementación en C++

Para los que anden buscando una implementación en C++ existe OpenSteer.

OpenSteer is a C++ library to help build steering behaviors for autonomous characters in games and animation. OpenSteer provides an app which displays predefined demos of steering behaviors. You can prototype, visualize and debug your own as a plug-in.
License: MIT License

Rubytris en GitHub

lobo_tuerto — Mon, 03 Aug 2009 00:13:35 +0000

Sólo para informarles que mi proyecto ya tiene un hogar en GitHub

Rubytris (¡con nuevo nombre!)

Este fin de semana refactoricé un buen de código, aunque visualmente no cambió mucho, por dentro es básicamente otro.

Si usan git y lo quieren probar, solo deben hacer un:

1	git clone git://github.com/lobo-tuerto/rubytris.git

El siguiente fin de semana le volveré a meter mano, creo que es una buena idea terminar bien este proyecto antes de saltarme a otro.

Una manita de gato al clon de Tetris

lobo_tuerto — Sat, 01 Aug 2009 02:47:09 +0000

Al parecer el proyecto de los steering behaviors va para largo.

Por mientras, este fin de semana le daré una manita de gato a mi clon de Tetris, incluso le cambiaré el nombre y lo subiré a GitHub. Entre otras cosas quiero convertirlo en gema y separar el único archivo que contiene todas las clases en varios ficheros.

También traduciré los comentarios al inglés, y será el juego que mantendré de manera oficial.
El antiguo Metris se quedará en su artículo como un programa didáctico en español para quien lo quiera usar.

Comenzaré ahora mismo.

Actualización 2009-08-01 03:29am

La refactorización va viento en popa, también ya casi termino la traducción al inglés y la separación en varios archivos.

De paso modifiqué el algoritmo que obtenía los colores al azar de las piezas — ¡ya no más piezas oscuras que apenas se ven en el tablero ni piezas con colores desabridos!

¡Ah! y ya tengo el nuevo nombre… jojojo.

Optimizando operaciones sobre vectores en Ruby con memoization

lobo_tuerto — Thu, 30 Jul 2009 05:49:59 +0000

Ahora que estaba haciendo el clon del Missile Commander, me dieron ganas de implementar un movimiento más realista en los misiles.

En lugar de que simplemente tuvieran una velocidad lineal desde que salen hasta que explotan al llegar a su destino, quería que aceleraran a la hora de hacer su despegue.

Recordé que tengo un muy buen libro que habla sobre steering behaviors (comportamientos de dirección), y decidí implementarlos en Ruby.

Los steering behaviors usan mucha matemática de vectores, así que me puse a desarrollar una pequeña clase para realizar un par de cálculos comunes: longitud y normalización — conforme las necesite, le iré agregando otras operaciones útiles.

La clase Vector2d

Esta es la clasecita que me ayudará a darle vida a un sinnúmero de entidades virtuales en mis futuros proyectos.

require 'benchmark'
 
class Vector2d
  attr_reader :x, :y
 
  def initialize(x=0,y=0)
    clear_length
    @x = x
    @y = y
  end
 
  def clear_length
    @length = nil
    @length_sq = nil
  end
 
  def length
    Math.sqrt(length_sq)
  end
 
  def sub_memoized_length
    Math.sqrt(memoized_length_sq)
  end
 
  def memoized_length
    @length ||= Math.sqrt(length_sq)
  end
 
  def length_sq
    @x*@x + @y*@y
  end
 
  def memoized_length_sq
    @length_sq ||= @x*@x + @y*@y
  end
 
  def normalize
    Vector2d.new(@x/length, @y/length)
  end
 
  def normalize!
    @x = @x/length
    @y = @y/length
    clear_length
    self
  end
 
  def x=(x)
    clear_length
    @x = x
  end
 
  def y=(y)
    clear_length
    @y = y
  end
end
 
Benchmark.bm do |x|
  a = Vector2d.new(23,45)
 
  x.report do
    1.upto(1000000) do
      a.length
    end
  end
 
  x.report do
    1.upto(1000000) do
      a.sub_memoized_length
    end
  end
 
  x.report do
    1.upto(1000000) do
      a.memoized_length
    end
  end
end

Conforme la programaba se me ocurrió hacer unas optimizaciones, lo que dio como resultado los métodos que incluyen la palabra memoized en su nombre.

Hice unas benchmarks (pruebas de tiempo) —¡mi primer benchmark en Ruby! — para medir que tanto afectaban mis supuestas optimizaciones, y esto fue lo que descubrí:

-*- mode: compilation; default-directory: "~/development/gamedev/steering/" -*-
Compilation started at Wed Jul 29 23:52:19
 
/usr/bin/ruby -w /home/lobo/development/gamedev/steering/vehicle.rb 
      user     system      total        real
  1.460000   0.000000   1.460000 (  1.480273)
  1.310000   0.000000   1.310000 (  1.352205)
  0.270000   0.000000   0.270000 (  0.276391)
 
Compilation finished at Wed Jul 29 23:52:22

Una breve explicación

La prueba consistió en calcular la longitud de un vector determinado, un millón de veces.

La técnica de optimización usada se llama: Memoization.

En computación, memoization es una técnica de optimización que se usa principalmente para incrementar la velocidad de los programas de computadora al evitar que las llamadas repetidas a una función recalculen los resultados de entradas previamente procesadas.

El primer método medido:

1
2
3

  def length
    Math.sqrt(length_sq)
  end

Calcula calcula la raíz cuadrada cada vez que es llamado, además calcula la suma de los cuadrados de X y Y.
Tarda: 1.480273 segundos

El segundo método:

1
2
3

  def sub_memoized_length
    Math.sqrt(memoized_length_sq)
  end

Se ahorra el cálculo de los cuadrados de X y Y al guardar en una variable de instancia el cálculo realizado previamente.
Tarda: 1.352205 segundos

El tercer método:

1
2
3

  def memoized_length
    @length ||= Math.sqrt(length_sq)
  end

Se ahorra el cálculo de la raíz cuadrada mientras X y Y no cambien.
Tarda: 0.276391 segundos

¿Qué tal?

En los juegos es necesario hacer todas las optimizaciones posibles, ya que las operaciones se están realizando una y otra vez en cada ciclo del game loop.

Creo que estás me vendrán muy bien.

P.D. Estas pruebas fueron hechas con Ruby 1.9.

Mi próximo videojuego

lobo_tuerto — Fri, 17 Jul 2009 05:34:43 +0000

Que bien se siente cuando ves de manera palpable la evolución de un proyecto. Cuando éste pasa de un estado burdo a refinado. Por ejemplo compara las siguientes imágenes:

A mi me agrada, ¿y a tí?
Ahora me encuentro haciendo el clón de otro de mis juegos favoritos de antaño: Missile Command.

El código que estoy usando cómo base, también ha evolucionado mucho.

Ya no tengo un solo archivo con todo el código ahí. No tendría chiste repetir el modo de programar que utilicé en el Tetris. Ahora cuento con un manejador de pantallas, un menú de inicio y música. Todas las clases separadas en sus respectivos archivos.

He estado completamente metido en ello, esa es la razón por la que no he podido publicar tanto como quisiera en el blog.

Tengo dos buenas noticias: Una es que ya comencé a darle a la lógica del videojuego, la otra es que si hay gente interesada, puedo escribir un artículo detallando el diseño que empleé para el administrador de pantallas.

El administrador que hice es bastante versátil; te permite hacer splash screens —este proyecto incluye dos, una de Amenoské (los que hicieron la rola) y una mía (debo hacerme propaganda ¿no? ¿si no quién?)— de una manera muy sencilla e hilarlas con las otras pantallas del juego (menús y gameplay).

A lo mejor te preguntarás ¿y para que tanto diseño y archivos para un simple Missile Command?
La respuesta es sencilla: no sólo voy a hacer un Missile Command. Me estoy preparando para lo que viene. Aún estoy ante la disyuntiva de hacer un Pac-Man (jejeje) o un Gauntlet. ¿Qué opinas?

Cómo instalar Ruby/Gosu en Ubuntu 9.04 Jaunty Jackalope

lobo_tuerto — Tue, 14 Jul 2009 16:33:54 +0000

Gosu es un framework escrito en C++ para desarrollar juegos 2D. Cuenta con bindings para Ruby, y eso, es lo que nos interesa — tee-hee!
Además lo necesitas, si quieres probar el clón de Tetris que escribí.

Instalación de dependencias para Ruby 1.8

Para instalar la gema Gosu, necesitarás los siguientes paquetes:

g++
libgl1-mesa-dev
libpango1.0-dev
libboost-dev
libsdl-mixer1.2-dev
ruby
ruby1.8
ruby1.8-dev

Copia y pega el siguiente comando en tu terminal:

1	sudo apt-get install g++ libgl1-mesa-dev libpango1.0-dev libboost-dev ruby ruby1.8 ruby1.8-dev libsdl-mixer1.2-dev

Instalación de la gema

Ahora instala Gosu como gema con el comando:

1	sudo gem install gosu

Con los paquetes mencionados arriba ya instalados, la gema se compilará sin problemas.

Instalación de dependencias adicionales para el soporte de OpenGL en algunos ejemplos

En algunos ejemplos del framework Chingu requieren que la gema ruby-opengl esté disponible. Instálala tecleando esto en tu terminal:

1 2	sudo apt-get install libgl1-mesa-dri libglu1-mesa freeglut3 libgl1-mesa-dev libglu1-mesa-dev freeglut3-dev sudo gem install ruby-opengl

Soporte para Ruby 1.9

Para usar Gosu con Ruby 1.9, sólo reemplaza todas las ocurrencias de 1.8 por 1.9. El comando para instalar las dependencias, queda entonces como:

1	sudo apt-get install g++ libgl1-mesa-dev libpango1.0-dev libboost-dev ruby1.9 ruby1.9-dev libsdl-mixer1.2-dev

Después de eso, sudo gem install gosu debería funcionar sin problemas.

Recursos

Para usar la versión C++ de Gosu y/o instalarlo en otras plataformas, checa:
GettingStartedOnLinux
GettingStartedOnOsx
GettingStartedOnWindows

Metris — Mi clón de Tetris en Ruby y Gosu

lobo_tuerto — Mon, 13 Jul 2009 15:08:34 +0000

El proyecto ahora se llama rubytris y lo puedes encontrar en github:
http://github.com/lobo-tuerto/rubytris

¡Por fin terminé una versión presentable de mi clón de Tetris desarrollado en Ruby con ayuda del framework Gosu!

Le puse Me-tris, nombrado así, para no tener problemas con la ley (sí, se que el nombre apesta… jeje).

Es altamente configurable, puedes modificar cosas como el ancho y alto del tablero (en bloques), el tamaño de los bloques (en pixeles), el espaciado entre ellos, la velocidad de caída de las piezas (en milisegundos), la velocidad de repetición cuando un jugador deja presionada una tecla (para moverse a los lados, rotar, caer).

También puedes definir nuevas figuras fácilmente e indicar si tienen un pivote (un punto alrededor del cual giran las piezas). Ya no tienes que definir las piezas y cada una de sus rotaciones por separado, las figuras pueden tener un tamaño arbitrario.

El juego está (muy) básicamente completo. Lleva la puntuación del jugador y termina (tee-hee!).
Fue escrito en 3 días, 2 de ellos seguidos y uno más un par de días después.

El código está muy comentado, pero si te surge alguna duda, puedes preguntar con confianza. Tiene también, mucho campo para mejorarse (por ejemplo una pantalla de entrada).

Aquí les dejo unos screenshots que muestran como luce el juego al modificar los parámetros de configuración:

Descargar

Aquí tienen la descarga, es un archivo .rb y varios .ogg y .png.
Metris – Mi clon de tetris escrito en Ruby con Gosu (68.7KiB)

A continuación pongo el código en su totalidad.

Les recomiendo primero checar el RubyTutorial, ahí explican las cuestiones básicas de Gosu.

# -*- coding: utf-8 -*-
begin
  # En caso de que usemos Gosu via rubygems
  require 'rubygems'
rescue LoadError
  # En caso de que no...
end
require 'gosu'
 
 
# Esto lo utilizamos para darle un orden a los elementos gráficos del
# juego durante el dibujado en pantalla
module ZOrder
  # El tablero se dibuja primero, después las piezas, y por último la
  # interfaz de usuario (el texto, por ejemplo)
  Board, Pieces, UI = *0..2
end
 
 
# Constantes para configurar nuestro juego
module GameConstants
  # Textos
  module Text
    Caption = "Me-tris"
    Score = "Puntos"
    GameOver = "Juego finalizado"
    NextPiece = "Pieza siguiente"
    Info = "Presiona  para reiniciar o  para terminar"
  end
 
 
  # Gráficos
  module Graphics
    # Para los bloques
    Tile = "media/square.png"
    # Para el pivote
    Pivot = "media/circle.png"
  end
 
  #Sonidos
  module Sounds
    # Para desaparecer un renglón
    CompletedRow = "media/dialog-information.ogg"
    # Para cuando se deja caer una pieza
    StorePiece = "media/dialog-warning.ogg"
    # Para cuando termina el juego
    GameOver = "media/dialog-error.ogg"
    # Para cuando inicia el juego
    GameStart = "media/desktop-logout.ogg"
    # Para cuando no se pueda rotar o mover la pieza
    InvalidMove = "media/button-pressed.ogg"
  end
 
 
  # Configuración del juego
  # Jugar en pantalla completa?
  FullScreen = false
  # Ancho de la pantalla en pixeles
  ScreenWidth = 800
  # Alto de la pantalla en pixeles
  ScreenHeight = 600
  # Ancho del tablero (en bloques)
  BoardWidth = 12
  # Alto del tablero (en bloques)
  BoardHeight = 17
  # Longitud de los lados de un bloque (en pixeles)
  BlockSize = 25.0
  # Separación entre bloques (en pixeles)
  BlockSeparation = 5.0
  # Longitud de los lados de la imagen (en pixeles)
  ImageSize = 30 + BlockSeparation
  # Factor para ajustar tamaño del texto y la imagen de los bloques en
  # caso de que el tamaño de GameConstants::BlockSize no corresponda
  # con el de GameConstants::ImageSize
  Factor = BlockSize/ImageSize
 
  # Jugabilidad
  # Bajar la pieza cada X número de milisegundos
  DescendTime = 1000
  # Bajar la pieza rápido cada X número de milisegundos
  BoostedDescendTime = 25
  # Repetir el movimiento con la tecla presionada cada X número de
  # milisegundos
  RepeatTime = 200
end
 
 
# Clase para crear las diferentes figuras que puede tener una pieza en
# el juego
class ShapeFactory
  def self.shapes
    # Aquí definimos las figuras que queremos que aparezcan en el
    # juego, los 0s representan espacios en blanco, los 1s representan
    # bloques sólidos y el 2 es para indicar el pivote (opcional)
    [
     [
      [1,1],
      [1,1]
     ],
     [
      [1,1,2,1,1]
     ],
     [
      [1,1,1,2],
      [0,0,0,1]
     ],
     [
      [0,2,1],
      [1,1,0]
     ],
     [
      [0,1,0],
      [1,2,1]
     ],
     [
      [0,1,0],
      [1,1,1],
      [0,1,0]
     ],
     [
      [2,1,1],
      [1,1,0],
      [1,0,0]
     ],
     [
      [1,1,2],
      [0,1,1]
     ]
    ]
  end
 
  # Método para obtener una figura al azar
  def self.shape
    shapes[rand(shapes.size)]
  end
end
 
 
# Esta clase nos servirá para dar seguimiento al estado de una pieza
# (figura y posición)
class PieceState
  # Deseamos tener acceso a la posición (x,y) y figura (shape)
  attr_accessor :x, :y, :shape
 
  def initialize
    # Seleccionamos una pieza al azar de nuestro repertorio
    @shape = ShapeFactory.shape
    # Le metemos variedad a las piezas obteniendo la matriz
    # transpuesta con 50% de probabilidad de que quede como estaba
    # originalmente y 50% de que quede en espejo
    @shape = @shape.transpose if(rand(2) == 0)
  end
 
  # Método para obtener la anchura
  def w
    @shape.first.size
  end
 
  # Método para obtener la altura
  def h
    @shape.size
  end
end
 
 
# Esta clase representa una pieza en el tablero
class Piece
  # Necesitamos tener acceso al color de la pieza para que el tablero
  # pueda almacenar los bloques con el color correspondiente
  attr_reader :color
 
  def initialize(window, board)
    # Obtenemos una referencia a la ventana del juego uso interno
    @window = window
    # Obtenemos una referencia al tablero para uso interno
    @board = board
 
    # Creamos un color para los bloques sólidos de las piezas
    @color = Gosu::Color.new(0xff000000)
    @color.red = rand(255-20) + 20
    @color.green = rand(255-20) + 20
    @color.blue = rand(255-20) + 20
 
    # Tomamos el color anterior y creamos un uno semitransparente para
    # los representar los bloques vacíos de las piezas
    @colorb = Gosu::Color.new(@color.argb)
    @colorb.alpha = 0x66
 
    # Tendremos dos estados, el actual (válido) y uno tentativo (puede
    # quedar en estado inválido) que nos servirá para identificar si
    # un movimiento es válido, por ejemplo:
    # ¿Después de rotar tenemos una figura válida? ¿no colisiona con
    # nada? ¿no se sale de la pantalla?
    @current_state = PieceState.new
 
    # Al tener una pieza nueva, la centramos en el tablero y la
    # ponemos por encima de él (además de crear el estado tentativo)
    move_to_center
  end
 
  # Coloca la pieza al lado del tablero
  def move_to_side
    @current_state.x = @board.w + 2
    @current_state.y = 2
    @next_state = @current_state.dup
  end
 
  # Poner la pieza lista para comenzar a descender
  def move_to_center
    @current_state.x = (@board.w - @current_state.w)/2
    @current_state.y = -@current_state.h
    @next_state = @current_state.dup
  end
 
  # Método que nos genera un arreglo vacío con las dimensiones
  # del estado actual transpuestas, nos sirve a la hora de tratar de
  # hacer la rotación de una pieza
  def empty_rotated_shape
    Array.new(@current_state.w).map!{Array.new(@current_state.h, 0)}
  end
 
  # Posición en x (en bloques)
  def x
    @current_state.x
  end
 
  # Posición en y (en bloques)
  def y
    @current_state.y
  end
 
  # Altura (en bloques)
  def h
    @current_state.h
  end
 
  # Anchura (en bloques)
  def w
    @current_state.w
  end
 
  # Figura de la pieza
  def shape
    @current_state.shape
  end
 
  # Si al hacer una rotación o mover la pieza, queda en una posición
  # válida dentro del tablero, entonces llamamos a este método para
  # que la pieza realmente tome esa posición
  def to_next_state
    @current_state = @next_state.clone
  end
 
  # Si la pieza quedá en una posición no válida dentro del tablero,
  # entonces restauramos su estado
  def restore_state
    @next_state = @current_state.clone
    # Si este método es llamado es porque se trató de hacer algún
    # movimiento no válido, tocamos ese sonido
    @window.sounds[:invalid_move].play
  end
 
  # Método para operar con el estado siguiente
  def with_next_state
    yield @next_state
  end
 
  # Método para operar con ambos estados
  def with_states
    yield @current_state, @next_state
  end
 
  # Método para operar con cada una de las celdas de nuestra pieza
  def for_every_cell
    @current_state.shape.each_with_index do |row, i|
      row.each_with_index do |cell, j|
        yield(cell, i, j)
      end
    end
  end
 
  # Método que dibuja nuestra pieza en pantalla
  def draw
    # Recorremos cada celda de nuestra pieza y la ponemos en pantalla
    for_every_cell do |c,i,j|
 
      # Calculamos la posición de la pieza en la pantalla
      pos_x = @board.offset_x + (j+@current_state.x) * @board.b_size
      pos_y = @board.offset_y + (i+@current_state.y) * @board.b_size
 
      # El color depende de si es sólido o vacío
      @window.graphics[:square].
        draw(pos_x,
             pos_y,
             ZOrder::Pieces,
             GameConstants::Factor,
             GameConstants::Factor,
             c==0 ? @colorb : @color,
             :default)
 
      # Remarcamos el pivote (si existe)
      if c==2
        @window.graphics[:circle].
          draw(pos_x,
               pos_y,
               ZOrder::Pieces,
               GameConstants::Factor,
               GameConstants::Factor,
               @colorb,
               :additive)
      end
    end
  end
 
end
 
# Esta clase representa el tablero de juego
class Board
  # Necesitamos acceso a los atributos: altura, anchura, tamaño del
  # bloque, desplazamiento en x, desplazamiento en y, gráficas, si
  # está lleno el tablero
  attr_reader :h, :w, :b_size, :offset_x, :offset_y, :graphics, :full
 
  def initialize(window)
    # Obtenemos una referencia a ventana para uso interno
    @window = window
 
    # La altura del tablero (en bloques)
    @h = GameConstants::BoardHeight
    # La anchura del tablero (en bloques)
    @w = GameConstants::BoardWidth
    # El ancho/alto de los bloques (en pixeles)
    @b_size = GameConstants::BlockSize
 
    # Centramos el tablero en la ventana
    @offset_x = (window.w - self.pixel_w)/2
    @offset_y = (window.h - self.pixel_h)/2
 
    # Color para los espacios vacíos en el tablero
    @color = Gosu::Color.new(0xff222222)
 
    # Ponemos el tablero en su estado inicial
    reset
  end
 
  # Para inicializar el tablero
  def reset
    # La pieza que actualmente está descendiendo
    @current_piece = Piece.new(@window, self)
 
    # La pieza que sigue
    @next_piece = Piece.new(@window, self)
 
    # Movemos la pieza siguiente al lado del tablero para que la pueda
    # ver el jugador
    @next_piece.move_to_side
 
    # Generamos un arreglo de arreglos para representar nuestro
    # tablero
    @board = Array.new(@h).map!{Array.new(@w, 0)}
    # Lo mismo para representar el color de los bloques en el tablero
    @board_colors = Array.new(@h).map!{Array.new(@w,0)}
 
    # Nos servirá para saber si el juego ha terminado
    @full = false
 
    # Ponemos la puntuación del jugador en cero
    @score = 0
 
    # Tocamos un sonido al iniciar el juego
    @window.sounds[:game_start].play
  end
 
 
  # Sirve para revisar si el estado tentativo es válido y si el
  # tablero lo puede "tomar"
  def can_take_it?
    # Vamos a trabajar con el estado siguiente para validarlo
    @current_piece.with_next_state do |n|
      n.shape.each_with_index do |row, i|
        row.each_with_index do |cell, j|
          # Nos aseguramos de trabajar con los renglones de la pieza
          # que están dentro del tablero
          if n.y + i >= 0
            # Checamos si hay colisión
            if @board[i+n.y][j+n.x] != 0 && n.shape[i][j] != 0
              # Si hayamos una colisión regresamos falso para avisar
              # que el tablero no puede "tomar" la piezao
              return false
            end
          end
        end
      end
    end
 
    # Si no hay colisión entonces devolvemos verdadero, con esto
    # informamos que el tablero si puede "tomar" la pieza
    true
  end
 
  # Almacena los bloques de la pieza que ha llegado al fondo del
  # tablero
  def store_piece
    @current_piece.shape.each_with_index do |row, i|
      row.each_with_index do |cell, j|
        # Solo copia los bloques llenos (diferentes a cero)
        @board[i+@current_piece.y][j+@current_piece.x] = cell if cell != 0
        # Copiamos los colores de la pieza al tablero de colores
        @board_colors[i+@current_piece.y][j+@current_piece.x] = @current_piece.color if cell != 0
      end
    end
    # Tocamos un sonido cuando una pieza baja
    @window.sounds[:store_piece].play
  end
 
  # Método que elimina los renglones llenos
  def compact_board
    # Necesitamos saber que renglones vamos a eliminar
    to_delete = []
 
    # Vamos a revisar renglón por renglón
    @board.each_with_index do |row,i|
      # Sólo si el renglón NO incluye algún cero...
      unless row.include?(0)
        # Registramos si este renglón necesita ser eliminado
        to_delete << {:row => row, :index => i}
      end
    end
 
    to_delete.each do |r|
      # Eliminamos el renglón del tablero
      @board.delete(r[:row])
      # Y eliminamos el renglón en el tablero de colores (para que
      # esté sincronizado con nuestro tablero de bloques)
      @board_colors.delete_at(r[:index])
      # Insertamos un nuevo renglón lleno de ceros (vacío) al inicio
      # de cada tablero (el de bloques y el de colores)
      @board.unshift(Array.new(@w,0))
      @board_colors.unshift(Array.new(@w,0))
    end
 
    # Aumentamos la puntuación del jugador
    @score += (10 * to_delete.size)
 
    # Y tocamos un sonido si se eliminaron algunos renglones
    @window.sounds[:completed_row].play if to_delete.size > 0
  end
 
  # Anchura del tablero en pixeles
  def pixel_w
    @w * @b_size
  end
 
  # Altura del tablero en pixeles
  def pixel_h
    @h * @b_size
  end
 
  # Intenta de mover la pieza actual a la izquierda
  def move_piece_left
    # Con el estado tentativo
    @current_piece.with_next_state do |s|
      # Lo movemos a la izquierda
      s.x -= 1
      # Checamos si es válida su posición y si no colisiona con nada
      if s.x >= 0 && can_take_it?
        # Si es así, actualizamos el estado
        @current_piece.to_next_state
      else
        # Si no, restauramos el estado
        @current_piece.restore_state
      end
    end
  end
 
  # Trata de mover la pieza actual a la derecha
  def move_piece_right
    # Con el estado tentativo
    @current_piece.with_next_state do |s|
      # Lo movemos a la derecha
      s.x += 1
      # Checamos si es válida su posición y si no colisiona con nada
      if s.x + s.w <= self.w && can_take_it?
        # Si es así, actualizamos el estado
        @current_piece.to_next_state
      else
        # Si no, restauramos el estado
        @current_piece.restore_state
      end
    end
  end
 
  # Trata de mover la pieza actual hacia abajo
  def move_piece_down
    # Con el estado tentativo
    @current_piece.with_next_state do |s|
      # Lo movemos hacia abajo
      s.y += 1
      # Checamos si es válida su posición y si no colisiona con nada
      if s.y + s.h <= self.h && can_take_it?
        # Si es así, actualizamos el estado
        @current_piece.to_next_state
      # Si la pieza está completamente dentro del tablero...
      elsif s.y > 0
        # Guardamos la pieza
        store_piece
        # Revisamos si hay renglones llenos y los quitamos
        compact_board
        # Ponemos en juego la siguiente pieza
        @current_piece = @next_piece
        # Y la ponemos lista para entrar al tablero
        @current_piece.move_to_center
        # Generamos la pieza que vendrá a continuación
        @next_piece = Piece.new(@window, self)
        # La ponemos al lado del tablero
        @next_piece.move_to_side
      # Si no está completamente dentro, significa que el tablero está
      # lleno
      else
        # Avisamos que el tablero está lleno
        @full = true
        # Y tocamos un sonido para avisar que el juego terminó
        @window.sounds[:game_over].play
      end
    end
  end
 
  # Trata de rotar la pieza a la izquierda
  def rotate_piece_left
    # Necesitaremos esto para mantener el pivote en su lugar cuando
    # hagamos la rotación de la pieza
    adjust_by = [0,0]
    # Necesitamos los datos de ambos estados
    # c = current_state, n = next_state
    @current_piece.with_states do |c, n|
      n.shape = @current_piece.empty_rotated_shape
      c.shape.each_with_index do |row, i|
        row.each_with_index do |cell, j|
          # Vemos si hay que realizar algún ajuste por el pivote
          adjust_by = [j-i, i-(row.size-j-1)] if c.shape[i][j] == 2
          # Copiamos la pieza rotada
          n.shape[row.size-j-1][i] = c.shape[i][j]
        end
      end
 
      # Hacemos los ajustes pertinentes
      n.x += adjust_by[0]
      n.y += adjust_by[1]
 
      # Checamos que esté dentro del tablero y que no colisione con
      # nada al rotar
      if n.x >= 0 &&
          n.x + n.shape.first.size <= self.w &&
          n.y + n.shape.size <= self.h &&
          can_take_it?
        # Si es así, la rotamos
        @current_piece.to_next_state
      else
        # Si no, la dejamos como estaba originalmente
        @current_piece.restore_state
      end
    end
  end
 
  # Trata de rotar la pieza a la derecha
  def rotate_piece_right
    # Necesitaremos esto para mantener el pivote en su lugar cuando
    # hagamos la rotación de la pieza
    adjust_by = [0,0]
    # Necesitamos los datos de ambos estados
    # c = current_state, n = next_state
    @current_piece.with_states do |c, n|
      n.shape = @current_piece.empty_rotated_shape
      c.shape.each_with_index do |row, i|
        row.each_with_index do |cell, j|
          # Vemos si hay que realizar algún ajuste por el pivote
          adjust_by = [j-(c.shape.size-i-1), i-j] if c.shape[i][j] == 2
          # Copiamos la pieza rotada
          n.shape[j][c.shape.size-i-1] = c.shape[i][j]
        end
      end
 
      # Hacemos los ajustes pertinentes
      n.x += adjust_by[0]
      n.y += adjust_by[1]
 
      # Checamos que esté dentro del tablero y que no colisione con
      # nada al rotar
      if n.x >= 0 &&
          n.x + n.shape.first.size <= self.w &&
          n.y + n.shape.size <= self.h &&
          can_take_it?
        # Si es así, la rotamos
        @current_piece.to_next_state
      else
        # Si no, la dejamos como estaba originalmente
        @current_piece.restore_state
      end
    end
  end  
 
  # Método para facilitarnos el iterar a través de todas las celdas
  # que contiene el tablero
  def for_every_cell
    @board.each_with_index do |row,i|
      row.each_with_index do |cell,j|
        yield cell, i, j
      end
    end
  end
 
  # Para dibujar el marcador en pantalla
  def draw_score
    # Dibujamos la palabra "Puntos" en la pantalla
    @window.font.
      draw(GameConstants::Text::Score,
           offset_x - @window.font.text_width(GameConstants::Text::Score, GameConstants::Factor*1.5) - @b_size*2,
           offset_y,
           ZOrder::UI,
           GameConstants::Factor*1.5,
           GameConstants::Factor*1.5,
           0xffffffff)
 
    # Dibujamos los puntos que lleva el jugador
    @window.font.
      draw(@score,
           offset_x - @window.font.text_width(@score, GameConstants::Factor) - @b_size*2,
           offset_y + @b_size *2,
           ZOrder::UI,
           GameConstants::Factor*1.0,
           GameConstants::Factor*1.0,
           0xffcc3300)
  end
 
  # Para dibujar las piezas en pantalla (la actual y la siguiente)
  def draw_pieces
    # Dibujamos la pieza en juego
    @current_piece.draw
    # Dibujamos la pieza que sigue
    @next_piece.draw
    # Dibujamos las palabras "Siguiente pieza" en la pantalla
    @window.font.
      draw(GameConstants::Text::NextPiece,
           offset_x + w * @b_size + @b_size*2,
           offset_y,
           ZOrder::UI,
           GameConstants::Factor*0.9,
           GameConstants::Factor*0.9,
           0xffffffff)
  end
 
  # Para dibujar el tablero en la pantalla
  def draw_board
    # Dibujamos el tablero iterando cada celda que lo compone
    for_every_cell do |c, i, j|
      @window.graphics[:square].
        draw(@offset_x + j*@b_size,
             @offset_y + i*@b_size,
             ZOrder::Board,
             GameConstants::Factor,
             GameConstants::Factor,
             @board[i][j] == 0 ? @color : @board_colors[i][j],
             :default)
    end
  end
 
  # Dibujamos el tablero, el marcador y las piezas en pantalla
  def draw
    draw_score
    draw_pieces
    draw_board
  end
end
 
 
# Esta es la clase que controla la aplicación, aquí se checa la
# entrada de teclado y se lleva el registro de los tiempos para hacer
# que las piezas desciendan
class Metris < Gosu::Window
  # Ancho y alto de la pantalla, fuente a usar para el texto, gráficos
  # y sonidos
  attr_reader :w, :h, :font, :graphics, :sounds
 
  def initialize
    @w = GameConstants::ScreenWidth
    @h = GameConstants::ScreenHeight
 
    super(@w, @h, GameConstants::FullScreen)
    self.caption = GameConstants::Text::Caption
 
    # Esta variable nos servirá para llevar un control de los gráficos
    # que tenemos en el juego
    @graphics = Hash.new
    # La imagen que usamos para representar los bloques
    @graphics[:square] = Gosu::Image.new(self, GameConstants::Graphics::Tile, true)
    # Y la que usamos para el pivote en las piezas
    @graphics[:circle] = Gosu::Image.new(self, GameConstants::Graphics::Pivot, true)
 
    # Variable para tener fácil acceso a los sonidos
    @sounds = Hash.new
    # Sonido a tocar cuando un renglón este lleno
    @sounds[:completed_row] = Gosu::Sample.new(self, GameConstants::Sounds::CompletedRow)
    # Sonido a tocar cuando el juego termine
    @sounds[:game_over] = Gosu::Sample.new(self, GameConstants::Sounds::GameOver)
    # Sonido a tocar cuando una pieza haya tocado fondo
    @sounds[:store_piece] = Gosu::Sample.new(self, GameConstants::Sounds::StorePiece)
    # Sonido a tocar cuando comience el juego
    @sounds[:game_start] = Gosu::Sample.new(self, GameConstants::Sounds::GameStart)
    # Sonido a tocar cuando no se pueda rotar o mover la pieza a algún lugar
    @sounds[:invalid_move] = Gosu::Sample.new(self, GameConstants::Sounds::InvalidMove)
 
    # Creamos el tablero de juego
    @board = Board.new(self)
    # Creamos la fuente para poner texto en pantalla
    @font = Gosu::Font.new(self, Gosu::default_font_name, 30)
 
    # Inicializamos los contadores de tiempo y el tablero
    reset
  end
 
  # Para inicializar los tiempos y el tablero
  def reset
    @moving_time = @falling_time = Gosu::milliseconds
    @moving_delta = @falling_delta = 0
    @board.reset
  end
 
 
  # Este es el ciclo del juego (gameloop)
  def update
    # Si el tablero no está lleno, lo actualizamos
    update_board if(!@board.full)
  end
 
  # Para actualizar el tablero
  def update_board
    # Tomamos el tiempo actual
    @new_time = Gosu::milliseconds
    # La diferencia entre el tiempo actual y el tiempo de movimiento
    @moving_delta = @new_time - @moving_time
    # La diferencia entre el tiempo actual y el tiempo de caida
    @falling_delta = @new_time - @falling_time
 
    # Esto pregunta si ya pasaron X ms desde la última vez que la
    # pieza bajo un renglón
    if @falling_delta > GameConstants::BoostedDescendTime
      # Si es así, entonces checamos si está presionado el botón de
      # flecha abajo
      if button_down? Gosu::Button::KbDown
        # Hacemos que el tablero mueva la pieza un renglón abajo
        @board.move_piece_down
        # Reiniciamos la variable del tiempo de caída al tiempo más
        # reciente obtenido
        @falling_time = @new_time
      end
    end
 
    # Este código es el que hace que la pieza baje automáticamente
    # cada X número de milisegundos, funciona igual que el anterior
    if @falling_delta > GameConstants::DescendTime
      @board.move_piece_down
      @falling_time = @new_time
    end
 
    # Este código permite que el jugador mantenga pulsada una tecla y
    # la pieza se siga moviendo a los lados, o siga rotando
    if @moving_delta > GameConstants::RepeatTime
      if button_down? Gosu::Button::KbRight
        @board.move_piece_right
        @moving_time = @new_time
      end
 
      if button_down? Gosu::Button::KbLeft
        @board.move_piece_left
        @moving_time = @new_time
      end
 
      if button_down? Gosu::Button::KbUp
        @board.rotate_piece_right
        @moving_time = @new_time
      end
 
      if button_down? Gosu::Button::KbQ
        @board.rotate_piece_left
        @moving_time = @new_time
      end
 
      if button_down? Gosu::Button::KbW
        @board.rotate_piece_right
        @moving_time = @new_time
      end
    end
 
 
  end
 
  # Esto es para tener acción inmediata, si alguien presiona de manera
  # repetida las flechas hacia los lados se obtendrá un movimiento más
  # rápido que si la dejamos presionada
  def button_down(id)
    # Si se presiona la tecla Esc, salimos
    self.close if id == Gosu::Button::KbEscape
    # Si se presiona la tecla Enter, reiniciamos el juego
    reset if id == Gosu::Button::KbReturn
 
    # Si el tablero está lleno, no continuar
    return if @board.full
 
    # Movimientos y rotaciones
    if id == Gosu::Button::KbRight
      @board.move_piece_right
      @moving_time = @new_time
    end
 
    if id == Gosu::Button::KbLeft
      @board.move_piece_left
      @moving_time = @new_time
    end
 
    if id == Gosu::Button::KbQ
      @board.rotate_piece_left
      @moving_time = @new_time
    end
 
    if id == Gosu::Button::KbUp
      @board.rotate_piece_right
      @moving_time = @new_time
    end
 
    if id == Gosu::Button::KbW
      @board.rotate_piece_right
      @moving_time = @new_time
    end
  end
 
  # Dibujar el "game over"
  def draw_game_over
    @font.draw_rel(GameConstants::Text::GameOver,
                   @w/2,
                   40,
                   ZOrder::UI,
                   0.5,
                   0.5,
                   GameConstants::Factor*2.0,
                   GameConstants::Factor*2.0,
                   0xffff0000)
    @font.draw_rel(GameConstants::Text::Info,
                   @w/2,
                   @board.pixel_h + @board.offset_y + 10,
                   ZOrder::UI,
                   0.5,
                   0,
                   GameConstants::Factor*0.8,
                   GameConstants::Factor*0.8,
                   0xffffffff)
  end
 
 
  # Dibujar el tablero y el gameover de ser necesario
  def draw
    @board.draw
 
    # Dibujamos el game over si el tablero está lleno
    draw_game_over if @board.full
  end
end
 
# Creamos la aplicación y la mostramos
Metris.new.show

Programación de videojuegos con Gosu en Ruby

lobo_tuerto — Fri, 10 Jul 2009 02:18:44 +0000

Aún recuerdo cuando me saltaba la barda de la primara para ir a las maquinitas a la hora del recreo. Buenos tiempos aquellos del Atari 2600.

Desde siempre me han llamado la atención los videojuegos — y fui un jugador asiduo y vago, cabe mencionar jeje.

Y también desde siempre quise aprender a programar videojuegos. Aprendí a programar, pero conforme pasaron los años cada vez tenía menos tiempo para mis proyectos personales.

Estos días, sin embargo, he andado un poco libre y me puse a investigar como andaba el rollo de la programación de juegos en Ruby, dado que es el lenguaje que he adoptado a últimas fechas — y que además adoro como no tienen idea.

Entonces, andando por la red me enteré de un framework llamado Gosu (sitio en Google Code | Wiki del proyecto).

Gosu, es una biblioteca multiplataforma para desarrollo de juegos en 2D. Tiene soporte para C++ y Ruby. Sumamente sencillo de agarrar y usar.

¿No me creen? échenle un ojo al tutorial de Ruby (o al de C++). En este otro sitio pueden descargar el tutorial de Gosu y Ruby en PDF en español: Un videojuego sencillo con Gosu y Ruby

Bueno, la noticia es que me puse a programar un Tetris, comencé ayer a las 4pm aprox, y ya casi lo termino. Me falta comentar el código y refactorizar algunas cosas. En cuanto lo tenga listo (más al rato o mañana) lo pondré por si están interesados en incursionar en el game development.

Aquí les dejo un screenshot jejeje:

De hecho, estaba pensando en hacer un remake de varios juegos antiguos — sólo por diversión y conocimiento. Y después me gustaría hacer algo más elaborado, como Gauntlet — ¡le traigo un chingo de ganas desde hace un buen!

¿Qué tal, cómo ven?
¿Algún otro interesado en programar juegos en Ruby?

Soy tu aire — Arte interactivo

lobo_tuerto — Wed, 20 May 2009 18:13:40 +0000

¿Qué tan lejos se puede llevar la metáfora de pintar una canción? De Labuat Soy tu aire.

Tenía un buen rato que no sostenía en mi cara una sonrisa honesta por tanto tiempo… Vean el por qué aquí.

Tutorial #4 de Irrlicht: Cómo controlar con el teclado un nodo de escena

lobo_tuerto — Wed, 04 Mar 2009 20:10:09 +0000

Ah pasado un rato desde el último tutorial que escribí para Irrlicht. Cuestiones de tiempo no me habían permitido seguir jugando con este motor gráfico.

Pero aquí seguimos, al pie del cañón.
Ok, manos a la obra.

Pueden seguir el tutorial para descargar y compilar la versión en desarrollo de Irrlicht, o simplemente descargar de sourceforge la más reciente liberada al público (la 1.5 al momento de escribir este tutorial).

Objetivo

Controlar un nodo de escena con el teclado.

Tutoriales pasados

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04
Tutorial #2 de Irrlicht: Cómo configurar NetBeans 6.1 y hacer un Hola Mundo
Tutorial #3 de Irrlicht: Cómo agregar y manipular nodos de escena en Irrlicht

Juego de Talento: Take #2

lobo_tuerto — Sat, 25 Oct 2008 15:07:33 +0000

La pensé un poco, no quería —como dicen— restregar sal en la herida, pero que chingaos, ya son varias las personas que me han comentado recientemente lo que está sucediendo con Juego de Talento.

Basta ver el último comentario publicado por GameIndustrySavior en el artículo anterior. Pongo la versión TL;DR a continuación para tu comodidad:

Juego de Talento no es mas que una escusa que utilizaron los organizadores para promover su centro CECAVIM, el cual despues de analizar la curricula presenta programas de estudio basura que no ayudaran a nadie a realmente entrar a la industria, solo enriquecer a los dueños de estas iniciativas. Del jurado del “Virtuality” solo hay 1 persona que realmente se dedica al desarrollo de videojuegos, los demas son personas que no tienen que ver con la industria a excepcion de la chica de gamers que creo yo si aporta a la parte del gameplay. Por dios hasta hay un contador publico! que contador publico es incluido en un concurso de desarrollo de videojuegos como juez!??? Todo esto demuestra que JDT es otra iniciativa que en vez de ayudar a la apenas naciente industria, la perjudica.
…

Un contador público → LOL?

Esta es una conversación que tuve hace unos meses (en agosto para ser exactos) con alguien involucrado en Juego de Talento:

Anonymous: tu le entraste al Juego de Talento?
Lobo tuerto: nop
Lobo tuerto: de hecho fui uno de los que lo critico jejeje
Lobo tuerto: tu le entraste?
Anonymous: jejeje
Anonymous: nel… pero ando ahi de metiche
Lobo tuerto: que bien, y cómo va todo el asunto?
Anonymous: pos ahi va… solo que los weyes que concursan no tienen ni puta idea de la que les espera jejeje
Anonymous: stan entusiasmados… pero los cabrones se van a pegar con la pared al final jejeje
Lobo tuerto: jajajaja porque lo dices
Lobo tuerto: que viene?
Anonymous: a pos que los cabrones creen que el mundo les tiene que dar las cosas de a gratis jejeje
Anonymous: se supone, que los ganadores, a parte de llevarse su lana de 1, 2 o 3 lugar… les van a apoyar a poner su empresa o a hacer su juego
Lobo tuerto: ah sip
Lobo tuerto: eso si lo había leído
Lobo tuerto: psss
Lobo tuerto: ojala que todo salga bien jeje
Anonymous: perooooo
Anonymous: te digo que los chavos estan tan enajenados que no se dan cuenta de la realidad de las cosas jejeje
Anonymous: los de Juego de Talento solo les van a dar 3 opciones a los ganadores:
Anonymous: 1- Apoyarlos a hacer su Juego
2- Apoyarlos en hacer su Empresa
3- Tomen su premio y mucha suerte
Lobo tuerto: hmmm
Lobo tuerto: yo tomaria la 3
Lobo tuerto: pero de nuevo, por lo mismo no estoy en juego de talento jejeje
Anonymous: tanto para la 1 como para la 2… es obvio que tanto financiar un proyecto, como armar una empresa implica una inversión pesada de lana y muchas otras cosas
Anonymous: y pos es natural que nadie te va a regalar toda esa lana
Lobo tuerto: aunque por ahi tambien lei, de que los de juego de talento podrian tomar el proyecto y sacarlo ellos, si es que los participantes “no estuveran interesados” en hacerlo ellos mismos no?
Anonymous: esa es la opción 1
Anonymous: el chiste es el siguiente… si tomas la opción 1, en la que te apoyen en hacer tu juego… la única condición para que eso suceda, es que les tienes que secer tu IP
Anonymous: en la opción 2… donde te ayudan a poner tu empresa… ellos se van a quedar un buen % de las acciones de la misma
Lobo tuerto: ohhhh
Lobo tuerto: omg
Anonymous: es natural… yo la neta si voy a financiar un proyecto… es porque espero que me regresen mi inversión y también generar ganancia
Lobo tuerto: obvio
Anonymous: asi es como se hacen las cosas
Lobo tuerto: aunque eso suena mas a inv priv
Lobo tuerto: siendo del gobierno
Lobo tuerto: podrias “esperar” otra cosa
Anonymous: pero el pedo es que muchos no se dan cuenta de esto y al rato se van a poner a chillar jejeje
Lobo tuerto: no crees?
Anonymous: pues no… JDT no tiene nada que ver con el gobierno jejeje… es 100% iniciativa privada
Lobo tuerto: pues creo que les deberían dar un “propedéutico”
Lobo tuerto: y platicarles y que entiendan bien eso
Lobo tuerto: lol
Lobo tuerto: pues como salió el tema de la política y eso, crei que era del gobierno
Lobo tuerto: luego eso tiendo a pensar cuando escucho “secretaría de economía” en algún lugar
Anonymous: el gobierno está metido, pero solo porque el gobierno financió el proyecto de JDT… pero no lo organizaron
Lobo tuerto: ya veo la escalera
Lobo tuerto: jejeje
Anonymous: pues incluso nosotros también metimos un par de proyectos a la Secre de Economia para que nos ayudaran con el financiamiento
Lobo tuerto: pense que el tal grinberg era el que dirigia jdt y era algún político
Lobo tuerto: no se de donde saqué la idea
Lobo tuerto: jajaajaj
Anonymous: pues el Grinberg ni siquiera es mexicano… es un argentino que supo como sacarle lana al gobierno de México jejeje
Lobo tuerto: uta….
Lobo tuerto: no, pues esto confirma mis sospechas jajaja
Lobo tuerto: es que tuve un post en mi blog algo polemico jaja
Anonymous: jajaja
Lobo tuerto: hasta un tipo del staff de jdt me fue a “escribir” ahi
Anonymous: chido jejeje
Lobo tuerto: pero entendio mal mi “rant”
Lobo tuerto: a final de cuentas conclui con que SI me da gusto que haya ese tipo de iniciativas, pero tambien SI les falta un buen con la organizacion y logistica
Lobo tuerto: y mira que medio los disculpe porque crei que eran del gobierno jajaja
Lobo tuerto: pero ahora que se que son inversion 100% priv psss
Anonymous: y no solo eso… JDT es solo una fachada jejeje… por eso esta todo mal organizado…
Lobo tuerto: bueno y no solo eso
Lobo tuerto: ve
Lobo tuerto: jejeje
Anonymous: el verdadero plan malifico vendrá después jejeje
Lobo tuerto: chas
Lobo tuerto: ya hasta parece telenovela
Lobo tuerto: jejeje
Lobo tuerto: y que sigue? (jajaja)
Anonymous: pues no puedo decir mucho… incluso lo que te comento es ‘off the record’ jejeje
Anonymous: puedes usar la información… solo no digas de donde salio jejeje
Lobo tuerto: claro
Lobo tuerto: es mi deber como bloggero
Lobo tuerto: proteger las fuentes
Lobo tuerto: jeje
Anonymous: yup
Anonymous: es todo un desmadre… pero pos es que si uno no juega con sus reglas, luego no te dan chance de nada y pos tus grandes sueños se quedas solo en eso… sueños
Lobo tuerto: de acuerdo contigo
Anonymous: al menos nosotros estamos procurando que las cosas beneficien a todos…
Anonymous: no lo niego, tenemos nuestras prioridades, pero neta que si queremos ver crecer todo esto
Lobo tuerto: si, de acuerdo tambien
Anonymous: lo que se es que el Gabriel tiene el plan de poner 3 negocios:
1- Estudio desarrollador de juegos
2- Su escuela
3- Una incuvadora para estudios de games
Anonymous: y pues JDT es solo una fachada para todo eso

Lobo tuerto: chale
Lobo tuerto: justo lo que queria hacer
Lobo tuerto: pero yo sin varo
Lobo tuerto: jajajaaj
Lobo tuerto: pues ojala le funcione
Lobo tuerto: neta

Y bueno, como digo, las puras buenas intenciones no bastan, si quieren hacer algo no lo hagan con las nalgas, háganlo bien, no hay otra manera.

Dev.Mag #25

lobo_tuerto — Fri, 12 Sep 2008 23:50:22 +0000

Acaba de ser publicado el número 25 de la revista de desarrollo de videojuegos Dev.Mag (chequen de una vez el 24 jeje).

Si aún no la conoces puedes revisar la lista de todos los números editados.

¡Muy recomendable!

Dev.Mag #23

lobo_tuerto — Wed, 09 Jul 2008 17:28:15 +0000

Ya está publicado el número 23 (y el 22 jeje) de Dev.Mag, revista orientada al desarrollo de videojuegos.

Viene totalmente rediseñada para ser fácilmente leída donde normalmente lo hacen: En el monitor.

Si aún no la conoces puedes revisar la lista de todos los números editados. ¡Muy recomendable!

Tutorial #3 de Irrlicht: Cómo agregar y manipular nodos de escena en Irrlicht

lobo_tuerto — Thu, 29 May 2008 01:46:18 +0000

Todo proyecto comienza por un principio —ya sé, bonito aforismo.

Por fin haremos algo divertido —uy si, cuánto— con Irrlicht: vamos a agregar algunos objetos a nuestro espacio 3D y los mostraremos en pantalla.

Véanlo como poner a un actor en escena, es el primer paso para lograr una obra, en nuestro caso ¡un videojuego!

Los videojuegos en su parte más fundamental están compuestos por entidades, ya saben, siempre nos referimos a ellas como el personaje principal (o monito), los monstruos, las balas, las pociones, el castillo, etc.

Nosotros comenzaremos agregando cubos a nuestra aplicación, esperando que en un futuro no muy lejano se conviertan en temibles criaturas a las cuales podamos derrotar a base de espadazos o balazos —o algo así.

Objetivo

En este tutorial aprenderemos a agregar nodos de escena y a modificarles las siguientes propiedades:

Posición
Escala
Rotación

Tutoriales pasados

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04
Tutorial #2 de Irrlicht: Cómo configurar NetBeans 6.1 y hacer un Hola Mundo

Tutorial #2 de Irrlicht: Cómo configurar NetBeans 6.1 y hacer un Hola Mundo

lobo_tuerto — Sat, 10 May 2008 06:28:07 +0000

¿Por qué NetBeans? porque me gusta.

Lo he estado usando para el último proyecto Rails en el que he trabajado y se me hace un IDE muy bueno. Si quieren leer sobre sus capacidades específicas para C/C++ pueden hacerlo aquí: C/C++ features.

Se que muchos han escuchado que necesita grandes cantidades de recursos, que es muy lento y otras tantas cosas más, yo solo les digo que antes de juzgar lo prueben.

Aprovechen, acaba de salir la versión 6.1.

Objetivo

El objetivo de este tutorial es configurar NetBeans para poder compilar desde ahí nuestras aplicaciones basadas en Irrlicht.
Y crearemos nuestro primer programa usando este poderoso motor gráfico, así es, ¡un Hola Mundo con Irrlicht!

Tutoriales pasados

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04

Juego de talento: ¿una iniciativa REAL para apoyar el desarrollo de videojuegos en México?

lobo_tuerto — Fri, 09 May 2008 05:39:28 +0000

Lo dudo mucho.

La intención inicial debió ser buena (muy buena, creo) pero la realidad deja mucho que desear.

¿Por qué digo esto? pues como dijo Jack el destripador (y un buen amigo), vámonos por partes…

Estoy convencido de que el principal problema es casi siempre, que la gente que está a cargo de cierta área, no es experta o apasionada en ella.
Para muestra basta un botón, vean lo que contestó Gabriel Grinberg a una muchachoa llamadoa KAILA el la cual preguntó en qué categoría entrarían King of Fighters y God of War.
Por si les da flojera les puedo compartir que él respondió que esos juegos entrarían en estrategia, a sabiendas de que en el concurso existe una categoría de acción —raro ¿no?
Por otra parte, la mayor queja es —para variar— una pésima organización, además de falta de seriedad. Nada más vean los comentarios que pone la gente aquí: Juego de talento.
Algo que me hizo desconfiar inmediatamente de que fuese una propuesta genuina y parcial es que recortaron la fecha límite de envío de proyectos de dos meses a tan solo uno.
Es decir, la fecha límite de envío de proyectos pasó de ser del 30 de junio al 30 de mayo. Encima te dicen que los de INDAUTOR se tardan 20 días en registrar tu obra (lo cual es requisito indispensable para concursar). Así que debías tener algo preparado con anterioridad, o ser capaz de hacer algo presentable en unos cuantos días.
Una más, los famosos talleres en un inicio no eran obligatorios, ahora sí lo son. ¿Con tanta tecnología no se les pudo haber prendido el foco y sacar el material de manera virtual para los que son del interior de la república? lo bueno es que te consiguen tarifas preferenciales en hoteles… han de creer que todos son estudiantes de la Ibero o del Tec. O que disponemos total y libremente de nuestro tiempo —algunos hacemos el intento por trabajar.

En lugar de querer captar gente o “talentos”, más bien parece que quisieran limitar la entrada, es posible que ya incluso cuenten con su ganador jajaja (si, conspiracionista el asunto).

Por cierto, una persona que se autodenominó cauto hizo comentarios en la misma línea —conspiratoria— en la página de Juego de talento, pero en lugar de ignorar sus comentarios o contestarlos con profesionalidad, trataron de mofarse de ellos. Chéquen la sección de Preguntas Frecuentes para que vean a que me refiero.

Ya para terminar quiero comentar que la página esta hecha un desmadre, mal organizada como todo el evento. Lo que debieron haber puesto es una portada con la información y enlaces a unos foros, no ocupar una sección de comentarios para preguntas y respuestas.

De seguro les dieron un buen presupuesto para el sitio web y la terminó haciendo el sobrino de alguno de los organizadores —nunca falta.

Pero bueno, lo rescatable del asunto es que YA empieza a haber eventos mas “serios” con respecto al desarrollo de videojuegos en México, y eso SI que me da gusto.

Supongo que con el tiempo mejorará la calidad y organización de los mismos.

A los que van a participar les deseo la mejor de las suertes, y a los que no, también.

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04

lobo_tuerto — Sun, 04 May 2008 03:29:55 +0000

Este tutorial es el primero de una serie que escribiré acerca de este excelente motor gráfico.
Los artículos me servirán como apuntes de lo que he aprendido y si alguien más se beneficia con ellos pues qué mejor.

Objetivo

El objetivo de este primer tutorial es descargar, compilar e instalar las bibliotecas de la versión más reciente de Irrlicht en mi sistema operativo favorito: Ubuntu en su versión más reciente la 8.04 Hardy Heron. Como paso opcional compilaremos los ejemplos y ejecutaremos el famoso “Hello world”.

A darle, que pa’ luego es tarde…

Descargar y compilar Irrlicht

Si no cuentas con SVN (Subversion) necesitas instalarlo, lo ocuparás para descargar el código fuente de Irrlicht.
Abre una terminal y en ella teclea lo siguiente:

1	sudo apt-get install subversion

También necesitamos instalar ciertos paquetes en nuestro sistema para poder compilar Irrlicht.
Teclea lo siguiente en la terminal:

1	sudo apt-get install build-essential xserver-xorg-dev x11proto-xf86vidmode-dev libxxf86vm-dev mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev libxext-dev

Ya con SVN en nuestro equipo y los requisitos previos cubiertos, procedemos a crear un directorio donde almacenaremos el código fuente de Irrlicht que descargaremos desde su repositorio.
En tu terminal teclea los siguiente comandos:

1
2
3

mkdir src
cd src
svn checkout https://irrlicht.svn.sourceforge.net/svnroot/irrlicht/trunk irrlicht

Para compilar Irrlicht:

1 2	cd irrlicht/source/Irrlicht make

Opcional: Compilar los ejemplos

Después de compilar Irrlicht, inmediatamente puedes compilar los ejemplos:

1
2
3

cd ../../examples
./buildAllExamples.sh
cd ../bin/Linux

Para ejecutar el Hello World de ejemplo que trae Irrlicht, escribe lo siguiente en tu terminal:

1	./01.HelloWorld

Instalar Irrlicht en Ubuntu

Ahora vamos a instalar la biblioteca compilada y los archivos de cabecera en nuestro sistema:

1
2
3

cd ../..
sudo cp lib/Linux/libIrrlicht.a /usr/local/lib/
sudo cp -r include/* /usr/local/include/

Listo, ya contamos con lo necesario para experimentar y comenzar a develar los misterios de la programación de videojuegos.

Lo que sigue

El tutorial #2 ya viene en camino y muestra cómo configurar NetBeans —mi IDE favorita— para compilar programas basados en Irrlicht.

¡Hasta la próxima!

Referencia

Installing Irrlicht

Dev.Mag #21

lobo_tuerto — Wed, 02 Apr 2008 04:19:04 +0000

Ya está publicado el número 21 de Dev.Mag, revista orientada al desarrollo de videojuegos.

Si te interesa la programación de juegos para computadora o estás iniciándote en ello, hazte un favor y descarga todos los números de Dev.Mag.

Traducción del correo que recibí:

Después de saltarnos un mes, ¡el número 21 ya está aquí!

En esta edición le echamos una mirada a AGS, analizamos la GDC anual y reseñamos muchos juegos independientes.
Además continuamos con nuestros artículos sobre Irrlicht y Blender.

Disfruta lo que ofrecemos este mes, ¡y prepárate para una gran sorpresa en la siguiente edición!

¡VAMOS!

Cambiando un poco de tema, mi “engine 3D” preferido por el momento es Irrlicht.

Si estuviese haciendo un juego eligiría como herramientas base:

Irrlicht como motor de 3D.
Raknet como motor de red.
skAI para la inteligencia artificial.
Y para la física aún debo decidir entre Bullet, ODE o Tokamak.

Desarrollo de videojuegos: Dev.Mag

lobo_tuerto — Sat, 16 Feb 2008 15:12:31 +0000

Husmeando por la red me encontré con una excelente publicación sobre desarrollo de videojuegos.

Estoy hablando de Dev.Mag, una revista sudafricana de distribución gratuita (y en línea) que actualmente va en el número 20 —The “I” Edition: Irrlicht, IGF and Innovation— si te late todo lo relacionado con el desarrollo de juegos de video deberías darte una vuelta por su sitio.

El último número trae una entrevista con el creador de Irrlicht, reseñas de juegos interesantes (e independientes), tutoriales de Blender, de Irrlicht, de gráficos para videojuego con Photoshop y hasta de programación del Ruido Perlin, también tiene su sección de diseño entre otras.

Bájenla y espero sus comentarios acerca de ella

lobo_tuerto » game development

lotu — Un framework para desarrollo de juegos en Ruby

Los antecedentes

lotu

lotu gem

Otros frameworks

Artículos relacionados:

Programando un PBBG en Ruby & Rails

PBBGs

Instant Time Strategy (ITS)

Mi development stack

Modelando los combates

Artículos relacionados:

Ruby steering behaviors

El código

El demo

Implementación en C++

Artículos relacionados:

Rubytris en GitHub

Rubytris (¡con nuevo nombre!)

Artículos relacionados:

Una manita de gato al clon de Tetris

Actualización 2009-08-01 03:29am

Artículos relacionados:

Optimizando operaciones sobre vectores en Ruby con memoization

La clase Vector2d

Una breve explicación

Artículos relacionados:

Mi próximo videojuego

Artículos relacionados:

Cómo instalar Ruby/Gosu en Ubuntu 9.04 Jaunty Jackalope

Instalación de dependencias para Ruby 1.8

Instalación de la gema

Instalación de dependencias adicionales para el soporte de OpenGL en algunos ejemplos

Soporte para Ruby 1.9

Recursos

Artículos relacionados:

Metris — Mi clón de Tetris en Ruby y Gosu

Descargar

Artículos relacionados:

Programación de videojuegos con Gosu en Ruby

Artículos relacionados:

Soy tu aire — Arte interactivo

Artículos relacionados:

Tutorial #4 de Irrlicht: Cómo controlar con el teclado un nodo de escena

Objetivo

Tutoriales pasados

Artículos relacionados:

Juego de Talento: Take #2

Artículos relacionados:

Dev.Mag #25

Artículos relacionados:

Dev.Mag #23

Artículos relacionados:

Tutorial #3 de Irrlicht: Cómo agregar y manipular nodos de escena en Irrlicht

Objetivo

Tutoriales pasados

Artículos relacionados:

Tutorial #2 de Irrlicht: Cómo configurar NetBeans 6.1 y hacer un Hola Mundo

Objetivo

Tutoriales pasados

Artículos relacionados:

Juego de talento: ¿una iniciativa REAL para apoyar el desarrollo de videojuegos en México?

Artículos relacionados:

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04

Objetivo

Descargar y compilar Irrlicht

Opcional: Compilar los ejemplos

Instalar Irrlicht en Ubuntu

Lo que sigue

Referencia

Artículos relacionados:

Dev.Mag #21

Artículos relacionados:

Desarrollo de videojuegos: Dev.Mag

Artículos relacionados: