Nesta palestra, vamos continuar a escrever algum código que permitirá a nossos agentes executar um
plano.
E então vamos colocar um plano simples em nosso agente.
E antes de começar, se você quiser exatamente o mesmo arquivo de projeto que eu comecei aqui,
ele está anexado a esta palestra como um projeto inicial.
Agora, para fazer isso, vamos entrar em nosso roteiro de agente G.
Então, abra isso.
Agora, se você se lembra de antes, houve uma atualização tardia e na verdade não preenchemos isto.
Portanto, agora é a hora de acrescentar o código.
Certo, então a primeira coisa que vamos fazer aqui é adicionar no planejador.
Portanto, só vou descer um pouco porque quero voltar e colocar outras coisas acima disto
um pouco mais tarde.
Primeiro de tudo, vamos dizer se o planejador é igual a nulo ou nossa deixa de ação, que é devolvida pelo planejador
igual a nulo, isso significa que o agente atualmente não tem planos para trabalhar.
Então, o que vamos fazer aqui?
Bem, nós vamos criar um novo plano.
Assim, criamos um novo planejador.
Antes de mais nada, portanto, planejador é igual a novo planejador G.
Assim.
E então vamos classificar todos os objetivos que temos agora.
Você se lembra quando criamos nosso agente e permitimos que ele tivesse múltiplos sub objetivos?
Portanto, se voltarmos ao topo aqui, um objetivo não é apenas um único objetivo, mas há vários objetivos.
E então também temos o nome do objetivo e estamos armazenando com ele um valor inteiro, que vai ser o quão importante
este objetivo em particular é para satisfazer.
Assim, vamos classificar todos os nossos objetivos e colocá-los em ordem do mais importante para o menos importante, de modo que possamos
então passar por eles um de cada vez até encontrarmos um que possamos fazer.
Portanto, vou fazer uma classificação var, que vai igualar nosso dicionário classificado, que
usará um comando de link.
Portanto, vai ser a partir da entrada em metas, ordem por valor de entrada descendente.
Selecione a entrada.
Certo.
E isso vai levar nossos objetivos.
Muito bem.
E encomende-o e coloque-o em objetivos ordenados.
Certo.
Agora, quando tivermos isso, vamos realmente passar por cada um de cada vez.
Portanto, para cada um deles, queremos o par de valores-chave do sub objetivo.
E int.
Portanto, este é um sub-golo em metas ordenadas.
Então aqui diremos que a deixa de ação.
É igual ao plano de pontos do planejador.
Portanto, é aqui que estamos chamando de plano.
Por isso, estamos assumindo o objetivo mais importante que conhecemos e tentando criar um plano para isso.
Portanto, planejar um plano precisa do conjunto de ações que temos o objetivo.
Portanto, temos esse é o sub objetivo, objetivos chave.
Portanto, são todos esses sub objetivos que compõem esse objetivo.
E então precisamos passar pelo estado, não pelos estados do mundo, mas estas são as crenças do agente e nós na
verdade ainda não as colocamos.
Por isso, neste momento, vamos passar por nulo.
Certo, então não estamos usando o sistema de crenças, ele só vai usar os objetivos mundiais que temos.
Então, se agirmos, vamos.
P Depois de termos feito isto não é igual a nulo, então devemos ter um plano que possamos seguir.
E nesse caso, vamos estabelecer o objetivo atual em que estamos trabalhando para igualar
o g, o sub objetivo, o valor chave.
E então vamos fugir porque não precisamos continuar a procurar esses objetivos para outro
plano, porque já temos um.
Portanto, esse é basicamente o nosso plano.
E agora lembre-se da atualização tardia, é um loop, ele vai loop e loop e loop.
Certo.
Assim, quando ele se desdobrar na primeira vez e não tivermos um plano ou uma execução, então teremos um planejador.
Agora, se temos uma ação, então, logo acima disto, quero testá-la primeiro.
Portanto, se estamos no meio de uma ação, então eu vou voltar desta atualização tardia
antes de entrarmos na fase de planejamento.
Portanto, aqui em cima iremos se a ação atual não for igual a um ponto de ação nulo e corrente.
Portanto, podemos dizer que estamos realmente trabalhando em nossa ação.
Agora, se estamos trabalhando em nossa ação, o que vamos fazer é colocar se a ação atual.
Agente de ponto.
O ponto tem caminho e corrente.
Ação.
A distância restante do agente é inferior a um f.
Agora, isto, como você reconhecerá, é código de malha de navegação.
E por isso precisamos ter isto aqui para que o agente se aproxime do objetivo.
Agora, assim que o agente tiver uma meta e ela tiver realmente atingido essa meta, e estamos dizendo
neste caso, como a menos de uma distância, então vamos correr o fim de nossa ação, que é correr basicamente
a conclusão da mesma.
Certo.
Agora lembre-se de que colocamos em cada ação uma duração.
Assim, quando chegamos a este ponto, atingimos nosso objetivo de localização, então precisamos esperar pela duração do mesmo.
Então, digamos que você tenha balançado até a mesa de registro e está se registrando, então você
chegou lá fisicamente, e então vai levar 10 segundos para realmente completar a tarefa que o agente está fazendo
lá.
Este é o código que fará isso.
Portanto, vamos dizer, se não for invocado e explicarei isto em um momento e se não for invocado,
então vamos invocar um método externo chamado completo.
Ação.
E isso vai ser enviado através da ação atual de curta duração.
Bem, na verdade, vai ser invocado nesses 10 segundos mais tarde e depois invocado.
Igual a verdade.
Agora, quando começarmos a ser invocados, será falso e eu vou apenas colocá-lo aqui.
Portanto, bool invocado e equivale a falso.
Portanto, sabemos que a primeira vez que entrarmos aqui, isto será falso.
Ele nos permitirá entrar aqui, invocar este método de ação completo em quaisquer segundos, e então ele se define invocado
como verdadeiro.
Portanto, nunca mais voltaremos a entrar aqui neste ponto.
Não podemos deixar que isso não nos deixe.
Mas o método de ação completo que vamos utilizar aqui em cima vai ser invocado de novo como falso
para nós.
Portanto, queremos uma ação nula e completa.
E então, dentro deste método, a ação atual em execução é igual a falsa.
Portanto, é aqui que finalmente dizemos que terminamos de executar nossa ação atual e isso forçará nosso sistema de planejamento
a seguir o plano novamente.
E por isso queremos que o atual posto de ação seja realizado.
Que é o método que executamos logo no final e, em seguida, vamos voltar a invocar a falsidade.
Certo.
Então é isso que acontece quando terminamos uma ação atual e depois de quantos anos de duração
ela vai durar, o que significa que ela vai falhar.
Desculpe-me por um momento enquanto eu comprava em meu próprio vídeo só para dizer que eu perdi uma declaração de retorno que você
precisará colocar dentro disso se a declaração for feita.
Agora, nesse ponto, ou você ficou sem ações ou ainda tem mais ações em sua fila.
Portanto, se for esse o caso, precisamos agora considerar isso.
Portanto, abaixo de nossa declaração para nosso planejador, vamos considerar se a ação Q não é igual a nula.
Portanto, temos realmente uma fila de ação e a contagem de pontos da fila de ação é igual a zero, o que significa que temos uma
fila de ação vazia e ficamos sem coisas para fazer.
Então, podemos ir se a meta atual for removida.
Portanto, se a meta na qual temos trabalhado é uma dessas metas removíveis, então podemos dizer
metas, remover nossa meta atual de lá e então vamos fazê-lo depois de termos feito aquele planejador definido para igualar nulo, o que vai
desencadear a obtenção de outro plano e da próxima vez que este loop passar.
Agora, finalmente, há mais uma condição de declaração que precisamos considerar aqui que
pode ocorrer e que é se fila de ação.
Não é igual a nulo.
E a ação.
A contagem dos pontos de taco é maior que zero.
Isso significa que ainda temos ações deixadas em nossa fila que voltaram do planejador.
Nesse caso, podemos começar a executá-los.
Por isso, agora vamos ter a ação atual e vamos ser iguais à ação.
Q.
Ponto D.
P E isto tomará a ação que está sentada no topo de nossa fila fora da fila e a colocará em
ação atual.
Agora executamos então o método de pré-desempenho que temos para nossa ação.
Por isso, vai ser um ponto de ação atual de pré-apresentação.
E ali podemos fazer todas as verificações que precisamos fazer, como para atributos físicos que precisam
ser ditos se o número de, digamos, cubículos estiver disponível e todo esse tipo de coisas.
E então, se isso for verdade, queremos ir se a meta de ação atual for igual a zero.
E a marca de alvo de ação atual não equivale a uma corda vazia.
Então o que vamos fazer é ir que o alvo de ponto de ação atual é igual ao alvo de ponto de ação do jogo com tag
ponto de ação atual.
Marca do alvo para que possamos definir o alvo para o agente de malha de navegação, definindo-o no inspetor.
Ou podemos encontrá-lo usando uma etiqueta.
Portanto, se você fez um pré-fabricado de seu personagem, será muito mais fácil para você apenas definir a etiqueta.
Então, ele faz esta busca quando entra no ambiente para procurá-la.
Agora, como você pode ver, estou recebendo erros com nossa tag alvo aqui.
Se eu salvar isso rapidamente e voltar à minha ação G e você talvez queira dar uma olhada aqui,
você pode ver que nós definimos a tag alvo para ser um objeto de jogo quando de fato é para ser uma corda.
Então isso foi apenas um pequeno erro que eu cometi antes e que ainda estará em seu código.
Portanto, basta salvar isso e depois podemos voltar para nosso agente.
A outra coisa que você pode ver aqui é que os objetos de jogo a serem encontrados com tag precisam ser um G maiúsculo lá dentro.
Agora vamos terminar isto.
Se temos nossa declaração de que temos nosso objeto-alvo, então vamos embora.
Se a meta de ação atual não for igual a zero.
Portanto, ainda pode ser que acabemos não tendo para onde ir, a ponto de mudar nosso agente de lugar.
E se for esse o caso, vamos verificar se não é igual a nulo.
Portanto, se não for igual a zero, o alvo, não a etiqueta, eu deveria dizer que o ponto de ação atual é igual a verdadeiro.
E é aqui que a ação realmente começa a ter lugar.
Vamos nos livrar desse T e do ponto de ação atual do agente de ponto de ajuste de destino e esse é nosso agente de malha de navegação
ajustando o destino para a corrente.
Ação.
Ponto alvo, ponto transform.
Posição do ponto.
Está bem.
Portanto, este é o ponto de partida para definir o destino de nosso agente.
E então para cima é onde estamos realmente testando se conseguimos chegar ao destino.
Agora, lembre-se que o código do agente de malha de navegação vai fazer sua coisa automaticamente em
segundo plano, até o ponto de mover o agente.
Certo.
Por isso, vamos terminar essa declaração agora mesmo.
Caso contrário, se não pudermos fazer nosso método de pré-desempenho, vamos dizer fila de ação.
Igual a nulo.
E isso nos obrigará a ter um novo plano.
Voltar para os objetivos.
Adquira um novo plano.
Agora, se qualquer uma de suas ações pelas quais você está trabalhando ou tentando trabalhar falhar, então ele vai replanear
tudo, o que pode de fato planejar exatamente a mesma seqüência de ações, mas enviá-lo de
volta para o início para que ele se certifique de que você faça isso.
E também garante que seu agente não fique preso em algum lugar no meio de um plano.
Certo, então agora que já temos isso, vamos apenas salvá-lo.
Esse é nosso principal código para nossa atualização tardia.
Certo.
Vamos voltar à unidade.
Agora vamos criar nossa classe básica para nosso paciente.
Portanto, clique com o botão direito do mouse e crie um novo roteiro em C afiado.
Vamos ligar para este paciente e depois abrir isto.
Vai ser um código muito curto.
Assim, o paciente vai herdar de G.
Agente e não vai ter uma atualização.
Vai ter um começo.
Agora, no início, queremos chamar o início da base que está acontecendo no roteiro do agente G e depois vamos criar um
sub objetivo.
Portanto, um sub-golo S é igual a um novo sub-golo e o sub-golo estará esperando e daremos prioridade a um e diremos que é verdade,
o que o removerá de ser um objetivo e então teremos que adicioná-lo a nossos objetivos.
Portanto, os objetivos acrescentam.
S um e sua prioridade neste caso são três.
Agora este início em particular e nosso agente G, vamos apenas salvar isto, vamos voltar para os agentes G querem
apontar algo que você precisa consertar aqui que eu acabei de fazer antes é adicionar um público ao início, caso contrário,
você vai receber um erro quando tentar chamar esse início de base.
Mas basicamente o ponto de base começa a configurar todas as suas ações que você prendeu ao seu
paciente, e então você pode ir em frente e executar o resto deste código de paciente, certo?
Portanto, vamos salvar isso, voltar à unidade e agarrar esse roteiro paciente e arrastá-lo
e soltá-lo em seu paciente.
Sim.
E aí está ele.
Agora precisamos realmente de uma ação a ser seguida, então vamos fazer uma ação rápida.
E aqui, vamos criar C-sharp e vamos chamar isso de C-sharp.
Ir para o hospital.
Abra isso para editá-lo.
E desta vez, não vai ser um comportamento mono.
Isto será na verdade uma ação g.
E dentro daqui, vamos nos livrar do nosso começo e atualizar.
E tudo o que precisamos fazer é colocar uma bobina de anulação pública para nossa pré-execução, a qual apenas colocaremos de volta
verdadeira lá dentro e, em seguida, uma cópia disso aqui embaixo para nosso desempenho no posto.
Portanto, esta é uma ação padrão básica de estoque.
Portanto, poupe isso.
Agora volte à unidade.
Vamos anexar este hospital de ouro ao nosso paciente, o que lhe dará acesso para poder realizar
essa ação em particular.
Agora esta ação, lembre-se, temos condições prévias e condições pósvias que podemos colocar
aqui.
Digamos que, só por enquanto, não há nenhuma condição prévia.
O efeito posterior terá de corresponder ao nosso objetivo, seja ele qual for.
Agora, o objetivo para nosso paciente, se voltarmos ao roteiro aqui, é esperar.
Muito bem, de volta à unidade em nosso paciente, vamos acrescentar um.
O efeito secundário e vai ser esperado e é aqui que precisa ser soletrado corretamente.
Agora, o valor neste caso não importa porque não estamos realmente usando-o para nada.
A outra coisa que precisamos saber é onde o alvo desta ação vai ocorrer agora, porque
o agente está no local, na hierarquia com, digamos que vamos ao hospital na área de espera, então pegue a
área de espera e arraste e solte-a em seu alvo.
Vai ficar tudo bem.
Não é um pré-fabricado, portanto não temos que procurá-lo usando a etiqueta da área de espera.
Certo.
Portanto, agora se pressionarmos o jogo, nosso agente vai formular um plano para garantir que esse objetivo de espera ocorra.
E, como você pode ver, fez isso porque tudo o que precisava fazer era correr o roteiro para ir ao hospital
a fim de satisfazer seu objetivo.
Então, lá vamos nós.
Há nosso sistema de plano muito, muito básico, muito, muito simples que funciona em nosso sistema de corda, que acabamos
de montar.
Assim, agora em diante e para cima, para ações mais complexas.