Proyecto Final

PROYECTO FINAL

• Descripción del Proyecto

Para esta última entrega damos por concluido nuestro proyecto el cual consistió como ya se había mencionado de un juego sencillo de guerra, las caracterísiticas principales del juego son:

• Juego tipo Uniwars uno contra uno por turnos.
• El objetivo del juego es destruir la base del rival.
• El juego cuenta con un mapa.
• Las unidades del juego son soldados.
• Cada soldado tiene un porcentaje de vida del 100% dividido en cuatro partes que se restarán de 25% en 25%.
• Tablero similar al de ajedrez pero constituido por montañas, bases etc.

La parte adaptativa consiste en que el rival se adapte a los movimientos y la forma de jugar del usuario. Que al momento de que el jugador termine su turno el agente haga su movimiento.

El juego esta programado en Java junto con programación en Jade, se ha utilizado 7 clases principales que contienes lo que son menu, JFrames, JPanel encargados de la interfaz asi como tambien incluye el menu principal donde se incluye las librerias de Jade.

• Módulos más relevantes

Hay tres clases mas que son importantes ia que refieren a los agentes, estos agentes se turnan en cierto tiempo para realizar sus funciones en el campo de juego.

• Herramientas y Técnicas

• JADE (Java Agent Development Framework)
• Eclipse
• Netbeans

• Lógica y Ambiente del Juego

5 agentes para el funcionamiento del contrincante (máquina).

5 agentes para el funcionamiento del jugador.
Matriz realizada de 15*8
Movimiento por medio de Cliks
El juego consiste en conquistar la otra base y los movimientos seran a base de turnos.

• Demostración

Reporte 3 "Sistemas Inteligentes"

Indicaciones

Ingresa a http://en.wikipedia.org/wiki/Perceptron y modifica el código para el caso de “and”. Modifica los pesos iniciales, la tasa de aprendizaje y el umbral.

• Código Original de la página

• Ejecutándolo

• Código Modificado

• Ejecutándolo

Reporte #4 Multiagentes

REPORTE  #4  - MULTIAGENTES

JADE

Programar un agente JADE consiste en:

·         Definir una clase Java que representa al agente (la cual debe heredar de la clase jade.core.Agent).

·         Implementar los comportamientos que va a manisfestar.

Un agente JADE cumple las siguientes características:

• El método protegido setup() sirve para inicializar el agente incluyendo instrucciones que especificarán la ontología a utilizar y los comportamientos asociados al agente. Se invoca al comenzar la ejecución del agente.

• El método protegido takeDown() sirve para liberar recursos antes de la eliminación del agente. Este método es invocado cuando se realiza una llamada al método doDelete(), que es el que realmente da por finalizada la ejecución del agente.

• Ambos métodos deben ser sobreescritos.

El ciclo de vida de un agente JADE sigue el ciclo propuesto por FIPA, es decir, cumple con la propuesta del estándar de interoperabilidad entre agentes más aceptado.

·         Tiene un nombre único en el entorno de ejecución.

·         Se implementa como un único hilo de ejecución (single-threaded).

·         Tiene un metodo de inicio (setup) y otro de fin (takeDown).

·         En su implementación se define una clase interna por cada uno de los comportamientos asociados al agente. Estos comportamientos se utilizan básicamente para el envío y recepción de mensajes, aunque también se pueden utilizar para realizar otras tareas

Un agente está sujeto a un ciclo de vida en el que se definen los estados en los cuales se puede encontrar el agente, así como los cambios que se pueden realizar entre los diferentes estados.

Estados de un Agente

Un agente puede estar en los siguientes estados:

• ·         Iniciado: El objeto Agente está creado pero todavía no se ha registrado en el AMS, no tiene nombre ni dirección y tampoco se puede comunicar con otros agentes.
• ·         Activo: El Agente está registrado en el AMS, tiene un nombre, una dirección y puede acceder a todas las opciones de JADE.
• ·         Suspendido: El Agente está parado. Su hilo de ejecución está detenido y no ejecuta ningún Comportamiento.
• ·         En espera: El Agente está bloqueado esperando por algo. Su hilo de ejecución está dormido en un monitor de java y se despertará cuando se cumpla una cierta condición (cuando reciba un mensaje).
• ·         Desconocido: El Agente ha sido eliminado. El hilo de ejecución ha terminado y se ha eliminado del registro del AMS.
• ·         Tránsito: Un Agente móvil entra en este estado mientras está migrando a una nueva localización. El sistema sigue guardando los mensajes en el buffer hasta que el agente vuelve a estar activo.

SPADE

Es una plataforma libre de sistemas multi-agente desarrollada en Python y basada en la tecnología de mensajería instantánea XMPP(Extensible Messaging and Presence Protocol, más conocido como XMPP(Protocolo extensible de mensajería y comunicación de presencia)).

La plataforma SPADE son: soporte de organizaciones virtuales, notificación de presencia, compatible con FIPA e independencia del lenguaje y la plataforma. La plataforma nació para probar la tecnología de la mensajería instantánea como protocolo de transporte para los agentes inteligentes.

Características

Las principales características de la plataforma SPADE son:

• Soporte del estándar FIPA mediante el protocolo de mensajería instantánea XMPP (Agentes AMS y DF incluidos)
• Notificación de presencia entre agentes.
• Procesadores de lenguajes de contenido en SL0 y RDF.
• Modelo de agente BDI basado en Conocimiento, Deseos e Intenciones.
• Modelo de comportamientos: Cíclicos, Periódicos, Timeout, una ejecución, máquina de estados finita y basado en eventos.
• Interfaz gráfica basada en web.

Interfaz Gráfica

La interfaz gráfica está basada en HTTP

Las características de la interfaz son las siguientes:

• La plataforma y los agentes exportan su propia interfaz web.
• La interfaz es configurable a través de plantillas.
• Cada agente exporta su identificador como un código QR.
• Instrospector de agente.
• Visor de mensajes enviados.
• Búsqueda de agentes y servicios.

MaDKit

MaDKit es un código abierto plataforma Multiagentes modular y escalable escrito en Java y construido sobre la AGR (agente / grupo / rol) modelo organizativo:

Agentes MaDKit desempeñar funciones en grupos y así crear sociedades artificiales.

MaDKit es software libre licenciado bajo la GNU GPL que incluye:

- Agentes de la creación artificial y la gestión del ciclo de vida

- Una infraestructura organizativa para la comunicación entre los agentes

- Alta heterogeneidad en las arquitecturas de agentes: No hay un modelo predefinido agente

- Multi-Agente de simulación basado en simuladores y herramientas de autoría

- Multi-agente distribuida basada en servicios de aplicaciones de edición

MaDKit 4 viene con un conjunto completo de servicios y agentes para el lanzamiento, presentación, desarrollando y seguimiento de los agentes y organizaciones.

El agente diseñador es un buen punto de partida para iniciar un nuevo proyecto en MaDKit .. Este agente es joven... Pero muy prometedor...

MaDKit viene con un conjunto de herramientas que pueden ser utilizadas para ayudar al desarrollo de aplicaciones Multiagentes.

o    Agente Diseñador: ayudar a la creación de un nuevo proyecto. Comience con ella, y luego construir su proyecto MadKit ...

o    Agentes del sistema: estas son las principales herramientas que el uso revelador MadKit para explorar, poner en marcha, visualizar y localizar los agentes.

o    Communicator: un agente que permite construir aplicaciones distribuidas sin preocuparse por la distribución ..

o    NetCom: una versión más nueva, más flexibles y más adaptables del agente Communicator. (documentación no está disponible aún)

o    ProjectBuilder: cómo crear, editar y crear un nuevo proyecto en MadKit (esta función no está disponible aún)

o    jSynEdit editor: un "agentified" versión de un pequeño editor con funciones coloreado de sintaxis que tiene la abeja integrada en MadKit y puede ser usado para editar y ejecutar Java y agentes de secuencias de comandos.

o    SEdit es a la vez un editor y animación de diagramas que se pueden utilizar para ver y manipular la información representada en forma de gráficos. SEdit está ahora totalmente integrado a MadKit y por lo tanto el manual necesita una pequeña actualización .. Pero, aun así, ofrece una gran cantidad de información útil.

o    PluginManager: MadKit viene con su propio instalador que puede ser utilizado para instalar, actualizar y MadKit taylor a sus necesidades.

El modelo AGR esta basado en las nociones de Agente, Grupo y Rol.

Agente

Es una entidad capaz de comunicar atreves de los roles que juegan en los diferentes grupos

Grupo

Role

ESTRUCTURA GENERAL DE LA PLATAFORMA

El componente principal es el Kernel (o micro-kernel). El kernel provee soporte para:

Control de grupos y roles locales

Manejo del ciclo de vida de los Agentes

Despacho de Mensajes locales

RoboCup Soccer Simulation League

La RoboCup es una iniciativa de investigación y educación en torno a una competición en la que pueden integrarse diferentes tecnologías. Promueve la investigación en robótica e inteligencia artificial.

Tal y como puede leerse en la web oficial de este proyecto " El objetivo último del proyecto es desarrollar para la RoboCup 2050 un equipo de robots humanoides completamente autónomos que sean capaces de ganar al equipo humano campeón del mundo de fútbol." 

RoboCup Fútbol

La RoboCup fútbol es una competición de fútbol entre robots. Esta se desarrolla en diferentes categorías:

• Liga en simulador: una plataforma de investigación para sistemas multiagente e inteligencia artificial
• Liga en tamaño pequeño: dos equipos de 5 pequeños robots (han de caber en una circunferencia de 180 mm de diámetro) se enfrentan utilizando cámaras sobre el mismo robot o sobre el campo.En esta categoría los sobots pueden comunicarse con un ordenador externo.
• Liga en tamaño medio: robots de tamaño medio con funcionamiento totalmente autónomo
• Liga con plataforma estándar: todos los equipos utilizan robots idénticos. Actualmente la plataforma es el robot NAO de Aldebaran.
• Liga humanoide: robots humanoides 100% autónomos con tamaños comprendidos entre 30 y 160 cm.

RoboCup Rescate

• Liga en simulador: El rescate en simulador es una nueva área de experimentación en la RoboCup. Su objetivo principal es proporcionar soporte en situaciones de emergencia por medio de la integración de información sobre desastres, predicción, planificación y la interfaz humana.
• Liga de robots: Esta prueba de rescate con robots tiene como objeto fomentar la investigación en torno a la respuesta a situaciones de emergencia.

RoboCup Junior

RoboCup Junior es un proyecto educativo dirigido a jóvenes estudiantes de hasta 19 años de edad. Su objeto es educativo y está diseñado para introducir la RoboCup en la enseñanza primaria y secundaria. En los diferentes retos hay dos categorías, la primera hasta 14 años y la segunda de 14 a 19. En esta modalidad de la RoboCup hay tres retos diferentes:

• Futbol
• Rescate 
• Danza

Referencias:
http://programacionjade.wikispaces.com/Agentes
http://www.madkit.net/api/madkit5/overview-summary.html
http://sebastian.rodriguez.free.fr/index.php/7-primeros-pasos-con-madkit.html
http://lrobotikas.net/es/competicion/43-robocup/81-robocup1
https://code.google.com/p/spade2/
http://es.wikipedia.org/wiki/SPADE

Unidad 2 Algoritmos Adaptativos

REPORTE 2 - RED COMPLEJA

Para el desarrollo de este reporte hicimos uso de una red compleja, la cual fue analizada en su forma de matriz adyacencias, que es la siguiente:

0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 
1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 
1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 
1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 
0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0

Genera un programa que obtenga la distribución de grado y la densidad de la red. Gráfica la distribución de grado (esto puede ser de manera manual). Hint: Utilizar lenguajes script puede facilitar la programación. Extra: agrupa la red.

Codificación - Python

Primero se obtiene la distribución de grado de la red, para ello sacamos el grado de cada reglón o columna:

  linea[l] = f.readlines()[l]
  numeros = [int(x) for x in linea[l].split()]
  for i in numeros[1:]:
            total[l] = total[l] + i
  print"EL grado de la linea ", l+1, "es: ", total[l]

Esto se realizo desde un archivo de texto, el cual contiene la matriz. 

Los resultados obtenidos fueron:

 Después de obtener el grado de cada reglón o columna, agruparemos los vértices que tengan el mismo valor de grado, para poder realizar la distribución:

for i in range(0,33):
    for j in range(0,33):
        if total[i] == j:
            K[j] = K[j] + 1

Después se obtiene la distribución de grado dividiendo la agrupación de los grados en la parte anterior entre el numero total de conexiones, esto se realizo en la siguiente fracción de código.

for i in range(0,33):
    distribucion[i] = K[i]/33.0

for i in range(0,33):
        if K[i] != 0:
            print  "K= %.f"%K[i], "la distribucion de grado Pr(K) es:",float(distribucion[i])

y el resultado es:

Densidad Para obtener la densidad de la Red se aplica la formula:

Con este código se busca primero las variables a usar en la formula, en este caso n ya esta definida por el total de columnas que es 33. 

for i in total:
    m = m + i

Luego calculamos la densidad aplicando la formula ya conocida, e imprimiendo el valor obtenido.

D = (2 * m) / (n*(n-1))
print "La densidad es: ", float(D)

El Resultado es el siguiente:

Gráfica de la Distribución de grado

Aquí se muestra la gráfica de los resultados de la distribución de grados, con la tabla de la agrupación de cada grado que se obtuvo. 

Unidad 1 Algoritmos Adaptativos

REPORTE 1 - Ventilador

Para el desarrollo del programa del ventilador. Se realizo este código que muestra corridas donde se ve el auto-ajuste.

Objetivo:

Nuestro objetivo en esta practica sera hacer una recreación de un ventilador que se auto ajustara según la temperatura del ambiente

Desarrollo:

Aquí se muestra Código dispensable para el funcionamiento

Clase Ventilador

Muestra el inicio del programa y que contendra el main

public class Ventilador {
    public static void main(String[] args) {
       SimTemp.main(args);
    }

Clase SimTemp

En esta Clase concentra los hilos temp y termo, iniciara el hilo termo con su función .start();

 public class SimTemp{

    public static void main(String[] args){
        HiloTemperatura temp=new HiloTemperatura();
  
        HiloTermometro termo =new HiloTermometro();
        termo.start();
    }
}

Clase HiloTermometro

Clase que dirigirá e iniciara los números aleatorios en la temperatura tendrá un inicio desde -2 hasta 50 grados que llega la zona de monterrey, también asignara un cierto tiempo antes de que se produzca un numero aleatorio entre otros, y se ubica el contenido del hilo HiloTermometro.

public void run(){
  try{
   while(true){
    Termometro=generaNumAleatorio(-10,50);
    SensacionTermica();
    System.out.println("\nLa temperatura es: "
                                        +Termometro+"\nSe siente "
                                        +LETRERO[termo]);
                                HiloTemperatura ht = new HiloTemperatura();
                                ht.ajustaEstadoVenti(termo,Termometro);
    sleep(4000);
   }
  }
  catch(InterruptedException e){
   System.out.println("Exception: "+e.getMessage());
  }
 }

Clase HiloTemperatura

La ultima Clase utilizada se enfoca en asignar y preparar la función del abanico en encendido y apagado así como también su velocidad de funcionamiento.

public void ajustaEstadoVenti(int termo,int temperatura){
        if(termo==0){
            estadoVenti=0;
        }
        else{
            estadoVenti=1;
            if(temperatura>=29){
                velocidad=3;
            }
            else{
                if(temperatura>24&&temperatura<29){
                    velocidad=2;
                }
                else{
                    velocidad=1;
                }
            }
        }
        impriEstadoVenti();
    }

Resultados

Tercer Entrega del Proyecto

• Resumen del Proyecto

EL PROYECTO SERÁ UN JUEGO QUE SERÁ CONTRA LA MAQUINA IA, QUE FUNCIONARA CON INTELIGENCIA ARTIFICIAL, SERÁ EL JUEGO POR TURNOS, SERÁ DE DOS JUGADORES UNO CONTRA OTRO (UNO COMANDADO POR LA IA), EL OBJETIVO PRINCIPAL SERÁ DESTRUIR LA BASE DEL CONTRARIO, LA IA SE ADAPTARA A LA FORMA DE JUEGO. CONSTARA DE UN TABLERO EL CUAL SERA SIMILAR AL DE UN JUEGO DE AJEDREZ, PERO QUE ESTARÁ CONSTITUIDO POR MONTAÑAS, CAMPO ABIERTO Y ALGUNOS EDIFICIOS EN EL QUE EL USUARIO Y IA MOVERÁN SUS UNIDADES PARA LLEGAR A LA BASE ENEMIGA. 

LAS UNIDADES (SOLDADOS) SERÁN ASIGNADAS AL INICIAR CADA PARTIDA, SE PODRÁ ESCOGER LA CIVILIZACIÓN QUE GUSTE PARA EL USUARIO Y TAMBIÉN PARA LA MAQUINA IA. TAMBIÉN SE PODRÁN ADQUIRIR NUEVAS UNIDADES A CONFORME VAYAN PASANDO LOS TURNOS Y OBTENIENDO PUNTOS POR CADA TURNO.

LA MODIFICACIÓN QUE SE LE HIzO en la entrega pasada ES QUE SOLO SERA DE DOS NIVELES QUE SERIA EL NORMAL Y EL DIFÍCIL, TAMBIÉN QUE SUS ESCENARIOS SERÁN CLASIFICADOS COMO GRANDES, MEDIANO Y PEQUEÑO Y SE MOVERÁN POR BLOQUES CON SU RESPECTIVO LIMITE DE CADA UNIDAD POR TURNO.

En esta entrega tenemos la codificación del diseño de la presentación del juego y el mapa que utilizaremos, posiblemente puedan ser varios mapas dependiendo de como nos vayamos desenvolviendo en el transcurso del desarrollo del juego, también ya tenemos planificado la lógica que utilizaremos y las reglas establecidas del juego ya que queremos que sea un juego sencillo y quitaremos algunas de las características que tienen los juegos ya más desarrollados ya que eso implicaría más tiempo y no queremos un juego que se tome tiempo en entender o aprender a jugar.

• Avance con Respecto a la Planeación

¿Qué se ha hecho?

Se a realizado varias clases con respecto a parte de la interfaz gráfica, edición de imágenes y ventanas las cuales nos servirán para representar mejor nuestra funcionalidad del juego, también nos hemos podido enfocar mas en el área inteligente la cual se realizo con ayuda de la librería JADE que ocuparemos lo que resta del proyecto para el manejo de Agentes Inteligentes.  Se a podido investigar mas a fondo sobre este tema y buscar mas tutoriales y ejemplos referentes al uso de Agentes Inteligentes.

¿Qué falta?

Falta gran parte de la programación centrada a lo visual, y un poco a lo adaptativo ya que al tener codificado una parte del manejo de agentes, se podrá codificar con mayor facilidad los otros personajes y parte de la maquina para que pueda ser competencia contra el usuario.

  

¿Qué problemas se han presentado y cómo los has resuelto / piensas resolverlos?

Se han presentado principalmente el problema de no saber usar o conocer sobre los Agentes Inteligentes, pero por ello nos enfocamos en buscar información sobre su uso y buenos tutoriales para mejorar nuestro manejo de ellos. El tener poca experiencia con este tema, nos hace ir un poco mas lentos pero como mencionamos gracias a información encontrada se ha podido realizar un avance lo cual nos a aclarado en que podemos enfocarnos mas para seguir con el proyecto.

• Lista actualizada de Recursos y Herramientas

El esta entrega presentamos una lista actualizada de recursos y herramientas de lo que hemos investigado conforme a nuestro proyecto, como nuestro proyecto es un juego tipo ‘’Age of Empires’’ pero más sencillo, siguiendo la idea de este juego y analizando los aspectos clave o importantes, nos dimos cuenta que vamos a tener que utilizar o nos ayudaría considerablemente lo que son los ‘’Agentes’’ y ‘’Multiagentes’’ a parte de que ya nos habían advertido que seguramente tendríamos que enfocarnos a estudiar ese tema porque lo utilizaríamos.

Las Librerias que se estan utilizando son las de JADE. 

• http://jade.tilab.com/

Nos has funcionado bastante bien, ya que en la misma libreria almacena algunos ejemplos de manejo de Agentes, los cuales nos sirvieron mucho. Aunque no sabemos manejarlas a la perfección aun.

Basándonos en el juego de MarioIA por su uso de Agentes Inteligentes:

• http://www.it.uc3m.es/jvillena/irc/practicas/11-12/03mem.pdf

Algunas de las características de los agentes inteligentes con las que tenemos que trabajar más son:

•     Control del entorno
•     Punto de vista incompleto

      
      Hay tutoriales que nos están ayudando mucho como estos:

• Java Game: http://thenewboston.org/list.php?cat=30
• Intermediate Java: http://thenewboston.org/list.php?cat=25

Hemos estado investigando diferente tipo ideas, aún tenemos que orientarnos en algunos aspectos ya que pensamos que podríamos batallar con algunas cosas. 

• Primera Versión del Sistema

Aquí mostramos parte del código que se utilizara para el funcionamiento de nuestro juego, en este manejamos Agentes Inteligentes. Los cuales tendrán un comportamiento el cual se accionara en cada uno de los movimientos de el contrincante del usuario (Maquina IA).

La siguiente Clase (RobotIA1.java) contiene entre sus elementos el Setup() y el takedown() para iniciar con los comportamientos:

import jade.core.Agent;
import jade.core.behaviours.Behaviour;

public class RobotIA1 extends Agent{
 private Behaviour comp;
 private int VidaRobot = 100;
 
 protected void Setup(){
  System.out.println("El Robot enemigo es GunLeon#1!
  + getAID().getName());
  comp = new comportamientoR1();
  addBehaviour(comp);
 }
 protected void takeDown(){
  //Codigo para desaparecer el robot del campo...
        System.out.println("El Enemigo ha sido Destruido!");
    }

El Robot constara de una vida de 100% la cual al recibir 4 ataques (25% cada ataque) el Robot sera destruido y eliminado del mapa (takeDown())
La siguiente fracción de código muestra el primer comportamiento del Agente Inteligente (RobotIA) el cual se refiere al movimiento del Robot después del termino del turno del jugador, al terminar este comportamiento manda a llamar al segundo comportamiento del Robot:

private class comportamientoR1 extends Behaviour{
  public void onStart(){
   System.out.println("Turno de la MaquinaIA");
  }
  public void action() {
   //Codigo de movimiento del Robot en el campo
   System.out.println("El Robot1 Enemigo se mueve...una celda en el campo");
   myAgent.addBehaviour(new comportamientoR1_2());
   //Codigo para cuando termine el turno de la MaquinaIA 
  }
  public boolean done() {
   return true;
  }
 }

El movimiento sera en una matriz que se generara con imágenes para formar el campo de batalla.
Por ultimo, esta el segundo comportamiento del agente, el cual realizara el ataque si el enemigo de este se encuentra cercas de su rango de ataque. Este comportamiento es llamado por el anterior para cuando se halla movido de posición verifique si puede realizar el ataque o no. 
Segundo Comportamiento del agente:

 private class comportamientoR1_2 extends Behaviour{   
  public void action() {
   //codigo del RobotIA cuando se dipone a atacar al jugador
   System.out.println("El robot verifica si hay enemigos cercas para atacar");
  }
  public boolean done() {
   return true;
  }
 }

Video donde se explica la funcionalidad del código

Resumen del Proyecto

El proyecto será un juego que será contra la maquina IA, que funcionara con inteligencia artificial, será el juego por turnos, será de dos jugadores uno contra otro (uno comandado por la IA), el objetivo principal será destruir la base del contrario, la IA se adaptara a la forma de juego. Constara de un tablero el cual sera similar al de un juego de ajedrez, pero que estará constituido por montañas, campo abierto y algunos edificios en el que el usuario y IA moverán sus unidades para llegar a la base enemiga. 

Las unidades (soldados) serán asignadas al iniciar cada partida, se podrá escoger la civilización que guste para el usuario y también para la maquina IA. También se podrán adquirir nuevas unidades a conforme vayan pasando los turnos y obteniendo puntos por cada turno.

La modificación que se le hiso es que solo sera de dos niveles que seria el normal y el difícil, también que sus escenarios serán clasificados como grandes, mediano y pequeño y se moverán por bloques con su respectivo limite de cada unidad por turno.

Colisiones

Demostracion.
se muestra como se jugara el juego, basado en el juego para android Uniwars.

Avance con respecto a la planeación

Con respecto al avance presentaremos un calendario de trabajo realizado en Microsoft Project 2012 para representar cada una de las actividades en las que se avanzo y las que faltan por avanzar.

Este software lo seguiremos manejando nos ayuda a tener un poco mas de organización, aunque si nos atrasamos en unos días ya que había inconveniente externos al proyecto, por lo cual el avance en la codificación no se realizo. 

¿Qué se ha hecho?

Para el proyecto se a realizado la mayoría de las actividades ya presentadas en el calendario anterior, de las cuales se consideran mas importantes la de elección del lenguaje que se usara, en este caso será JAVA, que se escogió mas que todo por que es el lenguaje que mas se domina por el equipo. Otro punto importante en el cual se hiso avance fue el uso de video tutoriales sobre este lenguaje, ya que aun sabiendo sobre el, nos faltan abarcar algunos puntos los cuales usaremos para el proyecto, como puede: ser el manejo de multiagentes, información de sistemas inteligentes y uso de librerías que faciliten el proceso.

¿Qué falta?

Bueno tuvimos varios inconvenientes en cuanto al tiempo, ya que no pudimos avanzar con la codificación, por lo cual faltaría comenzar con la parte del funcionamiento del proyecto teniendo ya definidas las clases y variables a usar, para después pasar a realizar la interfaz que ya será lo mas sencillo. Falta también buscar mas información mucha mas sobre sistemas inteligentes.

¿Qué problemas se han presentado y cómo los has resuelto / piensas resolverlos?

Los problemas entre los más importantes fue el tiempo para dedicarle a la codificación, necesitamos organizarnos un poco más ya que por problemas externos al proyecto se ha estado atrasando la codificación. Otro era la búsqueda de tutoriales de sistemas inteligentes y/o uso de multiagentes, pero pues no paramos hasta encontrar buena información y algunas ayudas externas sobre como se podrían utilizar en nuestro proyecto.

Lista actualizada de recursos y herramientas

El esta entrega presentamos una lista actualizada de recursos y herramientas de lo que hemos investigado conforme a nuestro proyecto, como nuestro proyecto es un juego tipo ‘’Age of Empires’’ pero más sencillo, siguiendo la idea de este juego y analizando los aspectos clave o importantes, nos dimos cuenta que vamos a tener que utilizar o nos ayudaría considerablemente lo que son los ‘’Agentes’’ y ‘’Multiagentes’’ a parte de que ya nos habían advertido que seguramente tendríamos que enfocarnos a estudiar ese tema porque lo utilizaríamos.

Para entrar más a fondo en este tema seguimos una introducción la cual nos ayudó a definir varias cosas.

http://www.infor.uva.es/~cllamas/MAS/MAS.pdf

Como bien ya sabemos un agente autónomo es un sistema que habita en un entorno dinámico en el que percibe y actúa alcanzando una serie de objetivos para la cual fue diseñado, nosotros proponemos un entorno virtual el cual constará con una serie de características referente al tipo de juego que con la ayuda del usuario, será un sistema adaptativo y tendrá que percibir algunas características que van a variar obteniendo resultados más dinámicos y diferentes.

Algunas de las características de los agentes inteligentes con las que tenemos que trabajar más son:

• -       Control del entorno
• -       Punto de vista incompleto

También podríamos definir que el tipo de entorno de nuestro proyecto es:

Estático/Dinámico

http://cibernetica.wordpress.com/2007/05/23/%C2%BFque-es-un-agente-inteligente/

El lenguaje pensado a usarse es Java

-       Compiladores NetBeans, Eclipse en Windows o Emacs en    Ubuntu.

-       Tutoriales sobre el uso de Multiagentes.

-        Información sobre Sistemas Inteligentes

-       Librerías de Java.

Ø  http://www.oracle.com/technetwork/java/index.html

Ø  http://docs.oracle.com/javase/tutorial/

Ø  http://www.ing.ula.ve/~aguilar/publicaciones/objetos/revistas/1070.pdf 

Ø http://www.uaeh.edu.mx/docencia/Tesis/icbi/maestria/documentos/Sistema%20multiagente.pdf

Ø  http://es.scribd.com/doc/68795969/85/Sistema-inteligente-de-interaccion

 También investigamos algunas librerías y herramientas que pensamos que nos ayudarán como:

• -       XELOPES
• -       YALE

http://www.oocities.org/es/mineria.datos/sistemas_herramientas_mineria_datos.pdf

Queremos implementar auto aprendizaje de algunas características o detalles para que sea más dinámico el juego, pero aún nos queda investigar bien este punto.

Hay tutoriales que nos están ayudando mucho como estos:

• Java Game: http://thenewboston.org/list.php?cat=30
• Intermediate Java: http://thenewboston.org/list.php?cat=25

Hemos estado investigando diferente tipo ideas, aún tenemos que orientarnos en algunos aspectos ya que pensamos que podríamos batallar con algunas cosas. 

Bosquejo de solución

se presentan algunas clases que se piensan usar, así como sus posibles funciones (las mas importantes) y la breve explicación de cada clase.

Clase	Funciones	Descripción general
Menú principal	*Ingresa nombre *Selección de tamaño del mapa *Selección de nivel de juego	En esta clase se encuentra la primera parte del juego en donde se solicitara un nombre al jugador , selecciona que tamaño de mapa deseara jugar, como el nivel del juego generando la partida con estas características
Menú de jugador (base)	*genera Oro *crear soldado #1 *crear soldado #2 *crear soldado #3 *crear soldado #4 *crear soldado #5 *crear soldado #6 *crear soldado #7 *soldado perfil	En esta clase es el desarrollo la primera parte del juego cuando seleccionara la base el usuario podrá creando algún tipo de soldado basándose en la cantidad de recurso que tenga (oro) donde se mostrara cuando preseleccione el soldado las características de este como su movilidad y bonos de ataque como defensa por tipo de área en el campo. La generación de oro será otorgada relación a la cantidad de bases bajo el poder del jugador antes de iniciar sus movimientos.
Menú de Soldado	*valida tipo de soldado *menú de soldado #1 *menú de soldado #2 *menú de soldado #3 *menú de soldado #4 *menú de soldado #5 *menú de soldado #6 *menú de soldado #7 *ataque *movimiento *rango visible	En esta clase es el desarrollo de la segunda parte del juego donde el usuario selecciona al soldado y podrá elegir entre atacar a un enemigo dentro del rango de ataque, moverse para atacar, defenderse o simplemente ampliar su panorama del mapa y ver tropas enemigas
AI	*Análisis de campo *movimiento	En esta clase esta desarrollada el área de IA de la computadora (enemigo) donde se analizara el mapa visible para la computadora y realizara su movimientos con la finalidad de exterminar con los soldados del usuario y conquistar la base del usuario
Interface	*Crear Mapa *Colocar soldados *Colocación de bases *creación de menús	En esta clase se desarrollara toda la interface  grafica del juego como es la colocación del mapa, bases y los soldados dentro del mapa, como también los menús dependiendo si el usuario seleccionó a un soldado o la base, desarrollándose en esta toda la parte visual del juego

Se presenta diagrama de alguna de la clase IA: