jueves, 22 de noviembre de 2012

jueves, 15 de noviembre de 2012

Imitación computacional de texturas naturales


La idea de la textura era hacer un cielo animado
el cielo seria un recorrido de colores
por ejemplo



en el programa hace un recorrido de azul dejando el texto en blanco
para la simulación o animación de estrellas

asi en la cadena de texto se le incluye un random que imprima un punto
y por lo tanto simulara una estrella



Simulación de las stars :P


Se alcanzan a ver muy leves los puntos


código


from Tkinter import *

def onclick():
   pass

root = Tk()
text = Text(root)
i=1
while i > 100:
   text.insert(INSERT, "       \n  ")
   i = i+1

#text.insert(END, "         .    ")
text.pack()
i=1
while i > 100:
   p=i+".0"

   text.tag_add("here", p, p)
   text.tag_config("here", background="blue", foreground="white")

    i=i+1

#text.tag_add("start", "2.0", "1.13")
#text.tag_config("start", background="darkcyan", foreground="white")


for i in range(100):
        x1=random.randint(1,100)
        y1=random.randint(1,100)
        ad.create_oval(x1, 10, y1, 10,width = 0, fill = white)


root.mainloop()


Este fue el primer código sin recorrido


from Tkinter import *

def onclick():
   pass

root = Tk()
text = Text(root)
i=1
#while i > 100:
text.insert(INSERT, "                                       .                    .                    . \n  ")
text.insert(INSERT, "      .            .               .  \n  ")
text.insert(INSERT, "          .                .                 .              .  \n  ")
text.insert(INSERT, "     .          .                         .      .   \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "  .      \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "               .                   .                    .   \n  ")
text.insert(INSERT, "             .    \n  ")
text.insert(INSERT, "      .                   .                  .                .  \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "  .     \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "    .   \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "      .  \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "        \n  ")
text.insert(INSERT, "       \n  ")
text.insert(INSERT, "        \n  ")
 #  i = i+1

#text.insert(END, "         .    ")
text.pack()
text.tag_add("here", "1.0", "2.0")
text.tag_add("here", "2.0", "3.0")
text.tag_add("here", "3.0", "4.0")
text.tag_add("here", "4.0", "5.0")
text.tag_add("here", "5.0", "6.0")
text.tag_add("here", "6.0", "7.0")
text.tag_add("here", "7.0", "8.0")
text.tag_add("here", "8.0", "9.0")
text.tag_add("here", "9.0", "10.0")
text.tag_add("here", "10.0", "11.0")
text.tag_add("here", "11.0", "12.0")
text.tag_add("here", "12.0", "13.0")
text.tag_add("here", "13.0", "14.0")
text.tag_add("here", "14.0", "15.0")
text.tag_add("here", "15.0", "16.0")
text.tag_add("here", "16.0", "17.0")
text.tag_config("here", background="blue", foreground="white")
#text.tag_add("start", "17.0", "18")
#text.tag_config("start", background="darkcyan", foreground="white")
#text.tag_add("start", "2.0", "1.13")
#text.tag_config("start", background="darkcyan", foreground="white")


for i in range(100):
        x1=random.randint(1,100)
        y1=random.randint(1,100)
        ad.create_oval(x1, 10, y1, 10,width = 0, fill = white)

root.mainloop()


Aportación Grupal


he estado investigando la interacción entre objetos y monos, restricciones
creando varias capas en el tmx y cada capa asignando valores

Ejemplo
este es una parte del código del juego


   LAYER_PISABLE = 0
    LAYER_SUELO = 1
    LAYER_OBJETOS = 2
    LAYER_OBJETOS_SUPERPUESTOS = 3
    LAYER_CIELO = 4



 def es_pisable(self,fila,columna):
        #si se intenta mover fuera del mapa, no se permite
        if ((fila >= self.height) or (fila < 0) or (columna >= self.width) or (columna < 0 )):
            return False
        else:
            return not (self.capas[Mapa.LAYER_PISABLE][fila][columna])

jueves, 8 de noviembre de 2012

Respuestas visuales, auditivos y táctiles

Arduino de toques

Como funciona?

A través de una resistencia que varia su valor dependiendo de la luz recibida, aprovecharemos dicha variación para hacer un programa que encienda o apague una serie de LED dependiendo de si hay más luz o menos luz,


Material necesario para este proyecto:
1 x Arduino Uno
1 x Protoboard
1 x LDR(Resistencia de luz)
1 x Potenciómetro 10kΩ
5 x Diodos LED
5 x Resistencias 220Ω
1 x Resistencia 1KΩ
1 x Cables
1 x Transformador




Esquema del circuito Eléctrico



Conexión en la protoboard


Programación


//Aquí almacenamos los datos recogidos del LDR:
int valorLDR = 0;

//Decimos que pines vamos a utilizar para LED
int pinLed1 = 12;
int pinLed2 = 11;
int pinLed3 = 10;
int pinLed4 = 9;
int pinLed5 = 8;

//Y que pin para la LDR
int pinLDR = 0;

void setup()
{
  //Establecemos como salida los pines para LED
  pinMode(pinLed1, OUTPUT);
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);

  //Le decimos que vamos a usar una referencia externa
  analogReference(EXTERNAL);

}

void loop()
{
  //Guardamos el valor leido en una variable
  valorLDR = analogRead(pinLDR);

  //Y comenzamos las comparaciones:
  if(valorLDR >= 1023)
  {
    digitalWrite(pinLed1, LOW);
    digitalWrite(pinLed2, LOW);
    digitalWrite(pinLed3, LOW);
    digitalWrite(pinLed4, LOW);
    digitalWrite(pinLed5, LOW);
  }
  else if((valorLDR >= 823) & (valorLDR < 1023))
  {
    digitalWrite(pinLed1, HIGH);
    digitalWrite(pinLed2, LOW);
    digitalWrite(pinLed3, LOW);
    digitalWrite(pinLed4, LOW);
    digitalWrite(pinLed5, LOW);
  }
  else if((valorLDR >= 623) & (valorLDR < 823))
  {
    digitalWrite(pinLed1, HIGH);
    digitalWrite(pinLed2, HIGH);
    digitalWrite(pinLed3, LOW);
    digitalWrite(pinLed4, LOW);
    digitalWrite(pinLed5, LOW);
  }
  else if((valorLDR >= 423) & (valorLDR < 623))
  {
    digitalWrite(pinLed1, HIGH);
    digitalWrite(pinLed2, HIGH);
    digitalWrite(pinLed3, HIGH);
    digitalWrite(pinLed4, LOW);
    digitalWrite(pinLed5, LOW);
  }
  else  if((valorLDR >= 223) & (valorLDR < 423))
  {
    digitalWrite(pinLed1, HIGH);
    digitalWrite(pinLed2, HIGH);
    digitalWrite(pinLed3, HIGH);
    digitalWrite(pinLed4, HIGH);
    digitalWrite(pinLed5, LOW);
  }
  else
  {
    digitalWrite(pinLed1, HIGH);
    digitalWrite(pinLed2, HIGH);
    digitalWrite(pinLed3, HIGH);
    digitalWrite(pinLed4, HIGH);
    digitalWrite(pinLed5, HIGH);
  }

}


En el programa se lee el valor del sensor
Si el valor es mayor o igual a 1023 no se activa ninguna salida
Si el valor es mayor o igual a 823 se activa una salida
Si el valor es mayor o igual a 623 se activan dos salidas
Si el valor es mayor o igual a 423 se activan tres salidas
Si el valor es mayor o igual a 223 se activan las 4 salidas

Aqui se realizo primero con leds, según el sensor detecte proximidad se empezaran a encender los led
una vez funcionando solo es cuestión de quitar los leds y poner el transformador

básicamente simularíamos las maquinitas de toques, donde los leds serian el regulador(potencio metro) y el transformador para dar una descarga fuerte

Aqui un diagrama no muy complejo

Ejemplo del funcionamiento en arduino







Aportación al proyecto
En esta parte se siguen incorporando mas mapas ya que se a tenido muchos problemas en la carga del juego ya que aveces no detecta las rutas de las imágenes aunque estén en la misma carpeta

también se están descargando mas sprites y personajes




Para la interacción con el jugador
Con los compañeros ya se acordó que se hiciera un movimiento random de los personajes y que al acercarse a ellos se pueda interactuar 


jueves, 1 de noviembre de 2012

Cuestiones de usabilidad en sistemas inteligentes



Ingeniería de usabilidad para la Web adaptable

http://www.springerlink.com/content/c87l5h7872762163/fulltext.pdf

Primero que es usabilidad?

Podemos definir la usabilidad como la medida en la cual un producto puede ser usado por usuarios específicos para conseguir objetivos específicos con efectividad, eficiencia y satisfacción en un contexto de uso especificado

La usabilidad, hace referencia, a la rapidez y facilidad con que las personas llevan cabo sus tareas propias a través del uso del producto objeto de interés, idea que descansa en cuatro puntos:

  • Una aproximación al usuario: Usabilidad significa enfocarse en los usuarios. Para desarrollar un producto usable, se tienen que conocer, entender y trabajar con las personas que representan a los usuarios actuales o potenciales del producto.
  • Un amplio conocimiento del contexto de uso: Las personas utilizan los productos para incrementar su propia productividad. Un producto se considera fácil de aprender y usar en términos del tiempo que toma el usuario para llevar a cabo su objetivo, el número de pasos que tiene que realizar para ello, y el éxito que tiene en predecir la acción apropiada para llevar a cabo. Para desarrollar productos usables hay que entender los objetivos del usuario, hay que conocer los trabajos y tareas del usuario que el producto automatiza, modifica o embellece.
  • El producto ha de satisfacer la necesidades del usuario: Los usuarios son gente ocupada intentando llevar a cabo una tarea. Se va a relacionar usabilidad con productividad y calidad. El hardware y el software son las herramientas que ayudan a la gente ocupada a realizar su trabajo y a disfrutar de su ocio.
  • Son los usuarios, y no los diseñadores y los desarrolladores, los que determinan cuando un producto es fácil de usar.


¿Por qué es importante la usabilidad?

El establecimiento de unos principios de diseño en ingeniería de usabilidad han tenido como consecuencia probada:


  1. Una reducción de los costes de producción: los costes y tiempos de desarrollo totales pueden ser reducidos evitando el sobre diseño y reduciendo el número de cambios posteriores requeridos en el producto.
  2. Reducción de los costes de mantenimiento y apoyo: los sistemas que son fáciles de usar requieren menos entrenamiento, menos soporte para el usuario y menos mantenimiento.
  3. Reducción de los costes de uso: los sistemas que mejor se ajustan a las necesidades del usuario mejoran la productividad y la calidad de las acciones y las decisiones. Los sistemas más fáciles de utilizar reducen el esfuerzo (stress) y permiten a los trabajadores manejar una variedad más amplia de tareas. Los sistemas difíciles de usar disminuyen la salud, bienestar y motivación y pueden incrementar el absentismo. Tales sistemas suponen pérdidas en los tiempos de uso y no son explotados en su totalidad en la medida en que el usuario pierde interés en el uso de las características avanzadas del sistema, que en algunos casos podrían no utilizarse nunca.
  4. Mejora en la calidad del producto: el diseño centrado en el usuario resulta en productos de mayor calidad de uso, más competitivos en un mercado que demanda productos de fácil uso.


¿En qué momento se ha de considerar la usabilidad?

La usabilidad debería ser considerada en todo momento, desde el mismo comienzo del proceso de desarrollo hasta las últimas acciones antes de hacer el sistema, producto o servicio disponible al público.

Antes de iniciar el proyecto es esencial tener una idea acerca de las características de los usuarios y de los aspectos del producto de mayor interés y necesidad. Teniendo en cuenta estas consideraciones de forma temprana se ahorra tiempo y dinero, dado que la posterior implementación de nuevos aspectos o nuevas interfaces de usuario implican un enorme esfuerzo adicional. Incluso una vez que el producto está en el mercado se debería preguntar a los usuarios acerca de sus necesidades y actitud respecto del mismo.


Usabilidad web

Un sitio web con usabilidad es aquél que muestra todo de una forma clara y sencilla de entender por el usuario. Aunque es imposible crear un sitio que sea claro y eficiente para cada usuario, el diseñador debe esforzarse para mostrar las cosas tan claramente como sea posible, de tal modo que reduzca al mínimo cualquier aspecto que pueda ser confuso.

Yendo un paso más adelante, el pensar en los errores que pueden ocurrir cuando un usuario está interactuando con un sitio web y desarrollar maneras inteligentes de manejar estos errores se llama diseño de contingencia, y juntos diseño de usabilidad y de contingencia pueden dar lugar a un usuario satisfecho con su experiencia en un sitio web.


Para ello se deben hacer estudios de las personas que van a utilizar el sistema

Por ejemplo

Si se va a crear una página para niños, el contenido de la página debe de ser muy llamativo para que al niño le provoque un interés

Otro ejemplo seria paginas para adultos, ya que algunos cuentan con problemas visuales, esto se soluciona con iconos muy grandes, que es lo que está pasando en la actualidad, todo es icono y lo más grande posible y entendible


Todo esto no se puede incorporar a la vez por que como el usuario puede ser sordo, mudo, ciego, daltónico, etc, nunca vas a satisfacer a todos los usuarios a la vez

Entonces tienes que crear el entorno lo más aceptable posible


Resumen. El documento describe un enfoque de usabilidad para el diseño
y la evaluación de los sistemas adaptativos basados en páginas web, centrándose en cuestiones prácticas.
Se presentará una lista de métodos, teniendo en cuenta un enfoque centrado en el usuario.
Después de haber introducido las peculiaridades que caracterizan a la evaluación de la adaptación de sistemas basados en Web, el capítulo describe las metodologías de evaluación siguiendo
las fases temporales de la evaluación, según un enfoque centrado en el usuario. Tres
fases se distinguen: fase de requisito, la fase de evaluación preliminar, y fase de evaluación de la final.
Además, cada técnica es clasificada según un conjunto de parámetros resalte la explotación práctica de esta técnica.
Para cada fase, se describen las técnicas adecuadas, dando ejemplos prácticos de
su aplicación en la web adaptable. Una serie de cuestiones que se plantean cuando se describen un sistema adaptativo, y posibles soluciones


Aporte grupal

Ahora toco Re-diseñar los mapas e incorporarlos al juego
con sus respectivas restricciones






miércoles, 24 de octubre de 2012

Movimiento natural de modelos

Seguir objeto en blender

Para el seguimiento se creo un objeto path el cual sera el riel o el patrón a seguir de la cámara

para el seguimiento en juego se me ocurría usar el modo de juego de mario o call of duty en el cual si vas avanzando que las propiedades de la cámara sean back(código)  esto es que la cámara este detrás del personaje, si llega a topar/interactuar con algún objeto, que realice el recorrido de la piedra hasta quedar en una posición donde se logra ver al personaje y al objeto




Les dejo el link por si quieren descargar mi piedra con recorrido de cámara

http://www.mediafire.com/?c1xbb9nhp4slgma

Aquí un vídeo de como la cámara sigue el vector


Aporte Grupal

Mi parte era crear algunos mapas nuevos

aquí les dejo unas imágenes
para descargarlos están en el grupo de Facebook

Otro



jueves, 18 de octubre de 2012

Modelado tridimensional de objetos

Modelado de objetos


En este caso se modelo una montaña de piedras que puede servir como obstrucción  ambientación o recurso para el personaje en el juego 
A continuación la piedra terminada
En diferentes ángulos 




Esta fue la primera piedra modelada
y ya solo se crearon algunas mas para encimarlas



Aportación del juego

Incorporar blender en el mapa (tmx) del juego

Basicamente .tmx no es más que un archivo XML que contiene todo los datos de nuestro mapa. Solo deberemos leer el archivo XML desde nuestro juego (casi todos los lenguajes tienen bibliotecas para trabajar con XML) y usar los datos como creamos convenientes

También les dejo unos recursos de piedras en tmx :D

Aquí les dejo una pagina para poder hacer objetos para el mapa 2D y algunos ejemplos
http://razonartificial.wordpress.com/category/recursos/

jueves, 11 de octubre de 2012

Gráficas Computacionales


Bucket Fill


El bucket fill hace un recorrido  en este caso esta rellenando una figura de un color, es parecida a la cubetita del paint
El recorrido seguirá hasta que se tope con algún color diferente y entonces  deja de colorear 

Una pequeña imagen

Este es el código con algunos comentarios
que pueden remplazar algunas partes o si lo toman como ayuda tal vez les pueda funcionar



  1. from Tkinter import *
  2.  
  3. class PaintBox( Frame ):
  4.    def __init__( self ):
  5.       Frame.__init__( self )
  6.       self.pack( expand = YES, fill = BOTH )
  7.       self.master.title( "BuketFile :D" )
  8.       self.master.geometry( "500x250" )
  9.  
  10.       self.message = Label( self, text = "Presiona para colorear la figura" )
  11.       self.message.pack( side = BOTTOM )
  12.      
  13.       # crea Canvas
  14.       self.myCanvas = Canvas( self )
  15.       self.myCanvas.pack( expand = YES, fill = BOTH )
  16.  
  17.       # dibuja evento de Canvas
  18.       self.myCanvas.bind( "<B1-Motion>", self.paint )
  19.       self.myCanvas.create_oval( 10,10, 100,100, fill = 'gray' )
  20.       self.myCanvas.create_rectangle( 300,200, 100,100, fill = 'gray' )
  21.      #buket()
  22.      
  23.  
  24.    def paint( self, event ):
  25.       x1, y1 = ( event.x - 4 ), ( event.y - 4 )
  26.       x2, y2 = ( event.x + 4 ), ( event.y + 4 )
  27.       #if x1 ==10 and y1==10:
  28.       for x1 in range(100):
  29.          for y1 in range(100):
  30.             self.myCanvas.create_rectangle( x1, y1, x2, y2, fill = "red")
  31.        #while event.x > 0:
  32.         #    x1++
  33.          #   while event.y > 0:
  34.           #     y1++
  35.                
  36.  
  37.    #def floodfill_queue(self, target, repl):  
  38.     #if target != self.color:  
  39.      #   return  
  40.  
  41.     #q = [self]  
  42.     #while q:  
  43.         #n = q.pop(0)  
  44.         #n.color = repl  
  45.         #for x in [n.west(), n.east(), n.north(), n.south()]:
  46.             #if x.color == target:  
  47.                 #x.color = repl  
  48.                 #q.append(x)        
  49.    #def buket(self,event):
  50.     #  if event.x ==10 and event.y==10:
  51.      #    while event.x > 0:
  52.       #      while event.y > 0:
  53.        #         paint()
  54.        
  55.    
  56. def main():
  57.    PaintBox().mainloop()
  58.  
  59. if __name__ == "__main__":
  60.    main()

Aporte al Juego


Este juego me pareció muy interesante 
ya que lo que vamos a hacer es muy parecido y podría ayudarnos a mejorar mucho
nuestro juego


También trataremos de tomar algunas ideas que se nos puedan olvidar
o poder aportar ideas a ellos para que su juego pueda mejorar mas

Otro también seria este videojuego en 3D ya que aporta algo de física
tanto interacción con los objetos como saltos y cosas parecidas


.