Hasta ahora, hemos visto la teoría para construir un plan basado en cabras, pero ahora tenemos que programar
uno.
Al final, lo que buscamos es un algoritmo que clasifique las acciones y haga coincidir sus efectos
con otras precondiciones para construir un plan.
Así que empezamos por obtener todas las acciones disponibles y el agente puede realizar.
Estas se entregan al planificador, que las revisa todas para ver si en principio son realizables.
Recuerda que ese pequeño método que escribimos para las acciones es realizable y siempre devuelve true.
Pues bien, esta es la prueba para ello.
Ahora bien, si se necesitara poner alguna otra lógica en ese método, eso tendría una acción rechazada por
el planificador antes de que la planificación tenga lugar.
Entonces aquí es donde lo pondrías.
Pero sólo estamos trabajando con el principio de que todas las acciones van a ser realizables.
A continuación, empezamos a construir un grafo comenzando por un nodo inicial.
Ahora este nodo inicial va a tener como efectos los estados del mundo.
A continuación, buscamos entre todas las acciones realizables las que se pueden llevar a cabo dados los estados
del primer nodo.
Cada acción coincidente crea un nuevo nodo y una nueva rama en el gráfico que estamos construyendo.
A continuación, exploramos cada rama en busca de otra acción que pueda adjuntarse utilizando las condiciones previas y los efectos.
Este proceso continúa por cada rama hasta que se satisface un camino que coincide con el objetivo inicial o el planificador
se queda sin acciones.
Si se encuentra un camino, ese camino se convierte en la cola de acciones del agente y éste comienza a realizarlas.
Así que vamos a empezar a crear esta clase de planificación.
Haz clic con el botón derecho del ratón hacia abajo en tus activos y añade otro do sostenido.
Vamos a llamarlo planificador G.
Entonces abre eso.
Y lo primero que vamos a hacer es en la parte superior añadir el uso de enlace del sistema de nuevo para ordenar las cosas como nuestro
diccionario y también vamos a crear una clase de ayuda en la parte superior.
Así que una clase pública para nuestros nodos.
Así que recuerda que estamos construyendo un gráfico y lo estamos haciendo con el planificador que vinculará
todas nuestras acciones juntas en un plan, pero en lugar de vincular las acciones a otras
acciones, en realidad sólo vamos a crear un conjunto de nodos que están vinculados entre sí y luego sólo se aferran
o apuntan a una acción particular.
De acuerdo.
Así que en primer lugar, vamos a tener un nodo público que es el padre de este nodo, a continuación, un público.
Float, que será un coste para la acción que se utilizará para determinar qué plan es realmente
el más barato.
¿Deben existir varios planes?
Entonces queremos un público.
Diccionario y probablemente puedes imaginar lo que va a entrar aquí.
Sí.
String int para el estado que vamos a almacenar inicialmente que serán los estados del
mundo en el primer nodo y luego la acción g pública, la acción a la que este nodo está hablando o apuntando.
De acuerdo.
Así que esas son las propiedades de ese nodo.
Ahora vamos a construirlo.
Así que nodo público nodo.
Coste del flotador de los padres.
Diccionario.
Cadena int.
Todos los estados.
Y por último, la acción g.
Acción.
Y luego, dentro de aquí, nos aseguraremos de establecer cada uno de nuestros valores de propiedad a los deseados.
Así que padre.
Deberíamos decir este padre.
Es igual al padre.
Este punto cuesta igual que el coste.
Este punto estado es igual a todos los estados, pero no a todos los estados porque apuntará a ese diccionario.
En realidad queremos que sea una copia de ese diccionario.
Para ello, creamos un nuevo diccionario de String iNts y le damos todos los estados para asegurarnos de que hemos
hecho definitivamente una copia.
Y entonces esta acción de punto será igual a la acción, de acuerdo, a nuestro planificador.
Así que abajo el plan, podemos realmente deshacernos de nuestra actualización.
Ahora empieza.
Sólo va a hacer el procesamiento en nuestro gráfico y la construcción de la gráfica.
Así que tampoco hace falta que sea un comportamiento de mona.
De acuerdo.
Así que en primer lugar, vamos a crear nuestro método.
Así que es público, devuelve una Q y va a devolver una Q de acciones G.
Así que g acción.
Y lo llamaremos plan.
Va a requerir una lista de todas las acciones.
Así que la acción que tenemos, el agente tiene un asimiento de eso porque construye uno mismo.
Así que las acciones del diccionario de la meta deseada por lo que el diccionario y la cadena int meta y los estados del mundo también.
Así que pongamos estados bien y llamemos a eso.
Estados.
De acuerdo.
Así que aquí, en primer lugar, vamos a averiguar cuál de las acciones que tenemos es realmente utilizable y nos
quedamos con ellas.
Así que vamos a crear una lista de acción.
Aquí las acciones de los toros son iguales a la nueva lista de acciones.
Y luego para cada acción g a en acciones.
Si un punto es alcanzable, entonces lo añadiremos a nuestras acciones utilizables.
Así que las acciones utilizables no suman.
Así que eso va a desviar las acciones que no se pueden ejecutar en este momento.
Después de eso, lo que vamos a hacer es configurar nuestra primera hoja para nuestro gráfico.
¿De acuerdo?
Así que queremos una lista de nodos, llamémoslos hojas igual a nueva lista de nodos.
Y el nodo de inicio nodo de inicio.
Va a ser igual a un nuevo nodo y va a tener un padre nulo porque es el primero.
Va a tener coste cero de nuevo porque es el primero, va a tener una lista de los estados.
Así que eso va a estar dentro de nuestros mundos.
Singleton Así que eso es G mundo punto instancia, punto obtener mundo punto obtener estados y luego null para la acción que está apuntando.
Porque, de nuevo, es sólo ese primer nodo, no está apuntando a una acción particular en este momento.
Una vez hecho esto, queremos construir el gráfico.
Así que vamos a devolver true o false en función de si realmente hemos encontrado un camino.
Así que será bool success y eso va a ser igual a lo que devolvemos de la gráfica de construcción que estamos por escribir.
Le pasaremos el nodo inicial, la lista de hojas que en este momento está vacía, la lista
de acciones utilizables y el objetivo.
Así que ese es el gráfico de nuestra factura.
Ahora, cuando volvamos del gráfico de construcción, comprobaremos si tenemos éxito.
Si no tenemos éxito, lo que podemos hacer aquí es decir que no hemos encontrado un plan.
Ahora voy a poner un registro de depuración aquí para asegurarnos de que obtenemos algún tipo de retroalimentación, porque hay
mucho que hacer una vez que se empieza a planificar y ejecutar sus agentes en cuanto a tratar de averiguar lo que realmente
está pasando dentro del sistema.
Y es posible que termines con un montón de errores en todo el asunto, lo cual es,
de acuerdo, bastante natural hasta que te haces a la idea de cómo encajan estos nodos y las acciones.
Así que en este punto devolveremos null.
Así que en realidad no estamos devolviendo ningún plan si no hay plan, lo cual tiene sentido.
De acuerdo.
Lo que vamos a hacer entonces es que, si hemos llegado hasta aquí, tenemos un plan concreto que podemos seguir para
lograr nuestro objetivo.
Así que ahora vamos a encontrar el más barato, por lo que el nodo más barato es igual a null inicialmente
y luego vamos a hacer un para cada nodo hoja en hojas.
De acuerdo.
Y vamos a hacer un bucle alrededor de todo esto.
Ahora, en este punto, vamos a comprobar si la hoja o el nodo más barato.
Así que si cheapest es igual a null, entonces el nodo más barato que tenemos sólo se va a establecer en la hoja.
Significa que no hemos encontrado nada que sea realmente más barato, así que usaremos el que
tenemos y luego pondremos otro.
Si el coste de la hoja es menor que el coste del punto más barato, entonces diremos que es el más barato.
Es igual a la vida.
Así que en este punto, hemos encontrado nuestro nodo hoja más barato.
Una vez que tenemos nuestro nodo más barato, Rashi ahora va a trabajar hacia atrás a través de él y de vuelta a la cadena para
obtener la secuencia de acciones.
Como hemos bajado por el gráfico, hemos encontrado nuestra hoja más barata, que está justo al final del plano,
y ahora tenemos que volver a subir por él.
Bien, vamos a crear una lista de acciones G que será nuestro plan resultante.
Y eso va a equivaler a una nueva lista.
De la acción G.
Y entonces el nodo n es igual al más barato.
Y luego mientras an no es igual a null.
Va a decir si una acción no es igual a null y sólo debe ser null si hemos golpeado el nodo de inicio de todos modos
como trabajamos hacia atrás a lo largo de la ruta.
Resultados punto de inserción al principio y punto de acción.
Y luego en iguales en punto padre.
Así que ahora tenemos el padre en un y vamos a obtener su acción y luego vamos a obtener su padre y el
bucle alrededor hasta que tengamos todos los.
Así que esencialmente se ha creado una lista enlazada de estos nodos que representan su gráfico ahora
que tenemos que podemos crear nuestra cola, que tendrá nuestras acciones que nuestro agente puede seguir
adelante y realizar.
Así que la acción de la cola, llamémosla cola con minúsculas es igual a nueva cola.
De la acción G.
Y luego para cada acción g i en el resultado.
Vamos a ir a Q.
Punto en q que pone un elemento al final de nuestra Q a.
Y eso es todo.
Así que los estamos pasando de nuestra lista a nuestra cola.
Ahora, en este punto, si hemos llegado hasta aquí, bueno, obviamente tenemos un plan
porque lo hemos elaborado.
Así que vamos a depurar punto log.
El plan es.
Y, por supuesto, si empiezas a recibir demasiadas líneas de depuración mientras ejecutas la simulación,
puedes comentarlas.
Así que para cada acción g A en Q
Y esto es puramente un bucle a través de él sólo para imprimirlos para que pueda ver que usted tiene un plan.
Así que depurar la cola de espera.
Y además un nombre de acción de punto o uso.
Y luego, finalmente, volver nuestro.
P Y eso nos lleva a nuestro agente con el plan.
Así que ese es el grueso del método Q.
Ahora tenemos que escribir el gráfico de construcción y como todavía hay mucho más código que escribir,
lo haremos en el próximo vídeo.