TESTE inimigo anda por um trajeto definido, para ao ser iluminado, e segue seu caminho

Olá!

Eu tava caçando um jeito de fazer um inimigo andar por determinado percurso, parando e olhando para cada direção, além disso, ele deveria parar quando colidisse comigo a um metro de distancia e eu acendesse a luz da lanterna. Achei um script de waypoints que me ajudou muito (coloco abaixo traduzindo os coments, pode ser útil para mais alguem ou servir de base para algo.). Traduzi o que pude, certas partes foram dificeis por causa do meu conhecimento tacanho em programação. Mas traduzi e resolvi postar, como agradecimento a ajuda que ja recebi do forum (e dos tutoriais que vi daqui)
Como eu faria, para adicionar no script abaixo, o efeito de parar o inimigo (apenas dentro de 1 metro de distancia do meu jogador) ao acender a luz (pondo no script o mesmo botão que uso para ligar a lanterna), e ao sair dessa area, ele volta a se mover, seguindo o percurso?

Alguem pode me dar uma luz?

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Movimentação : MonoBehaviour
{
 //   This is a very simple waypoint system.
 //Este é um sistema simples de Waypoints
 // Each bit is explained in as much detail as possible for people (like me!) who need every single line explained.
 //Cada parte é explicada com o máximo de detalhes possivel para pessoas (como eu) que precisam entender cada linha descrita
 // As a side note to the inexperienced (like me at the moment!), you can delete the word "private" on any variable to see it in the inspector for debugging.
 //Como um conselho para pessoas sem experiência, como eu, você pode deletar a palavra "private" de qualquer variável para vê-la no inspector para debugar.

 // I am sure there are issues with this as is, but it seems to work pretty well as a demonstration.
 //Eu estou certo de que há problemas com o código como ele é, mas serve bem como demonstração (para mim serviu como uma luva...)

 //STEPS: Passos
 //1. Attach this script to a GameObject with a RidgidBody and a Collider.
 //1. Coloque este script a um gameobject com rigidbody e collider
 //2. Change the "Size" variable in "Waypoints" to the number of waypoints you want to use.
 //2. Mude o "Size" (tamanho) das variável em "waypoints" para o número de waypoints (espécie de checkpoints no caminho) que você quer usar.
 //3. Drop your waypoint objects on to the empty variable slots.
 //3. coloque seus waypoints nos slots vazios das variáveis
 //4. Make sure all your waypoint objects have colliders. (Sphere Collider is best IMO).
 //4. Esteja certo de que todos os waypoints tem colliders (Sphere Colliders são melhores)
 //5. Click the checkbox for "is Trigger" to "On" on the waypoint objects to make them triggers.
 //5. Marque a caixa de "is trigger" como "on" em todos os objetos de waypoints
 //6. Set the Size (radius for sphere collider) or just Scale for your waypoints.
 //6. Coloque o tamanho (raio para o sphere collider) ou apenas ajuste a escala
 //7. Have fun! Try changing variables to get different speeds and such.
 //7 Divirta-se! Tente mudar as variáveis para ter diferentes velocidades e etc.

 // Disclaimer:
 // Extreeme values will start to mess things up.
 // Maybe someone more experienced than me knows how to improve it.
 // Please correct me if any of my comments are incorrect.

 // This is the rate of accelleration after the function "Accell()" is called.
 //Esta é a taxa de aceleração depois que a função "Acell()" é chamada
 // Higher values will cause the object to reach the "speedLimit" in less time.
 //Altos valores farão o objeto alcançar a velocidade máxima mais rapidamente
 public float accel = 0.8f;

 // This is the the amount of velocity retained after the function "Slow()" is called.
 //Esta é a quantidade de velocidade retida após a função "slow()" ser chamada
 // Lower values cause quicker stops. A value of "1.0" will never stop. Values above "1.0" will speed up.
 //Valores menores causam paradas mais bruscas um valor de "1.0" fará nunca parar. Valores acima de "1.0" vão acelerar o objeto
 public float inertia = 0.9f;

 // This is as fast the object is allowed to go.
 //Esta é a velocidade máxima do objeto
 public float speedLimit = 10.0f;

 // This is the speed that tells the functon "Slow()" when to stop moving the object.
 //Esta é a velocidade que diz a função "slow()" quando parar o objeto
 public float minSpeed = 1.0f;

 // This is how long to pause inside "Slow()" before activating the function
 //Aqui é quanto tempo de pausa há em "Slow()" antes de chamar a função
 // "Accell()" to start the script again.
 //"ACell()" para recomeçar o script
 public float stopTime = 1.0f;

 // This variable "currentSpeed" is the major player for dealing with velocity.
 //Esta variável "current speed" é a forma principal de se lidar com a velocidade
 // The "currentSpeed" is mutiplied by the variable "accel" to speed up inside the function "accell()".
 //"currentSpeed" é multiplicado pela variável "acell" para aumentar a velocidade dentro da função "Acell()"
 // Again, The "currentSpeed" is multiplied by the variable "inertia" to slow
 //Novamente, "CurrentSpeed" é multiplicado pela variavel "inertia" para frear.
 // things down inside the function "Slow()".
 //Tudo ocorre dentro da função "Slow()"
 private float currentSpeed = 0.0f;

 // The variable "functionState" controlls which function, "Accell()" or "Slow()",
 //A variavel "functionState,  "Acell()" ou "Slow()"
 // is active. "0" is function "Accell()" and "1" is function "Slow()".
 //está ativa. "0" é a função "Acell()" e 1 é a função "Slow()"
 private float functionState = 0;

 // The next two variables are used to make sure that while the function "Accell()" is running,
 //As duas variáveis seguintes são usadas para ter certeza que  enquanto a função "Acell()" está em uso,
 // the function "Slow()" can not run (as well as the reverse).
 //A função "Slow()" não pode funcionar (e vice-versa)
 private bool accelState;
 private bool slowState;

 // This variable will store the "active" target object (the waypoint to move to).
 //Esta variável irá guardar o objeto alvo ativo (o waypoint ao qual o objeto irá se mover)
 private Transform waypoint;

 // This is the speed the object will rotate to face the active Waypoint.
 //Esta é a velocidade que o objeto irá rotacionar para ir ao proximo waypoint
 public float rotationDamping = 6.0f;

 // If this is false, the object will rotate instantly toward the Waypoint.
 //Se esta for falsa, o objeto irá rotacionar instantaneamente para o waypoint
 // If true, you get smoooooth rotation baby!
 //Se for verdadeira, ele terá uma suaaave rotação
 public bool smoothRotation = true;

 // This variable is an array. []< that is an array container if you didnt know.
 //Esta variavel é uma matriz. []< Este é um conteiner de matriz se você não sabe.
 // It holds all the Waypoint Objects that you assign in the inspector.
 //Ele guarda os waypoints que você define no inspetor
 public Transform[] waypoints;


 // This variable keeps track of which Waypoint Object,
 //Esta variável mantém o controle de qual waypoint,
 // in the previously mentioned array variable "waypoints", is currently active.
 //na variavel de matriz mencionada anteriormente, esta atualmente ativa
 private int WPindexPointer;


 // Functions! They do all the work.
 // You can use the built in functions found here: [url]http://unity3d.com/support/documentation/ScriptReference/MonoBehaviour.html[/url]
 // Or you can declare your own! The function "Accell()" is one I declared.
 // You will want to declare your own functions because theres just certain things that wont work in "Update()". Things like Coroutines: [url]http://unity3d.com/support/documentation/ScriptReference/index.Coroutines_26_Yield.html[/url]

 //The function "Start()" is called just before anything else but only one time.
 void Start( )
 {
 // When the script starts set "0" or function Accell() to be active.
 // Quando o script começar selecione "0" ou função Acell() ativa.
 functionState = 0;

 }

 //The function "Update()" is called every frame. It can get slow if overused.

 void Update ()
 {
 // If functionState variable is currently "0" then run "Accell()".
 // Se functionState  = "0", então chame a função Acell()
 // Withouth the "if", "Accell()" would run every frame.
 //Sem esse "if", a função é chamada a cada frame.
 if (functionState == 0)
 {
 Accell();
 }

 // If functionState variable is currently "1" then run "Slow()".
 // Se functionState é igual a "1", chame a função "Slow()"
 // Withouth the "if", "Slow()" would run every frame.
 //Sem esse "if" a função é chamada a cada frame.
 if (functionState == 1)
 {
 StartCoroutine(Slow());
 }

 waypoint = waypoints[WPindexPointer]; //Keep the object pointed toward the current Waypoint object.
 //Mantenha o objeto apontado para o próximo waypoint
 }

 // I declared "Accell()".
 // função "Acell()"
 void Accell ()
 {
 if (accelState == false)
 {
 // Make sure that if Accell() is running, Slow() can not run.
 //Confirmando que se Acell() esta funcionando, Slow() não pode funcionar
 accelState = true;
 slowState = false;
 }

 // I grabbed this next part from the unity "SmoothLookAt" script but try to explain more.
 //Eu peguei esta parte do script "SmoothLookAt" mas tentarei explicar mais
 if (waypoint) //If there is a waypoint do the next "if".
 //Se tiver um waypoint próximo
 {
 if (smoothRotation)
 {
 // Look at the active waypoint.
 //olhe apara o waypoint ativo
 var rotation = Quaternion.LookRotation(waypoint.position - transform.position);

 // Make the rotation nice and smooth.
 //Faça a rotação bela e suave
 // If smoothRotation is set to "On", do the rotation over time
 //Se smoothRotation estiver ligada, faça a rotação através do tempo
 // with nice ease in and ease out motion.

 transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * rotationDamping);
 }
 }

 // Now do the accelleration toward the active waypoint untill the "speedLimit" is reached
 //Agora acelere para o proximo ponto de waypoint até spedLimit ser alcançado
 currentSpeed = currentSpeed + accel * accel;
 transform.Translate (0,0,Time.deltaTime * currentSpeed);

 // When the "speedlimit" is reached or exceeded ...
 //Qaundo speedLimit é atingida ou ultrapassada...
 if (currentSpeed >= speedLimit)
 {
 // ... turn off accelleration and set "currentSpeed" to be
 //...desligue a aceleração e selecione currentSpeed para ser
 // exactly the "speedLimit". Without this, the "currentSpeed
 //exatamente a speedLimit. Sem isso, currentSpeed
 // will be slightly above "speedLimit"
 //estará levemente acima de speedLimit
 currentSpeed = speedLimit;
 }
 }

 //The function "OnTriggerEnter" is called when a collision happens.
 //A função OnTriggerEnter é chamada quando uma colisão acontece
 void OnTriggerEnter ()
 {
 // When the GameObject collides with the waypoint's collider,
 //Quando o objeto colide como colisor do waypoint
 // activate "Slow()" by setting "functionState" to "1".
 //Ativar "Slow()" colocando "functionState" = "1"
 functionState = 1;

 // When the GameObject collides with the waypoint's collider,
 //Quando o GameObject colide com o colisor do waypoint
 // change the active waypoint to the next one in the array variable "waypoints".
 //Mude o wyapoint ativo para o próximo.
 WPindexPointer++;

 // When the array variable reaches the end of the list ...
 //Quando a matriz de variaveis encontrar o fim da lista...
 if (WPindexPointer >= waypoints.Length)
 {
 // ... reset the active waypoint to the first object in the array variable
 // ... resete o waypoint para o primeiro da lista
 // "waypoints" and start from the beginning.
 //tudo volta para o começo
 WPindexPointer = 0;
 /*
 * teste: Destruir objeto ao chegar ao fim da lista
 */
 Destroy (gameObject, 1f);

 }
 }

 // I declared "Slow()".
 IEnumerator Slow()
 {
 if (slowState == false) //
 {
 // Make sure that if Slow() is running, Accell() can not run.
 accelState = false;
 slowState = true;
 }

 // Begin to do the slow down (or speed up if inertia is set above "1.0" in the inspector).
 currentSpeed = currentSpeed * inertia;
 transform.Translate (0,0,Time.deltaTime * currentSpeed);

 // When the "minSpeed" is reached or exceeded ...
 if (currentSpeed <= minSpeed)
 {
 // ... Stop the movement by setting "currentSpeed to Zero.
 currentSpeed = 0.0f;
 // Wait for the amount of time set in "stopTime" before moving to next waypoint.
 yield return new WaitForSeconds(stopTime);
 // Activate the function "Accell()" to move to next waypoint.
 functionState = 0;
 }

 //=======================================================================================
 // Espaço para o resto do script
 }

}



Eu mantive a parte em ingles, para editar depois caso encontre uma tradução melhor.

É isso, grato e abraços.

COMO ASSIM????

Grato mestre!

Funcionou, só precisei fazer uma leve alteração. a intenção era fazer como os Boos. um inimigo que anda, mas para ao ser visto pela lanterna. Ele só andava quando eu acendia a lanterna, mas pondo "false" no fim do seu script, resolveu. 
Ele ta parando independente da distância em que acendo a luz, Mas vou analisar isso com muita calma. Queria só agradecer pela ajuda, grato!