Hola a tod@s,
para terminar el año, Rodrigo Díaz Tajada nos deja un ejemplo en XNACommunity sobre reflexiones y refracciones de superficies.
Os dejo a continuación la descripción del ejemplo y el enlace para la descarga:
Un ejemplo para simular la reflexión y refracción de superficies mediante el uso de cubemaps. La demo permite seleccionar entre cubemap estático (generado al inicio de la aplicación) y cubemap dinámico (regenerado a cada frame). Además, se puede alternar entre un efecto de reflexión y de refracción.
Controles:
- Arrastrar con el botón izquierdo: rotar cámara.
- Arrastrar con el botón derecho: mover cámara.
- Tecla 1: Seleccionar cubemap estático.
- Tecla 2: Seleccionar cubemap dinámico.
- Tecla 3: Seleccionar reflexión.
- Tecla 4: Seleccionar refracción.
En enlace de descarga lo podeis encontrar aquí
Saludetes y ¡¡ Feliz Año Nuevo!! 
Hola a tod@s,
hoy Tyler Gasve nos deja en XNACommunity un visualizador de modelos 3D. A continuación os dejo la descripción que el mismo a dejado escrita, junto con un video de la aplicación y los enlaces de descarga:
"Visualizador de modelos 3D (.x y .fbx) permitiendo mostrar y listar sus mesh, bones y animaciones.
Los
modelos cargados pueden ser rotados, escalados y trasladados en su eje
-Y-, las animaciones ralentizadas, aceleradas y pausadas.
XNA Skin
Model View genera los archivos .xnb en tiempo de ejecución utilizando
para ello un Build, requiere para ello de Visual Studio y XNA
instalados.
Una parte importante del código de XNA Skin Model View se extrajo de:
http://creators.xna.com/en-US/tutorial/skinnedmodelextensions
http://creators.xna.com/en-US/sample/winforms_series2
No
todos los archivos .x/.fbx con animaciones van a funcionar
correctamente en la aplicación, esta tiene las mismas limitaciones que
el Content Pipeline Skinned Model original. Para probar su
funcionamiento se acompaña a la aplicación de unos modelos animados
"Skinned Model", en particular "fox anim skin", al que me entretuve a
generar unas cutre animaciones desde cero y añadirle un par de mesh
asociados a un bone para probar la correcta exportación desde 3DSMax
(kwxport-1.4.4). "
Los enlaces de descarga los teneis aquí.
Saludetes
Hola a tod@s,
hoy desde XNACommunity os traigo tres proyectos realmente interesantes. Se trata de mezclar una librería de detección de movimiento como es OpenCV y XNA.
Lo primero de todo ¿que es OpenCV exactamente? pues es una biblioteca libre de visión artificial originalmente desarrollada por Intel.
Desde que apareció su primera versión alfa en el mes de enero de 1999,
se ha utilizado en infinidad de aplicaciones. Desde sistemas de
seguridad con detección de movimiento, hasta aplicativos de control de
procesos donde se requiere reconocimiento de objetos. Esto se debe a
que su publicación se da bajo licencia BSD, que permite que sea usada libremente para propósitos comerciales y de investigación con las condiciones en ella expresadas.
Open CV es multiplataforma, Existiendo versiones para Linux, Mac OS X y Windows. Contiene mas de 500 funciones que abarcan una gran gama de areas en el proceso de Visión, como reconocimiento de objetos (reconocimiento facial), calibración de camaras, vision estereo y visión robótica.
Como metas el proyecto pretende proveer un "Tool-Kit" o Marco de
desarrollo fácil de utilizar y altamente eficiente. Esto se ha logrado,
realizando su programación en código c y c++ optimizados, aprovechando
además las capacidades que proveen los procesadores multi nucleo. Open
CV puede además utilizar el sistema las Primitivas de Rendimiento
Integradas de Intel. Que es un conjunto de rutinas de bajo nivel
especìficas para procesadores Intel. (Sacado de la wikipedia).
Bien, pues entre Javier Cantón que realizó el primer proyecto de ejemplo y Jesús Bosh que por lo que veo le está sacando rendimiento y aumentando los ejemplos con OpenCV han colgado sus respectivos proyectos en esta nuestra comunidad, XNACommunity. Son realmente interesantes y merece la pena bajarlos y echarles un vistazo.
Estos son los proyectos:
Os dejo los videos de los dos últimos proyectos para que veais todo lo que se puede hacer:
Saludetes
Render To Texture
IntroducciónHola a todos, en el siguiente tutorial/artículo intentaré enseñaros como hacer la técnica conocida como “Render to Texture” con la ayuda del 3D Studio.
Pero antes de nada veamos qué es esta técnica y cuando puede venir bien utilizarla.
La idea básica del render to texture consiste en utilizar como textura de un modelo una imagen renderizada previamente de ese modelo, si lo leemos así parece algo inútil… ¿para qué vamos a querer poner como textura de un objeto la misma textura que ya tiene? La razón es que en esa textura no sólo vamos a tener la misma textura anterior, si no que podremos aplicar efectos de iluminación avanzados, reflexiones, sombras etc. Ahora es cuando se le empieza a ver la utilidad de esta técnica, ya que podemos modelar nuestra escena en 3D Studio u otro programa similar, con varias luces, sombras, reflexiones… para posteriormente generar un render to texture y tener toda la información de la escena en una textura sin necesidad de tener que aplicar shaders en tiempo real, que por lo general, bajarán el rendimiento de la aplicación, es por eso que esta técnica suele usarse en su mayoría para aplicaciones en tiempo real, como los videojuegos.
Parece obvio que si esto es así todo el mundo usaría el render to texture para sus aplicaciones gráficas en tiempo real, pero quizás algunos de vosotros os preguntéis, vale sí, todo esto está muy bien, ¿pero qué ocurre si tenemos iluminación dinámica? ¿y si tenemos objetos moviéndose por el escenario, se verán afectados por la iluminación? Lamentablemente esta técnica no sirve para estos casos, al tener luces que cambien de posición u otro tipo de objetos móviles no se verán afectados ya que la escena tiene toda la iluminación precalculada en una textura y ésta no se actualizará, es por eso que esta técnica sólo es útil para modelar escenarios estáticos, que sabemos que no cambiarán durante la ejecución del programa.
ComenzandoPues bueno, una vez comentado todo esto, vamos a ponernos manos a la obra, como punto de partida tomaré el ejemplo de Javi de generación de terrenos con 3D Studio, que lo podéis encontrar en la sección de artículos también, cuando lo terminemos tendremos algo como esto:
El siguiente paso que vamos a hacer es añadir una luz a la escena para generar unas sombras, para ello debéis hacer click en el botón de luces bajo el menú de crear, lo podéis ver en esta imagen:
Elegimos Estándar en la pestaña y hacemos click sobre Target Direct, ahora nos vamos a algún viewport y pinchamos y arrastramos para crear la luz. Una vez creada quizás nos interese moverla para que enfoque bien a nuestro terreno, a mi me ha quedado algo tal que así:
Bien, una vez que ya tenemos la iluminación vamos a tocar algunos parámetros para tener sombras en la escena, hacemos click en selección por nombre (círculo rojo en el dibujo) y elegimos la luz que acabamos de crear:
Con la luz seleccionada nos vamos al panel de la izquierda donde creamos la luz y elegimos la pestaña de modificación (Círculo azul en la imagen) , como se observa en el panel hay que activar la casilla donde pone ON para las sombras (shadows) y si queréis también podéis tocar algún parámetro más, yo he modificado ligeramente la zona de penumbra y la zona que reciba luz:
Si hacemos ahora un render de la escena tenemos algo asi:
Pues bien, ya tenemos nuestra escena configurada para realizar el render to texture, el siguiente paso es ir al menú render y elegir la opción de render to texture:
A continuación se nos abre una ventana:
Es importante tener seleccionado el plano para indicar que vamos a aplicar el render to texture sobre ese objeto, si no lo tuviéramos seleccionado no aparecería nada en el cuadro donde aparece Plane01. En maping coordinates elegimos las opciones que tengo marcadas, use automatic unwrap (esto generará en el plano unas coordenadas para la textura) y dejad el channel 3, que luego lo utilizaremos.
Hacemos click sobre Add debajo de output:
Seleccionamos Complete Map y le damos a Add Elements
Se nos aparece la pantalla anterior de nuevo, a la derecha de file name and type podemos elegir donde guardar la textura y con qué formato, a continuación debajo podemos definir la altura y la anchura de la textura, seleccionamos shadows aunque por defecto viene seleccionada y en el menú baked material hacemos click sobre output into source. Ya está todo listo, hacemos click sobre render y nos aparecerá un render algo extraño jeje, estará guardado en donde se lo indicastéis.
Una vez hecho esto vamos a crear un nuevo material, para ello pulsad la tecla M del teclado y se abrirá el editor de materiales, elegimos un material vacío y al lado diffuse color hacemos click (justo donde aparece la M vosotros no deberíais tenerla)
A continuación elegimos bitmap y buscamos la textura que generó el render to texture:
Se nos abrirán más opciones en el editor, sólo tenemos que tocar el canal de la textura, que será el canal 3 ya que fue ahí donde se guardaron las coordenadas que generó el render to texture:
Una vez hecho esto podemos asignar este material a la escena, eliminar las luces y lanzar un nuevo render del terreno para ver que tenemos luz y sombras incluso habiendo eliminado la luz! :)
Ya solo falta exportar el proyecto a FBX y cargarlo en XNA para ver como efectivamente tenemos sombras y luz sin necesidad de perder rendimiento por ello.
Pues bien, con esto concluye este tutorial, espero que os resulte útil, un saludo y hasta la próxima.
David Mariscal Fernández
Hola a tod@s,
como en otras ocasiones desde XNACommunity nos llega un ejemplo para ayudarnos a mejorar nuestros juegos en XNA. Se trata de un ejemplo para aprender a crear reflexiones estáticas 2D para los menús de tus juegos.
Este
ejemplo muestra como precalcular de forma sencilla una textura usando
Texture.GetData y texture.SetData con un filtro blur aplicado y un
degradado en el canal alpha.
El ejemplo lo ha subido Javier Cantón, podeis descargarlo desde aquí.
Saludetes
Se ha incluido una nueva sección en la web de XNACommunity, se trata de un apartado de juegos completamente terminados que podemos descargar para jugar (
) y ver como están construidos.
De momento están disponibles 5 de los 8 juegos finalistas del concurso de videojuegos del DotNetClub de Alicante.
A continuación os dejo unos pantallazos de los juegos:
Tienen muy buena pinta ¿no creeis?
podeis leer la descripción de cada uno de ellos desde
aquí.
Saludetes
José Manuel Silvestre nos ha dejado esta vez en XNACommunity un componente muy sencillo y fácil de utilizar para nuestros juegos en XNA.
Se trata de una barra de progreso con la que podemos mostrar la carga de las pantallas, la energía, etc.
El componente lo tenéis disponible en XNACommunity.
Saludetes
José Manuel Silvestre nos trae su primer componente hecho en XNA. Se trata de un visor que simula una pantalla de LCD con el que podremos mejorar el aspecto de nuestros juegos.
En el paquete se incluyen los archivos .PSD (PhotoShop) por si queremos crear nuestros propios tipos de dígitos.
Este es el aspecto del componente:
Como siempre podeis descargarlo desde XNACommunity.
Saludetes
En este
ejemplo se muestran sombras omnidireccionales usando 'dual-paraboloid
mapping'.
Este tipo de proyección permite representar las profundidades
de todos los puntos de la escena en sólo dos texturas, a diferencia de
otros métodos como las sombras hechas con cubemaps que requieren
actualizar seis superficies, dando como resultado una técnica bastante
óptima aunque con ciertas fallos en la calidad de imagen.
Como siempre video y código:
El código lo podéis bajar de XNACommunity
Saludetes
¿Ya te has pasado el Guitar Hero mil veces? pues ahora puedes hacerte tu propia versión con ayuda del ejemplo que Javier Cantón ha subido a XNACommunity.
Podeis descargar el archivo con el proyecto desde la web de XNACommunity.
Saludetes
Pues eso mismo, aquí os dejo la info sobre el último ejemplo que Alex Urbano ha hecho para XNACommunity.
Este
ejemplo muestra una mezcla de técnicas destinadas a pintar una escena
3D simulando que es un dibujo animado hecho a mano. Se mezclan cosas
tales como cel shading usando una textura para modular la intensidad de
la luz, siluetas mediante geometría y detección de las mismas en un
post-proceso, y una simulación de trazos a lápiz en las zonas
sombreadas.
El ejemplo lo podeis descargar desde XNACommunity en la sección de ejemplos.
Saludetes
Bueno la idea de este tutorial es aprender a crear modelos de terrenos para nuestras demos XNA con 3D Studio Max. La generación de Terrains en los videojuegos se suele hacer mediante código durante el tiempo de carga o de forma dinámica durante el juego. Uno de los últimos videojuegos comerciales que presentan un sistema de terrenos muy avanzado es BattleField Bad Company, en el cual los terrenos se modifican en tiempo de juego a causa de explosiones provocadas por las armas de los jugadores.
Sin embargo muchas veces no se necesitan sistemas de generación de terrenos tan complejos, por lo que podemos precalcular estos y añadirlos en forma de content directamente a nuestros proyectos. Y esto precisamente es lo que vamos a explicar en este tutorial.
Manos a la obra
Bueno lo primero que vamos a necesitar será una textura para nuestro terreno, está podéis crearla ustedes o buscar alguna por internet, yo para este ejemplo voy a usar esta:
Bien lo siguiente que vamos a necesitar es una textura de alturas (heightMap), es decir, una textura con tonalidades que van de blanco a negro y que luego usaremos para establecer las alturas de nuestro terreno. Los pixeles negros estarán a nivel de mar y los pixeles de color blanco serán los picos más altos de nuestro terreno. Posiblemente podáis encontrar también algunos heightMap buscando por internet, pero en mi caso voy a generarlo mediante Photoshop.
Bien nos vamos a Photoshop y creamos un nuevo fichero de dimesiones 512x512, ya que nuestro terreno será cuadrado:
Y luego pintaremos el fondo completamente de negro para que inicialmente todo esté a nivel del mar:
El siguiente paso será usar la brocha para pintar las zonas de nuestro terreno que estarán sobre el nivel del mar. Seleccionamos la herramienta y configuramos algunas propiedades para que la brocha al pintar genere degradados en los bordes y de esa forma el terreno que generemos esté suavizado.
Y por último nos ponemos a pintar las alturas, esto es a gusto del consumidor, según lo que necesitéis para vuestro proyecto. Os recomiendo para la mayoría de los casos dibujar una especie de muralla rodeando toda la imagen pero dejando un margen negro, entonces si colocamos una cámara en el centro del terreno nunca veamos el final de este, sino montañas que no nos dejan ver más allá. Yo he dibujado esto XD:
Bien ya tenemos las texturas que necesitábamos, ahora nos vamos al 3d Studio Max y lo primero que vamos a hacer es crear un plano en el centro del mundo. Para ello dentro de la pestaña Create del menú de la derecha y teniendo seleccionada Geometric podremos ver un botón en el que pone Plane.
Presinamos el botón de plane y manteniendo pulsada la tecla control para que nos salga un plano cuadrado, creamos un plano en el centro del mundo.
Para asegurarnos que está en el centro, haremos click con el botón derecho del ratón sobre el botón mover del toolbar superior y en la ventana que nos aparecerá colocaremos todas las coordenadas a 0.
Ahora nos vamos a la pestaña modify y en un cuadro blanco de debajo aparecerá solo plane. Bien más abajo están las propiedades de creación de este plano, las cuales vamos a modificar para darle mayor número de vértices de forma que luego el terreno tenga un aspecto más suavizado. Para ello modificaremos los parámetros length segs y width segs, yo les voy a poner 40 a cada uno pero este valor difiere según el tamaño del terrain y del suavizado que necesitéis, lo óptimo sería tener un vértice para cada pixel de la textura del heigthMap.
Lo siguiente será irnos a la lista de modificadores y añadirle uno a nuestro plano llamado Displace:
Luego en sus propiedades nos iremos a Map y le aplicaremos el heigthMap que hemos generado con el photoshop.
Y por último para apreciar las alturas de nuestro heightMap sobre el plano le indicaremos mediante el parámetro Strength cuál será la altura de aquellos pixeles que esté en blanco:
Bien ya tenemos nuestro terreno generado, solo falta aplicarle la textura. Para ello abrimos el editor de materiales ( la forma más fácil es presionando la tecla ‘M’). Sobre cualquier material por defecto seleccionamos en la pestaña Maps, y le añadimos una textura al canal diffuse.
Y para aplicar la textura al plano realizamos los siguientes pasos que se muestran en la imagen (debemos tener el plano seleccionado).
Ok, pues aquí termina este tutorial, lo único que nos faltaría sería exportar ya dicho modelo en fbx o en el formato que se quiera.
Created by Javier Cantón Ferrero.
Saludetes
Hola a tod@s, tenemos un nuevo artículo en XNACommunity, en esta ocasión va sobre inteligencia artificial en los videojuegos, se la ha currado Marc García. Podeis también bajaros el código y leerlo en XNACommunity.
Primeros pasos en Inteligencia Artificial:
Modelos de comportamiento usando máquinas de estados
En el mundo de los videojuegos, está muy bien que los enemigos parezca que piensen y actúen en consecuencia a nuestros actos.
Básicamente si no lo hicieran, luchar contra un enemigo o contra una palmera no tendría diferencia alguna (los cocos, quizás).
En este artículo pretendo explicar qué hace decidir a un enemigo actuar de una manera o de otra, y poner un ejemplo práctico.
Mi intención es, que alguien que no sepa nada del tema, después de leer el artículo pueda jugar a un juego y entender porqué ese enemigo viene corriendo hacia mí cuando claramente tengo un bazooka en la mano.
CONTENIDO
- Máquinas de Estados
- Montando el tinglado
- Conclusiones
- Ejemplo
Máquinas de Estados
Me referiré a ellas como autómatas. Hay de muchos tipos, de estados finitos, infinitos, con transiciones lambda/epsilon etc. etc.
La mejor manera de explicar su funcionamiento es con el siguiente diagrama:
Los autómatas cuentan con términos propios (lenguaje, palabra, estado, ...), pero como eso es más complicado, vamos a lo básico.
Simplificando: empezamos en un estado, y cuando se cumple una condición, saltamos a otro estado.
Tanto las condiciones como los estados pueden ser abstracciones de cosas más complejas. De hecho, hasta pueden ser tratados como otros autómatas aparte.
Esto nos puede ayudar a ser organizados y no acabar con tiras y tiras y tiras de papel/hojas de <mi procesador de texto>. Ya sabéis, divide y vencerás.
Sabiendo eso, se puede hacer un esquema parecido al siguiente...
... en el que dejamos externa la parte de inicio/fin. Si además lo llamamos, por ejemplo, 'soldado'... pues supongo que ya se empieza a ver por dónde van los tiros.
Y hasta aquí la parte teórica, que no quiere decir ni por asomo que no exista nada más que explicar (je). Simplemente he contado lo básico que creo que es necesario para entenderlo.
De todos modos, si alguien siente curiosidad, wikipedia es tu amiga ->
http://en.wikipedia.org/wiki/Automata_theory http://en.wikipedia.org/wiki/Finite_state_machine Pasemos al ejemplo práctico
Montando el tinglado
Para nuestro ejemplo contamos con un par de modelos, a los que asignaremos diferentes comportamientos.
Ya que el comportamiento puede variar, creamos una clase base, de la que heredarán el resto.
public class CBehaviourModel
{
public CBehaviourModel() { }
public virtual void Update(GameTime gameTime, ref Vector3 position, ref Vector3 direction, ref Vector3 rotation) { }
}
El método importante es el
Update (bueno, estando sólo el constructor y un método tampoco queda mucho más).
Como alguno de los comportamientos modificará la posición, etc. de su modelo, lo pasamos por referencia en el
Update.
Teniendo ya la clase base, podemos crear el resto.
El planning es que uno de los modelos estará en modo patrulla, y el otro estará buscándolo. Cuando lo vea, lo seguirá.
Hacemos 3 clases entonces:
CPatroller,
CStraightSearcher y
CFollower.
Además, hacemos una cuarta
CStandStiller, que no hace nada. Realmente es como la clase base, pero con el nombre adecuado a lo que hace, quedarse quieto.
Para las explicaciones me centraré en los métodos "importantes", básicamente los
Update. Ya que en los métodos
Draw,
Load, etc. no hay nada excesivamente raro, no los comentaré.
Patrullar
Se trata de una clase muy simple.
Contiene un array de
N posiciones, que le indican la ruta a seguir. El punto
N conecta con el primero, de manera que hace un recorrido cerrado.
En el Update, va guardando el tiempo pasado entre frame y frame (
cumul_time) para determinar la distancia que avanza.
Hace un Lerp entre 2 vectores: pilla vector1, pilla vector2, y con un factor alpha [0..1] devuelve un nuevo vector. Si alpha = 0.5f, devuelve el vector medio entre v1 y v2. Como va de 0 a 1, usamos el tiempo para determinar alpha.
Una vez llegado al destino (
cumul_time = 1), se avanzan los corners (si es el final se vuelve al principio).
public override void Update(GameTime gameTime, ref Vector3 position, ref Vector3 direction, ref Vector3 rotation)
{
// update time: takes X seconds to go from corner to corner
cumul_time += (float)gameTime.ElapsedGameTime.TotalSeconds / corner_to_corner_time;
if (cumul_time > 1f) // reached max?
{
cumul_time = 0f;
// Change corners
++actual_corner;
rotation.Y -= 90f;
if (actual_corner >= corner_points.Length)
{
actual_corner = 0;
rotation.Y = 0f;
}
}
// patrolling
int next_corner = actual_corner + 1;
if (next_corner >= corner_points.Length)
next_corner = 0;
Vector3 from = corner_points[actual_corner];
Vector3 to = corner_points[next_corner];
position = Vector3.Lerp(from, to, cumul_time);
}
Apunte: siempre suelo decir que a la hora de calcular cualquier cosa en videojuegos hay que tener en cuenta tanto los números como los gráficos.
Es decir, que hay que cuadrar los valores de los elementos con los de las meshes que se van a pintar.
Por eso cuando se cambia de esquina se actualiza la rotación del modelo. Si no, iría pululando por el escenario sin más (ver el caso de
CFollower).
Buscar
Esta clase está hecha a modo de alarma típica de láser infrarrojo. Tenemos el modelo quieto, que "emite" un rayo; si alguien cruza ese rayo se cambia de comportamiento a
CFollower.
Para simular el rayo usaremos dos planos. El segundo se usa para limitar la "altura" del primero, ya que un plano es infinito y por tanto cualquier cosa que estuviera por detrás del modelo se detectaría también.
Aunque no se vea, en la escena tenemos
las rayas de colores son los dos planos.
En el
Update se hace la comprobación que el objeto esté por delante del plano rojo, y que intersecte con el plano amarillo.
public bool Intersects(BoundingSphere sphere)
{
intersection_front = false;
intersection_straight = false;
// check0: front of plane
if (Front.Intersects(sphere) != PlaneIntersectionType.Front)
{
return false;
}
intersection_front = true;
// check1: straight plane
if (Straight.Intersects(sphere) == PlaneIntersectionType.Intersecting)
{
intersection_straight = true;
}
return (intersection_front && intersection_straight);
}
Seguir
Finalmente, esta clase se encarga de seguir una posición con una distancia de seguridad (para no montar un modelo con otro).
Cada
Update se ha de actualizar la posición a seguir, por lo que se hace desde el
Update del juego principal.
if (dino.Behaviour is CFollower)
{
((CFollower)dino.Behaviour).TargetPosition = sword.Position;
}
dino.Update(gameTime);
sword.Update(gameTime);
y en el update correspondiente, se calcula la nueva posición
public override void Update(GameTime gameTime, ref Vector3 position, ref Vector3 direction, ref Vector3 rotation)
{
Vector3 dir = target_position - position;
dir = dir - dir / 10; // security distance = 1/10;
position += dir * (float)gameTime.ElapsedGameTime.TotalSeconds;
dir.Normalize();
direction = dir;
}
En este modelo no se actualiza la rotación del modelo, por lo que se ve "mal" cuando se mueve. Este es el ejemplo que comentaba en la clase
CPatroller.
Conclusiones
Con todo lo anterior se puede conseguir lo que se ve en el ejemplo, que es muy básico.
Con algo más de complejidad, se podría hacer, por ejemplo, que si un elemento se escapa a más de una distancia X, el otro elemento cambia a CSearcher.
También CStraightSearcher se podría convertir en CSearcher, haciendo no sólo una línea recta, si no que vaya rotando en un arco para ampliar la búsqueda, añadir un cono de visión, etc.
Los controles básicos son WASDZX + mouse para la cámara, espacio para iniciar el comportamiento de patrulla, R para resetear y ESC para salir.
Finalmente, espero que este artículo haya ayudado a alguien a entender, o entender mejor, como funcionan algunas de las Inteligencias Artificiales en los videojuegos.
Hay que tener en cuenta que las máquinas de estados se usaban hace mil millones de años, y que los juegos next-gen usan algoritmos muchos más complejos.
Pero bueno, que de algún lado ha venido todo.
Lo dicho, que espero que haya sido útil.
Saludetes