WEBVTT

00:04.150 --> 00:09.260
Na palestra anterior, demos uma olhada no que eram máquinas de estado finito, e criamos um ambiente.

00:09.280 --> 00:14.410
Agora vamos realmente começar a codificar para esse ambiente e criar alguns estados.

00:14.800 --> 00:21.280
Muito bem, de volta ao nosso patrimônio, o que vamos fazer é criar um novo roteiro, então

00:21.280 --> 00:26.950
crie um roteiro afiado em C e este roteiro será chamado de Ambiente de Jogo.

00:28.030 --> 00:33.670
Abra isso e então, dentro de nós, vamos criar nosso singleton.

00:33.790 --> 00:45.760
Portanto, isto não herdará do comportamento mono e será uma classe fechada ao público, como já fizemos antes.

00:45.760 --> 00:51.520
E depois queremos criar nossas listas para manter esses pontos de verificação.

00:51.520 --> 01:04.030
Portanto, antes de mais nada, vamos criar um ambiente de jogo estático privado para nosso singleton e depois

01:04.030 --> 01:05.530
um privado.

01:06.760 --> 01:09.880
Lista de objetos de jogo.

01:12.080 --> 01:19.070
Pontos de verificação equivalem a uma nova lista de objetos de jogo.

01:22.070 --> 01:29.540
E depois uma chamada pública para aquele objeto de jogo da lista pública.

01:31.650 --> 01:33.540
Pontos de verificação.

01:36.240 --> 01:37.140
Obtenha.

01:38.560 --> 01:41.500
Pontos de controle de retorno.

01:46.340 --> 01:46.760
Certo.

01:46.760 --> 01:50.540
Não precisamos de um começo e não precisamos de uma atualização, portanto, vamos nos livrar deles.

01:50.540 --> 01:52.850
E então tudo o que precisamos aqui é de nosso singleton.

01:52.850 --> 01:59.540
Portanto, vamos colocar em um ambiente de jogo público estático.

02:00.270 --> 02:03.120
Queixo único.

02:05.850 --> 02:06.870
Obtenha.

02:13.400 --> 02:19.190
Se instância for igual a nula, então nós a criaremos.

02:21.180 --> 02:26.400
Instância iguala o novo ambiente de jogo.

02:29.620 --> 02:35.080
E então povoaremos esses pontos de controle para a própria instância real.

02:35.080 --> 02:38.950
Por exemplo, postos de controle com a capital.

02:40.520 --> 02:45.920
Adicionar gama de pontos e essa gama será jogo.

02:45.920 --> 02:47.060
Objeto.

02:47.480 --> 02:48.620
Encontrar.

02:50.280 --> 02:55.920
Objetos com etiqueta no plural e nós queremos pontos de controle.

02:55.920 --> 03:02.580
A etiqueta que tem o C maiúsculo é apenas ponto de controle, não pontos de controle.

03:03.210 --> 03:05.070
E acabe com isso.

03:05.700 --> 03:06.390
Certo.

03:06.420 --> 03:15.180
E então devolvemos a instância e depois nos certificamos de ter parênteses de fechamento suficientes para tudo.

03:15.780 --> 03:17.820
Três deles ali no fundo.

03:17.970 --> 03:18.960
Esse é o seu jogo.

03:18.960 --> 03:24.300
Singleton, que agora podemos usar para agarrar esses pontos de verificação.

03:24.300 --> 03:30.780
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

03:30.780 --> 03:33.340
de ter um singleton que você pode chamar.

03:33.360 --> 03:36.930
Não é preciso passá-lo entre tudo que está bem.

03:36.960 --> 03:40.800
É hora de criar nossa classe de estado de base.

03:40.800 --> 03:45.630
Portanto, no ativo, clique com o botão direito do mouse para criar um roteiro afiado em C.

03:45.630 --> 03:48.990
Chamemos isso de Estado, o que faz sentido.

03:48.990 --> 03:52.170
Vamos abrir isso em nosso editor.

03:52.170 --> 03:59.760
E não vai ser novamente um comportamento mono agora vai ter estas bibliotecas que já temos no topo, mas

03:59.760 --> 04:03.240
estamos lidando com a malha de navegação.

04:03.240 --> 04:10.170
Por isso, vamos precisar incluir o sistema de unidade motor ponto AI.

04:10.680 --> 04:11.070
Muito bem.

04:11.070 --> 04:12.510
Portanto, agora temos nossa classe.

04:12.510 --> 04:16.650
Vamos nos livrar dos métodos já existentes lá dentro.

04:16.650 --> 04:21.720
Portanto, a primeira coisa, vamos criar um enumeral público para o Estado.

04:22.800 --> 04:28.830
E aqui você quer listar todos os estados possíveis e pode acrescentar mais adiante.

04:28.830 --> 04:35.550
Vamos apenas colocar alguns óbvios para um guarda NPC para que eles possam estar em estado ocioso, um estado

04:35.550 --> 04:39.090
de patrulha, eles poderiam estar em perseguição.

04:39.090 --> 04:45.510
Assim, perseguir o estado, eles podem estar atacando ou podem até estar dormindo.

04:45.900 --> 04:51.150
A seguir, teremos outro enumero público, que será nosso evento.

04:51.150 --> 04:59.100
Assim, isto nos dirá se estamos em entrada, atualização ou saída.

04:59.550 --> 05:10.500
Portanto, onde estamos na administração do estado particular agora neste estado, vamos trazer um monte

05:10.500 --> 05:19.800
de valores que são específicos ao nosso jogo real e à maneira como o temos montado.

05:19.800 --> 05:26.760
Mas antes de tudo, precisamos de um Estado público e vamos chamar esse nome.

05:26.760 --> 05:29.400
Portanto, isto registrará qual é o nome do estado.

05:30.060 --> 05:39.540
Então queremos nosso evento protegido para o palco, que é uma dessas atualizações de entrada ou saída.

05:40.020 --> 05:43.260
E então vamos ter.

05:44.960 --> 05:53.600
Objeto de jogo protegido NPC a protegido.

05:55.690 --> 06:01.330
Animador Adam porque também estamos lidando com animações.

06:01.660 --> 06:05.410
Transformada protegida para o jogador.

06:05.800 --> 06:07.630
Temos um deus que estamos criando.

06:07.630 --> 06:14.320
Portanto, o guarda precisa saber onde está o jogador para poder enfrentá-lo e saber se deve atirar ou perseguir

06:14.320 --> 06:17.290
o jogador, dependendo da distância.

06:17.500 --> 06:20.350
E depois também um protegido.

06:22.630 --> 06:23.830
Estado.

06:27.480 --> 06:30.120
Que será nossa próxima.

06:30.950 --> 06:33.800
Uma data como essa.

06:33.800 --> 06:37.850
Este estado não é o enumero, que é este aqui em cima.

06:37.850 --> 06:47.000
Portanto, o nome é baseado no enumero e este próximo estado é o estado que vai correr atrás do que estamos correndo atualmente.

06:47.000 --> 06:53.570
Portanto, se você estiver ocioso e depois quiser entrar em uma patrulha, então o próximo estado estaria apontando

06:53.570 --> 06:55.460
para um estado de patrulha.

06:55.940 --> 06:57.410
Tudo bem, ótimo.

06:57.440 --> 06:57.770
Certo.

06:57.770 --> 07:06.110
Alguns outros valores que precisamos para o I real vamos ter

07:06.110 --> 07:22.940
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

07:22.940 --> 07:26.270
definirei como 7. 0 f.

07:26.270 --> 07:34.610
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

07:34.640 --> 07:40.250
se estiver enfrentando a uma distância de 30 graus de sua linha de visão.

07:41.180 --> 07:48.410
Se o NPC se aproximar o suficiente dentro de um intervalo de sete, ele pode então entrar em um estado de ataque.

07:48.410 --> 07:51.340
Chegaremos a essa lógica na próxima palestra.

07:51.710 --> 07:58.040
Vamos continuar escrevendo o método ou o construtor, devo dizer, para este estado em particular.

07:58.040 --> 08:14.810
Portanto, o estado público vai levar um objeto de jogo que será o NPC, um agente nev mesh, agente e animador.

08:16.970 --> 08:22.550
E uma transformação para nosso jogador.

08:23.360 --> 08:25.430
Então o que fazemos com todos eles.

08:25.640 --> 08:27.650
Por isso, nós os sentamos aqui.

08:27.650 --> 08:36.020
Portanto, NBC iguala e Pixie Agent igualará o agente pelo qual passamos.

08:37.310 --> 08:40.790
Aquele agente não deve ter um sublinhado à sua frente.

08:40.790 --> 08:46.760
Então, teremos um átomo que equivale a um ano de pontuação por pontos.

08:47.820 --> 08:51.810
Etapa que igualará o evento.

08:52.880 --> 08:54.230
Ponto de entrada.

08:56.510 --> 09:01.100
E então o jogador se iguala no marcador.

09:01.130 --> 09:08.750
Agora acabei de notar que não declarei agente, deixe-me terminar este construtor e vamos voltar ao topo e acrescentar

09:08.750 --> 09:09.940
isso.

09:09.950 --> 09:17.330
Portanto, um agente protegido de malha de navegação chamado agente.

09:20.980 --> 09:21.550
Muito bem.

09:21.550 --> 09:31.660
Agora, sob este ponto, vamos colocar o código do esqueleto para cada uma de nossas diferentes etapas ou fases à medida que

09:31.660 --> 09:33.760
passamos pelo estado.

09:34.030 --> 09:38.290
Portanto, estes serão um vazio virtual público.

09:38.320 --> 09:39.250
Entre.

09:41.000 --> 09:47.880
A etapa é igual à atualização do ponto do evento.

09:47.900 --> 09:49.070
Agora a razão.

09:49.190 --> 09:50.240
Este é o.

09:50.270 --> 09:50.750
Entre.

09:50.750 --> 09:51.200
Portanto, isto.

09:51.200 --> 09:52.850
Isto deve funcionar primeiro.

09:52.850 --> 09:59.090
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,

09:59.090 --> 10:03.140
para que ele saiba mais tarde no processo que é para lá que ele está indo.

10:03.470 --> 10:07.400
Vazio virtual público para atualização.

10:09.160 --> 10:17.650
E então esta etapa será igual à atualização do evento porque, uma vez em atualização, você quer

10:17.650 --> 10:30.280
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

10:30.850 --> 10:39.310
à saída do ponto do evento para que ele saiba o que deve correr e limpar depois de si mesmo lá.

10:39.640 --> 10:52.030
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

10:52.030 --> 10:56.830
através de cada uma dessas diferentes etapas.

10:56.830 --> 11:07.330
Portanto, se a etapa igual ao evento não entrar, então executaremos o método enter.

11:09.510 --> 11:23.190
Se o estágio for igual a atualização de pontos de evento em maiúsculas porque esse é nosso valor enumeral, então

11:23.190 --> 11:39.330
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

11:39.330 --> 11:44.310
vamos retornar ao próximo estado.

11:45.650 --> 11:53.270
Observe que este método em particular retorna um estado.

11:54.470 --> 11:58.400
Portanto, agora, se não vamos voltar ao próximo estado, faremos apenas um retorno.

11:58.610 --> 12:02.390
Isto para que continuemos retornando ao mesmo estado.

12:02.390 --> 12:07.340
E você verá onde isto ajuda a progredir para o próximo estado e para o próximo estado em linha.

12:07.340 --> 12:16.040
Ao passarmos agora, criaremos um estado ocioso e um estado de patrulha para que possamos realmente fazer com que nosso NPC faça algo

12:16.220 --> 12:19.160
para que você possa ver isto funcionando.

12:19.190 --> 12:30.800
Agora vou criar meus estados que herdam da classe de estado base neste arquivo ponto csv.

12:30.890 --> 12:37.700
A melhor prática provavelmente seria tê-los em arquivos CSS separados, mas como estamos construindo

12:37.700 --> 12:42.470
isso à medida que vamos e voltamos entre o código e o que não, vou ter o lote

12:42.470 --> 12:48.050
inteiro no mesmo lugar só para facilitar um pouco a nossa visão, e vamos voltar e continuar

12:48.050 --> 12:50.840
montando isso no próximo vídeo.
