WEBVTT

00:02.930 --> 00:08.810
Hasta ahora, hemos visto la teoría para construir un plan basado en cabras, pero ahora tenemos que programar

00:08.810 --> 00:09.260
uno.

00:09.290 --> 00:15.440
Al final, lo que buscamos es un algoritmo que clasifique las acciones y haga coincidir sus efectos

00:15.440 --> 00:18.890
con otras precondiciones para construir un plan.

00:19.490 --> 00:23.870
Así que empezamos por obtener todas las acciones disponibles y el agente puede realizar.

00:23.990 --> 00:30.980
Estas se entregan al planificador, que las revisa todas para ver si en principio son realizables.

00:31.010 --> 00:36.960
Recuerda que ese pequeño método que escribimos para las acciones es realizable y siempre devuelve true.

00:36.980 --> 00:38.870
Pues bien, esta es la prueba para ello.

00:38.900 --> 00:44.210
Ahora bien, si se necesitara poner alguna otra lógica en ese método, eso tendría una acción rechazada por

00:44.210 --> 00:47.440
el planificador antes de que la planificación tenga lugar.

00:47.450 --> 00:49.400
Entonces aquí es donde lo pondrías.

00:49.400 --> 00:54.590
Pero sólo estamos trabajando con el principio de que todas las acciones van a ser realizables.

00:55.070 --> 00:59.000
A continuación, empezamos a construir un grafo comenzando por un nodo inicial.

00:59.330 --> 01:04.170
Ahora este nodo inicial va a tener como efectos los estados del mundo.

01:04.190 --> 01:10.220
A continuación, buscamos entre todas las acciones realizables las que se pueden llevar a cabo dados los estados

01:10.220 --> 01:11.510
del primer nodo.

01:11.660 --> 01:17.750
Cada acción coincidente crea un nuevo nodo y una nueva rama en el gráfico que estamos construyendo.

01:18.200 --> 01:25.700
A continuación, exploramos cada rama en busca de otra acción que pueda adjuntarse utilizando las condiciones previas y los efectos.

01:26.390 --> 01:34.670
Este proceso continúa por cada rama hasta que se satisface un camino que coincide con el objetivo inicial o el planificador

01:34.670 --> 01:36.500
se queda sin acciones.

01:37.300 --> 01:44.380
Si se encuentra un camino, ese camino se convierte en la cola de acciones del agente y éste comienza a realizarlas.

01:45.070 --> 01:48.310
Así que vamos a empezar a crear esta clase de planificación.

01:48.430 --> 01:52.660
Haz clic con el botón derecho del ratón hacia abajo en tus activos y añade otro do sostenido.

01:52.660 --> 01:55.510
Vamos a llamarlo planificador G.

01:55.900 --> 01:57.760
Entonces abre eso.

01:57.760 --> 02:07.090
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

02:07.090 --> 02:12.910
diccionario y también vamos a crear una clase de ayuda en la parte superior.

02:12.910 --> 02:16.120
Así que una clase pública para nuestros nodos.

02:16.120 --> 02:23.200
Así que recuerda que estamos construyendo un gráfico y lo estamos haciendo con el planificador que vinculará

02:23.200 --> 02:28.690
todas nuestras acciones juntas en un plan, pero en lugar de vincular las acciones a otras

02:28.690 --> 02:35.770
acciones, en realidad sólo vamos a crear un conjunto de nodos que están vinculados entre sí y luego sólo se aferran

02:35.770 --> 02:38.680
o apuntan a una acción particular.

02:38.860 --> 02:39.160
De acuerdo.

02:39.220 --> 02:47.530
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.

02:48.750 --> 02:55.170
Float, que será un coste para la acción que se utilizará para determinar qué plan es realmente

02:55.170 --> 02:56.240
el más barato.

02:56.250 --> 02:58.200
¿Deben existir varios planes?

02:58.320 --> 03:00.420
Entonces queremos un público.

03:02.320 --> 03:06.400
Diccionario y probablemente puedes imaginar lo que va a entrar aquí.

03:06.400 --> 03:06.820
Sí.

03:06.820 --> 03:14.260
String int para el estado que vamos a almacenar inicialmente que serán los estados del

03:14.260 --> 03:23.530
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.

03:24.980 --> 03:25.290
De acuerdo.

03:25.360 --> 03:29.320
Así que esas son las propiedades de ese nodo.

03:29.320 --> 03:30.940
Ahora vamos a construirlo.

03:31.120 --> 03:34.330
Así que nodo público nodo.

03:35.530 --> 03:39.490
Coste del flotador de los padres.

03:41.130 --> 03:42.540
Diccionario.

03:43.450 --> 03:45.910
Cadena int.

03:48.530 --> 03:49.880
Todos los estados.

03:51.660 --> 03:54.450
Y por último, la acción g.

03:55.900 --> 03:56.620
Acción.

03:57.640 --> 04:06.460
Y luego, dentro de aquí, nos aseguraremos de establecer cada uno de nuestros valores de propiedad a los deseados.

04:06.460 --> 04:07.780
Así que padre.

04:09.570 --> 04:11.580
Deberíamos decir este padre.

04:12.600 --> 04:14.040
Es igual al padre.

04:15.780 --> 04:18.960
Este punto cuesta igual que el coste.

04:19.890 --> 04:27.360
Este punto estado es igual a todos los estados, pero no a todos los estados porque apuntará a ese diccionario.

04:27.360 --> 04:30.270
En realidad queremos que sea una copia de ese diccionario.

04:30.270 --> 04:41.490
Para ello, creamos un nuevo diccionario de String iNts y le damos todos los estados para asegurarnos de que hemos

04:41.490 --> 04:45.120
hecho definitivamente una copia.

04:45.120 --> 04:51.600
Y entonces esta acción de punto será igual a la acción, de acuerdo, a nuestro planificador.

04:51.600 --> 04:54.230
Así que abajo el plan, podemos realmente deshacernos de nuestra actualización.

04:54.240 --> 04:54.990
Ahora empieza.

04:54.990 --> 05:00.630
Sólo va a hacer el procesamiento en nuestro gráfico y la construcción de la gráfica.

05:00.630 --> 05:03.000
Así que tampoco hace falta que sea un comportamiento de mona.

05:03.240 --> 05:03.690
De acuerdo.

05:03.690 --> 05:06.810
Así que en primer lugar, vamos a crear nuestro método.

05:06.810 --> 05:13.560
Así que es público, devuelve una Q y va a devolver una Q de acciones G.

05:13.560 --> 05:16.320
Así que g acción.

05:17.360 --> 05:19.460
Y lo llamaremos plan.

05:20.180 --> 05:24.350
Va a requerir una lista de todas las acciones.

05:24.350 --> 05:30.020
Así que la acción que tenemos, el agente tiene un asimiento de eso porque construye uno mismo.

05:30.020 --> 05:44.270
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.

05:44.270 --> 05:49.070
Así que pongamos estados bien y llamemos a eso.

05:49.950 --> 05:51.020
Estados.

05:51.480 --> 05:51.670
De acuerdo.

05:51.720 --> 05:58.800
Así que aquí, en primer lugar, vamos a averiguar cuál de las acciones que tenemos es realmente utilizable y nos

05:58.800 --> 06:00.130
quedamos con ellas.

06:00.150 --> 06:05.610
Así que vamos a crear una lista de acción.

06:06.590 --> 06:13.670
Aquí las acciones de los toros son iguales a la nueva lista de acciones.

06:14.330 --> 06:21.860
Y luego para cada acción g a en acciones.

06:25.110 --> 06:32.640
Si un punto es alcanzable, entonces lo añadiremos a nuestras acciones utilizables.

06:32.640 --> 06:36.270
Así que las acciones utilizables no suman.

06:37.360 --> 06:44.770
Así que eso va a desviar las acciones que no se pueden ejecutar en este momento.

06:44.770 --> 06:50.500
Después de eso, lo que vamos a hacer es configurar nuestra primera hoja para nuestro gráfico.

06:50.530 --> 06:50.890
¿De acuerdo?

06:50.920 --> 07:03.820
Así que queremos una lista de nodos, llamémoslos hojas igual a nueva lista de nodos.

07:04.300 --> 07:08.140
Y el nodo de inicio nodo de inicio.

07:08.320 --> 07:14.920
Va a ser igual a un nuevo nodo y va a tener un padre nulo porque es el primero.

07:14.920 --> 07:24.340
Va a tener coste cero de nuevo porque es el primero, va a tener una lista de los estados.

07:24.340 --> 07:28.270
Así que eso va a estar dentro de nuestros mundos.

07:28.270 --> 07:42.490
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.

07:42.490 --> 07:50.710
Porque, de nuevo, es sólo ese primer nodo, no está apuntando a una acción particular en este momento.

07:50.710 --> 07:53.170
Una vez hecho esto, queremos construir el gráfico.

07:53.170 --> 07:58.600
Así que vamos a devolver true o false en función de si realmente hemos encontrado un camino.

07:58.600 --> 08:07.990
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.

08:08.020 --> 08:15.430
Le pasaremos el nodo inicial, la lista de hojas que en este momento está vacía, la lista

08:15.430 --> 08:18.970
de acciones utilizables y el objetivo.

08:21.190 --> 08:22.450
Así que ese es el gráfico de nuestra factura.

08:22.510 --> 08:27.790
Ahora, cuando volvamos del gráfico de construcción, comprobaremos si tenemos éxito.

08:28.240 --> 08:36.370
Si no tenemos éxito, lo que podemos hacer aquí es decir que no hemos encontrado un plan.

08:36.400 --> 08:44.020
Ahora voy a poner un registro de depuración aquí para asegurarnos de que obtenemos algún tipo de retroalimentación, porque hay

08:44.020 --> 08:50.710
mucho que hacer una vez que se empieza a planificar y ejecutar sus agentes en cuanto a tratar de averiguar lo que realmente

08:50.710 --> 08:53.320
está pasando dentro del sistema.

08:53.320 --> 08:58.210
Y es posible que termines con un montón de errores en todo el asunto, lo cual es,

08:58.210 --> 09:04.960
de acuerdo, bastante natural hasta que te haces a la idea de cómo encajan estos nodos y las acciones.

09:04.960 --> 09:07.240
Así que en este punto devolveremos null.

09:07.240 --> 09:13.840
Así que en realidad no estamos devolviendo ningún plan si no hay plan, lo cual tiene sentido.

09:14.020 --> 09:14.260
De acuerdo.

09:14.290 --> 09:22.390
Lo que vamos a hacer entonces es que, si hemos llegado hasta aquí, tenemos un plan concreto que podemos seguir para

09:22.390 --> 09:24.400
lograr nuestro objetivo.

09:24.400 --> 09:34.330
Así que ahora vamos a encontrar el más barato, por lo que el nodo más barato es igual a null inicialmente

09:34.330 --> 09:40.990
y luego vamos a hacer un para cada nodo hoja en hojas.

09:42.970 --> 09:43.530
De acuerdo.

09:43.540 --> 09:46.630
Y vamos a hacer un bucle alrededor de todo esto.

09:47.050 --> 09:52.810
Ahora, en este punto, vamos a comprobar si la hoja o el nodo más barato.

09:52.810 --> 10:06.700
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.

10:06.730 --> 10:12.430
Significa que no hemos encontrado nada que sea realmente más barato, así que usaremos el que

10:12.700 --> 10:15.010
tenemos y luego pondremos otro.

10:15.010 --> 10:25.450
Si el coste de la hoja es menor que el coste del punto más barato, entonces diremos que es el más barato.

10:27.270 --> 10:28.980
Es igual a la vida.

10:31.560 --> 10:38.550
Así que en este punto, hemos encontrado nuestro nodo hoja más barato.

10:38.760 --> 10:45.690
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

10:45.690 --> 10:47.910
obtener la secuencia de acciones.

10:47.910 --> 10:54.390
Como hemos bajado por el gráfico, hemos encontrado nuestra hoja más barata, que está justo al final del plano,

10:54.390 --> 10:57.290
y ahora tenemos que volver a subir por él.

10:57.440 --> 11:03.990
Bien, vamos a crear una lista de acciones G que será nuestro plan resultante.

11:04.920 --> 11:07.410
Y eso va a equivaler a una nueva lista.

11:08.230 --> 11:10.000
De la acción G.

11:12.380 --> 11:16.070
Y entonces el nodo n es igual al más barato.

11:18.210 --> 11:22.890
Y luego mientras an no es igual a null.

11:26.110 --> 11:34.270
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

11:34.270 --> 11:38.410
como trabajamos hacia atrás a lo largo de la ruta.

11:38.680 --> 11:47.320
Resultados punto de inserción al principio y punto de acción.

11:48.880 --> 11:54.220
Y luego en iguales en punto padre.

11:55.690 --> 12:01.840
Así que ahora tenemos el padre en un y vamos a obtener su acción y luego vamos a obtener su padre y el

12:01.840 --> 12:04.900
bucle alrededor hasta que tengamos todos los.

12:04.900 --> 12:10.750
Así que esencialmente se ha creado una lista enlazada de estos nodos que representan su gráfico ahora

12:10.750 --> 12:16.810
que tenemos que podemos crear nuestra cola, que tendrá nuestras acciones que nuestro agente puede seguir

12:16.810 --> 12:18.370
adelante y realizar.

12:18.470 --> 12:25.900
Así que la acción de la cola, llamémosla cola con minúsculas es igual a nueva cola.

12:27.150 --> 12:30.060
De la acción G.

12:32.470 --> 12:39.730
Y luego para cada acción g i en el resultado.

12:41.890 --> 12:44.590
Vamos a ir a Q.

12:45.980 --> 12:53.600
Punto en q que pone un elemento al final de nuestra Q a.

12:55.030 --> 12:55.960
Y eso es todo.

12:55.960 --> 13:01.030
Así que los estamos pasando de nuestra lista a nuestra cola.

13:01.060 --> 13:06.790
Ahora, en este punto, si hemos llegado hasta aquí, bueno, obviamente tenemos un plan

13:06.790 --> 13:08.740
porque lo hemos elaborado.

13:08.740 --> 13:12.460
Así que vamos a depurar punto log.

13:14.330 --> 13:16.460
El plan es.

13:16.460 --> 13:22.640
Y, por supuesto, si empiezas a recibir demasiadas líneas de depuración mientras ejecutas la simulación,

13:22.640 --> 13:24.440
puedes comentarlas.

13:24.950 --> 13:30.110
Así que para cada acción g A en Q

13:31.770 --> 13:37.800
Y esto es puramente un bucle a través de él sólo para imprimirlos para que pueda ver que usted tiene un plan.

13:38.070 --> 13:42.450
Así que depurar la cola de espera.

13:44.200 --> 13:50.440
Y además un nombre de acción de punto o uso.

13:52.990 --> 13:55.900
Y luego, finalmente, volver nuestro.

13:55.900 --> 14:00.430
P Y eso nos lleva a nuestro agente con el plan.

14:01.880 --> 14:07.880
Así que ese es el grueso del método Q.

14:07.910 --> 14:15.740
Ahora tenemos que escribir el gráfico de construcción y como todavía hay mucho más código que escribir,

14:15.740 --> 14:18.170
lo haremos en el próximo vídeo.
