**kwargs siempre me sonó a WARRRRRRRRRRRRRRRRRRRRRRRRRGGGGGGGHH o algo así como lo que usaría un orco para salir al campo de guerra. De hecho, me hizo acordar al mejor recurso para construir unidades que puede tener un juego de estrategia. Y cuando hablo de juego de estrategia hablo de Warhammer 40000 (Dawn of War y sus expansiónes). Los orcos tienen el Waagh!, que viene a ser una mezcla de guerra santa, migración y violencia galáctica, como un movimiento sindical, pero con menos lucha de clases.

La cuestión es que me fuí por las ramas. Bueno.

Supongamos que, en Python,  queremos hacer un programa que sume una cantidad indeterminada de números. Claro, podemos hacer un programa rápido tipo “mientras usario no escriba BASTA hacer: suma = suma + valor_ingresado”, pero por suerte, tenemos magia pythonesca:

Veamos:

def suma(*args):

return sum(args)

Y ya está!

>>> suma(1100)
1100
>>> suma(21,2,2,3,4,5,6,7,6,6,6,6,6)
80
>>> suma (1,2,3,4,5,6,7,8,8,9,0,100231,1.2)
100285.2
>>> a = 40
>>> suma (a,a*2,a**a)
12089258196146291747061760000000000000000000000000000000000000120L
Bueno, en ese me zarpé. Pero creo que se entiende, no? No importa cuantos parámetros pasemos (siempre que no caigamos en un loop infinito), Python agarra los argumentos que le pasamos y los suma (con sum)

Otro ejemplo

>>> def saludo(*args):
…     for nombre in args:
…             print “hola, %s” % nombre

>>> saludo(u”Nicolás”, “Sergio”)
hola, Nicolás
hola, Sergio

Bellísimo! hora de ahorrar un poco de código. Ahora bien, *args creo que está explicado (y creedme, en la hay  gente que explica mucho mejor que yo), ¿Cómo es la onda con **kwargs?.

Bueno, es casi lo mismo que *args, pero se diferencian en algo muy interesante. *args solo sirve para argumentos “sueltos” (sin palabras clave o variables), como vimosen los ejemplos. O sea, tomando “saludo()”, no podría haber hecho “saludo(nombre=”tomate”)”

>>> saludo(nombre=”Tomate”)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: saludo() got an unexpected keyword argument ‘nombre’
Porque justamente, le estoy pasando un argumento CON NOMBRE. Acá entra en acción **kwargs (Keyword Arguments, o KWARRRRRRRRRRRRRRRGH!)

>>> def saludo(**kwargs):
…     for nombre in kwargs:
…             print u”hola %s, estás en %s” % (kwargs[nombre], nombre)

>>> saludo (n1 = “nico”, n2=”blog”, n3=”melissa”)
hola nico, estás en n1
hola blog, estás en n2
hola melissa, estás en n3

Espectacular, ¿no?

Otra joyita, de paso, es saber que kwargs y args no tienen importancia. LO VITAL son los * y los **, que determinan si vas a pasar argumentos con clave o no. Igual se recomienda que usemos args y kwargs para tener un código más legible

Un ejemplo al voleo:

>>> def otro_nombre(**pato):
…     for animal in pato:
…             print u”dentro de %s está el %s” % (animal, pato[animal])

>>> otro_nombre(caramelo=”santo”)
dentro de caramelo está el santo

claro, el santo!

Una buena lectura sobre el tema (con ejemplos más bonitos) acá

El Sábado 10 de Octubre se realizó en Santa Fe ciudad, la 1° Jornada de Videojuegos Santa Fe, donde se juntaron muchas empresas de la provincia (puedo decir que estuvo Sismo Studio de Rafaela) a comentar casos de éxito, la situación del mercado nacional/internacional y a compartir sus desarrollos.

Además, se hicieron talleres sobre tecnologías de desarrollo de videjuegos (muy interesante la charla sobre Blender!) y la presentación de la Tecnicatura en Diseño y Programación de Videojuegos, que se va a dictar en la Faculta de Ingeniería y Ciencias Hídricas, a partir del primer cuatrimestre de 2010.

Por si el lector está interesado en saber más, se puede ver la introducción que da CoDeViSa (Comunidad de Desarrolladores de Videojuegos de Santa Fe), pasate por su página que lo describen mejor que yo.  Les dejo un párrafo interesante:

Entre otros objetivos, el encuentro busca difundir los estudios de desarrollo de videojuegos  de la región y el país, afianzando la relación entre el ámbito académico y empresarial.

La verdad que eso fué muy importante.  Yo pensaba que, realmente, crear videojuegos en Argentina era algo poco rentable…y la verdad que me equivoqué. La Asociación de Desarrolladores de Videojuegos Argentina (Adva), escribe sobre esto en su FAQ. Por lo que pude preguntar a algunos empresarios, es muy interesante ver que, realmente, hay mucho trabajo para exportar. El mercado estrictamente nacional es “escaso”, y parece ser que la rentabilidad de las empresas viene de la producción que exportan al exterior.

Cuando llegué al evento, se pudo notar que superaron las expectativas de asistencia, los talleres (que tenían un cupo limitado), se llenaron enseguida, y la gente que se quedó afuera (me incluoyo),   pudo ver los talleres mediante un plasma en el sector de stands. Vamos a ver si se grabaron los talleres así pongo el link :)

El evento (por lo que pude estar), fue genial. No solo por el hecho de tratarse de Videojuegos, sinó por enterarme que, a pesar de lo que uno puede pensar, Hacer videojuegos tiene rentabilidad.

Una de las charlas a la cual asistí, Producción de Videojuegos, por Agustín Pérez Fernández, habló sobre los distintos mercados posibles que hay ahora mismo.

No voy a transcribir la charla completa (y espero poder verla colgada por Internet en algún momento), pero voy a comentar una sensación que tuve. Ciertos mercados, como el de juegos para celular, o juegos web, son muy fáciles de entrar a competir, con la desventaja de que, claro, tener mucha más competencia. Distinto es el mundo de los desarrolladores para juegos de consola, que no solo a veces la misma empresa fabricante compite con el desarrollador, sinó que las consolas especiales para “constuir” el software de tal manera que la consola lo interprete…cuestan (y MUCHO). A pesar de esto, en el mundo de la X-Box 360 es un tanto distinto, ya que solo necesitamos un software que se instala en la consola, pagar una suscripción mensual (accesible, comparandola con el precio de alguna consola para desarrollo)…. En fin, tanto conocimiento…y tan poco tiempo…

Para ir terminando este post atrasado:

Si estás pensando hacer una empresa de Videojuegos…

  • Aprovechá los créditos que te puedan dar fondos como FonSoft.
  • Elegí bien tu equipo. No busques teams gigantescos con 133120 personas, que encontraste en un foro. Grupos extensos tienden a debatir tanto, que todo se diluye…y no se toman decisiones.
  • Y hay tantas otras cosas a tener en cuenta!… Para las cuales, si estás interesado, podés preguntar y aprender en el Foro de Codevisa o el de Adva :)

En fin, una excelente movida!

Ahora, por otro lado, gente de la UNL comentó que ya hay muchos inscriptos para la carrera, lo cual va a alimentar mucho la “masa crítica” necesaria para que, con el tiempo, ideas más “complejas” (como la realización de juegos “pesados”, tanto en guión como en desarrollo), puedan realizarse. Esperemos que si! ¿Qué mejor que un juego estilo WOW del Eternauta?

Se va la….tercera?

Continue reading »

Seguimos con los ejercicios en C! Continue reading »

Por ahi encontré viejos ejercicios de C que hice alguna vez, sobre matrices. Los voy a poner acá por si le sirve a alguien. quizá no sea la manera más óptima, pero bueno, aprendé (y enseñame). Parece que hacía dos métodos. Uno, el que uno aprende al principio, y otro, que quizás sea más óptimo. Puse un leer más porque sinó te asusto de lo feo que es mi código :) Actualización: Gracias a PyBalo, encontré unos errores en este código. Gracias PyBalo! Continue reading »

Veo que alguien / algunos buscaron y entraron a este blog por “Números a Letras” en Python.

La verdad es que no se a que se refieren, si es pasar el valor ascii de una letra a la letra en sí, o a otra cosa:

de todas formas, acá dejo algo que se puede hacer

Existe un método llamado “chr()”:

Help on built-in function chr in module __builtin__:

chr(…)
chr(i) -> character

Return a string of one character with ordinal i; 0 <= i < 256.

“Retorna una cadena de un carácter con un ordinal i; 0 <= i <256.”

y para el proceso inverso, tenemos “ord()”

Help on built-in function ord in module __builtin__:

ord(…)
ord(c) -> integer

Return the integer ordinal of a one-character string.

“Retorna el ordenal entero de una cadena de un caractér”

Sirve?

Aprendiendo Python, me topé con un ejercicio: Crear un Juego de la Vida. Ya escribí (poco y nada, más que nada escribí el código que utilicé para más o menos hacer algo en Python) sobre este tema, pero nunca di una pequeña introducción al tema.

Saco toda esta información de Wikipedia, por cierto.

Movimientos en el Juego de la Vida

It's Alive!

Dicen por allá en los 70 (allá por un 8 de Junio, Onganía es derrocado por….¿los mismos militares? ¿Argentina? ¿Lógica? ¿Hola? ¿Alguien?), un matemático crea este juego y lo publica en una revista de matemáticas, como las Hombre o Maxim, pero más interesantes (de paso, notaron el patrón de las tapas de esas revistas? podemos asumir que todas las tapas contienen elementos comunes: mujeres. Adicionalmente podemos asumir una posición x, y, z “similar” entre esos elementos: mostrando el culo, pero adicionalmente, casi siempre están en la misma posición x,y,z. Cada vez menos originalidad hasta para eso tenemos. Estos son tiempos tristes).

Luego de eso, genera un interes muy grande. Principalmente porque es un juego, y a los matemáticos les gustan los juegos. Y los desafíos (tanto como los culos visibles en revistas previamente mencionadas)

Lo interesante del asunto es que es un juego sin jugadores. Esto es: Solo se necesita el “estado” inicial, y luego listo, no se necesita más información (si te ponés pelotudo, seguramente podes decir “ah, pero -alguien- tiene que poner el estado inicial! hay jugadores!. Bueno, son las 03:10 am. y puedo decirte libremente que fuck-you.) No tiene nada que ver con que los matemáticos sean solitarios ni cartas blancas (cuack).

Existe un tablero de juego que, en el juego original, tenía proporciones infinitas (para ser menos complicado, ya vamos a ver por qué). En el mismo, se colocaban células (el juego tiene mucho que ver con lo que se denomina autómata celular) que, dado un estado inicial (el que no se pone solo, pero no hay jugadores, les juro), siguen unas sencillas reglas que hacen del juego algo totalmente maravilloso para observar.

El tablero, está dividido en celdas (como un tablero de ajedrez), y en cada celda puede haber (o no) una solo una célula (o pieza, como te guste).

Tablero de ajedrez

Asi, pero infinito, y las piezas no tienen jerarquia. Anarquismo Molecular!

Ahora bien, en ese tablero, puede haber células. En la celda donde se encuentre una célula, se tomará a esa celda como “viva”, mientras donde no haya una célula, esa celda será considerada “muerta”. El juego pierde la gracia cuando todas las celdas están muertas. La muerte no es divertida

Narigona? no. La muerte no es graciosa. Aunque tenga cara de...buitre? y un palito

Me gusta su sombrero.

Ahora, entenderlo es bastante sencillo. Uno solo tiene que establecer ese estado al principio y sentarse en su sillón / amante preferido. La ciencia hace el resto del trabajo

Las reglas base del juego de la vida (digo base porque después se fueron agregando más) son:

  • Regla de Nacimiento:
    • Una célula muerta resucita si tiene exactamente TRES vecinos vivos.
  • Regla de la Supervivencia:
    • Una célula viva permanece viva si tiene DOS o TRES vecinos
  • Regla de la Superpoblación:
    • Una célula muere o permanece muerta si tiene CUATRO o MÁS vecinos
  • Regla del asilamiento:
    • Una célula muere o permanece muerta si tiene MENOS de DOS vecinos

¿Vecinos? Si. Vecinos. ¿Vieron que antes dije que el juego estaba en un tablero con celdas? Supongamos que estamos analizando la celda que está en (4,4) (eso es una celda dentro de una matriz…o tablero, si querés llamarlo mas humanamente. El primer 4 indica que fila y el otro número que columna. Gente loca usa esto al revés. Pero yo soy normal, lo juro. Todos los chicos cool usan este sistema). Esa celda está (por si no leíste lo que staba entre paréntesis antes) en la fila 4 y la columna 4. ¿Dónde están los vecinos?. Bueno, suponiendo que nos basamos en el Wikicionario :

Habitante cercano, persona que vive en la casa de al lado

Podemos entonces entender que un vecino es, en este caso, todas las celdas próximas a la celda evaluada (me siento estúpido explicando esto. ¿Maté un pájaro con un misil?).

Entonces, podemos decir que cada celda, suponiendo que el tablero es infinito, tiene ocho vecinos, los cuales pueden estar vivos o muertos.

Suponiendo que me expliqué mas o menos de manera coherente con el tema de la celda (4,4), miren que lindo dibujé:

(3,3)    (3,4)    (3,5)

\     |     /

(4,3)    (4,4) (4,5)

/    |    \

(5,3)    (5,4)    (5,5)

Siendo la celda (4,4) la que se está evaluando, tiene ocho vecinos, los cuales son, de izquierda superior a derecha inferior

  1. (3,3)
  2. (3,4)
  3. (3,5)
  4. (4,3)
  5. (4,5)
  6. (5,3)
  7. (5,4)
  8. (5,5)

Ok, ahí tenemos todos los vecinos. Pero supongamos que no estamos evaluando el punto (4,4), sinó un (800,100), o algún número así de grande (no me estoy señalando nada al decir “así”). Es interesante usar esto de las letras en las matemáticas. Por si no notáste en los 8 renglones que desperdicié ennumerando los vecinos, podemos pasar todos los números a letras. Siendo esto mucho mas claro (y más sexy) para la comprensión.

Supongamos que en vez de decir (4,4), decimos (F,C), donde F es la variable que va a contener el número de FILAS, y C es la variable que va a contener el número de COLUMNAS. Supongamos que ahora no sabemos cuales son estos valores. El coso lindo que dibu-escribí antes, quedaría algo así

(F-1,C-1)    (F-1,C)    (F-1,C+1)

\      |      /

(F,C-1)    (F,C) (F,C+1)

/     |     \

(F+1,C-1)    (F+1,C)    (F+1,C+1)

Sexy. Como tódo lo lógico. De esta manera sin números. Se puede contemplar mejor, y además, además, ya tenés todo hecho para cuando tengas que programar todo eso. Me encanta.

OK. Perfecto. Ya tenemos las reglas y el tablero, ahora…a ponerle un poco de vida.

Teniendo esas reglas en mente, podemos empezar a poner situaciones iniciales. Gente claramente más inteligente que yo creo patrones, formas que pueden estabilizarce y quedarse indefinidamente “como están” sin modificaciones (a menos que sean alteradas por otra forma). Estas son las Still Lifes

Forma de Cubo en el Juego de la Vida

Este cubo es el ejemplo “clásico”. Algo totalmente estático (como verán, todas las celdas cumplen con la Regla de Supervivencia) y “estabilizado”, me atrevo a decir. Gente claramente más inteligente que yo y el que encontró este patrón encontró más patrones. Dígale NO a la Lucha de Clases

Realmente en el juego de la vida pueden pasar cosas muy divertidas, como por ejemplo este tablero, que se llama “Gospers Glider Gun”. Wow.

Lei  Gospel Glider Gun, me encantó

Leí "Gospel Glider Gun", me encantó

Me olvidaba algo importante. El tema de las generaciones. Cada generación es…cada “turno de juego”, la primera generación (la 0) comienza con la configuración inicial, se aplican las reglas…y se muestra la generación siguiente. Así hasta el infinito o hasta que no haya mas celdas vivas. Como verán, la Muerte sigue cortando el mambo.

Hasta acá viene bien. Pero ahora falta la parte Pythonera del asunto.

Sigo mañana, ya son casi las 5 y no dormí nada. Maldita Leche chocolatada.

Hacía mucho que tenía algo pendiente. Hacer un Juego con Pygame y Python. Si bien la creación de juegos no es algo que me vuelve loco (como dije en un post anterior, cada vez me siento más viejo, y alejarme un tanto del mundo gamer me esta llevando por ese camino, si bien uno nunca puede negar una buena partida de Unreal Tournament ’99 o Quake III… :P ), una linda forma de aprender a programar es haciendo juegos.

Dando vueltas por un buen blog sobre Python (que está en inglés, lamentablemente), encontré un interesante tutorial, sobre como hacer un juego (muy muy básico, aparentemente) con Python y Pygame.

Me propuse a seguirlo, y sacar algunos screenshots para ir mostrando lo que voy haciendo :)

Interesado en mi fotografía?, pasate por mi Tumblr :-) Suffusion WordPress theme by Sayontan Sinha