Na palestra anterior, demos uma olhada no que eram máquinas de estado finito, e criamos um ambiente.
Agora vamos realmente começar a codificar para esse ambiente e criar alguns estados.
Muito bem, de volta ao nosso patrimônio, o que vamos fazer é criar um novo roteiro, então
crie um roteiro afiado em C e este roteiro será chamado de Ambiente de Jogo.
Abra isso e então, dentro de nós, vamos criar nosso singleton.
Portanto, isto não herdará do comportamento mono e será uma classe fechada ao público, como já fizemos antes.
E depois queremos criar nossas listas para manter esses pontos de verificação.
Portanto, antes de mais nada, vamos criar um ambiente de jogo estático privado para nosso singleton e depois
um privado.
Lista de objetos de jogo.
Pontos de verificação equivalem a uma nova lista de objetos de jogo.
E depois uma chamada pública para aquele objeto de jogo da lista pública.
Pontos de verificação.
Obtenha.
Pontos de controle de retorno.
Certo.
Não precisamos de um começo e não precisamos de uma atualização, portanto, vamos nos livrar deles.
E então tudo o que precisamos aqui é de nosso singleton.
Portanto, vamos colocar em um ambiente de jogo público estático.
Queixo único.
Obtenha.
Se instância for igual a nula, então nós a criaremos.
Instância iguala o novo ambiente de jogo.
E então povoaremos esses pontos de controle para a própria instância real.
Por exemplo, postos de controle com a capital.
Adicionar gama de pontos e essa gama será jogo.
Objeto.
Encontrar.
Objetos com etiqueta no plural e nós queremos pontos de controle.
A etiqueta que tem o C maiúsculo é apenas ponto de controle, não pontos de controle.
E acabe com isso.
Certo.
E então devolvemos a instância e depois nos certificamos de ter parênteses de fechamento suficientes para tudo.
Três deles ali no fundo.
Esse é o seu jogo.
Singleton, que agora podemos usar para agarrar esses pontos de verificação.
E quando começamos a criar os estados, como você verá daqui a pouco, e as classes de estado são tão agradáveis
de ter um singleton que você pode chamar.
Não é preciso passá-lo entre tudo que está bem.
É hora de criar nossa classe de estado de base.
Portanto, no ativo, clique com o botão direito do mouse para criar um roteiro afiado em C.
Chamemos isso de Estado, o que faz sentido.
Vamos abrir isso em nosso editor.
E não vai ser novamente um comportamento mono agora vai ter estas bibliotecas que já temos no topo, mas
estamos lidando com a malha de navegação.
Por isso, vamos precisar incluir o sistema de unidade motor ponto AI.
Muito bem.
Portanto, agora temos nossa classe.
Vamos nos livrar dos métodos já existentes lá dentro.
Portanto, a primeira coisa, vamos criar um enumeral público para o Estado.
E aqui você quer listar todos os estados possíveis e pode acrescentar mais adiante.
Vamos apenas colocar alguns óbvios para um guarda NPC para que eles possam estar em estado ocioso, um estado
de patrulha, eles poderiam estar em perseguição.
Assim, perseguir o estado, eles podem estar atacando ou podem até estar dormindo.
A seguir, teremos outro enumero público, que será nosso evento.
Assim, isto nos dirá se estamos em entrada, atualização ou saída.
Portanto, onde estamos na administração do estado particular agora neste estado, vamos trazer um monte
de valores que são específicos ao nosso jogo real e à maneira como o temos montado.
Mas antes de tudo, precisamos de um Estado público e vamos chamar esse nome.
Portanto, isto registrará qual é o nome do estado.
Então queremos nosso evento protegido para o palco, que é uma dessas atualizações de entrada ou saída.
E então vamos ter.
Objeto de jogo protegido NPC a protegido.
Animador Adam porque também estamos lidando com animações.
Transformada protegida para o jogador.
Temos um deus que estamos criando.
Portanto, o guarda precisa saber onde está o jogador para poder enfrentá-lo e saber se deve atirar ou perseguir
o jogador, dependendo da distância.
E depois também um protegido.
Estado.
Que será nossa próxima.
Uma data como essa.
Este estado não é o enumero, que é este aqui em cima.
Portanto, o nome é baseado no enumero e este próximo estado é o estado que vai correr atrás do que estamos correndo atualmente.
Portanto, se você estiver ocioso e depois quiser entrar em uma patrulha, então o próximo estado estaria apontando
para um estado de patrulha.
Tudo bem, ótimo.
Certo.
Alguns outros valores que precisamos para o I real vamos ter
um flutuador a esta distância e vamos definir isso para 10. 0 se o ângulo da bóia é igual a 30 graus e uma bóia chamada distância de disparo ou distancia, que eu
definirei como 7. 0 f.
Agora o que isto significa é que quando o jogador está a uma distância de dez graus do NPC, então o NPC deve ser capaz de vê-lo
se estiver enfrentando a uma distância de 30 graus de sua linha de visão.
Se o NPC se aproximar o suficiente dentro de um intervalo de sete, ele pode então entrar em um estado de ataque.
Chegaremos a essa lógica na próxima palestra.
Vamos continuar escrevendo o método ou o construtor, devo dizer, para este estado em particular.
Portanto, o estado público vai levar um objeto de jogo que será o NPC, um agente nev mesh, agente e animador.
E uma transformação para nosso jogador.
Então o que fazemos com todos eles.
Por isso, nós os sentamos aqui.
Portanto, NBC iguala e Pixie Agent igualará o agente pelo qual passamos.
Aquele agente não deve ter um sublinhado à sua frente.
Então, teremos um átomo que equivale a um ano de pontuação por pontos.
Etapa que igualará o evento.
Ponto de entrada.
E então o jogador se iguala no marcador.
Agora acabei de notar que não declarei agente, deixe-me terminar este construtor e vamos voltar ao topo e acrescentar
isso.
Portanto, um agente protegido de malha de navegação chamado agente.
Muito bem.
Agora, sob este ponto, vamos colocar o código do esqueleto para cada uma de nossas diferentes etapas ou fases à medida que
passamos pelo estado.
Portanto, estes serão um vazio virtual público.
Entre.
A etapa é igual à atualização do ponto do evento.
Agora a razão.
Este é o.
Entre.
Portanto, isto.
Isto deve funcionar primeiro.
Quando você chega a um estado e quando ele o faz, então prepara o palco para ser o que quer que seja que será o próximo,
para que ele saiba mais tarde no processo que é para lá que ele está indo.
Vazio virtual público para atualização.
E então esta etapa será igual à atualização do evento porque, uma vez em atualização, você quer
permanecer em atualização até que a atualização realmente o expulse e então a saída virtual do vazio público que então definirá a etapa igual
à saída do ponto do evento para que ele saiba o que deve correr e limpar depois de si mesmo lá.
Então, finalmente, precisamos de um processo público estatal, que é o método que será executado a partir do exterior e que fará o Estado progredir
através de cada uma dessas diferentes etapas.
Portanto, se a etapa igual ao evento não entrar, então executaremos o método enter.
Se o estágio for igual a atualização de pontos de evento em maiúsculas porque esse é nosso valor enumeral, então
vamos executar a atualização e então se o estágio for igual a saída de pontos de evento, na verdade vamos chamar o método de saída e
vamos retornar ao próximo estado.
Observe que este método em particular retorna um estado.
Portanto, agora, se não vamos voltar ao próximo estado, faremos apenas um retorno.
Isto para que continuemos retornando ao mesmo estado.
E você verá onde isto ajuda a progredir para o próximo estado e para o próximo estado em linha.
Ao passarmos agora, criaremos um estado ocioso e um estado de patrulha para que possamos realmente fazer com que nosso NPC faça algo
para que você possa ver isto funcionando.
Agora vou criar meus estados que herdam da classe de estado base neste arquivo ponto csv.
A melhor prática provavelmente seria tê-los em arquivos CSS separados, mas como estamos construindo
isso à medida que vamos e voltamos entre o código e o que não, vou ter o lote
inteiro no mesmo lugar só para facilitar um pouco a nossa visão, e vamos voltar e continuar
montando isso no próximo vídeo.