void Atras()
 {
     actuador.Flotar();
     actuador.Atras();
 }
 /**
  * Metodo principal. Checa si puede avanzar en su direccion, desbloquea segun sea posible y conveniente.
  * */
 void seguimientoCiego(Vector3 lookOnObject)
 {
     distancia = Vector3.Distance(playerObject.position, transform.position);
     if (distancia <= distanceFromObject)
     {
         if (!haciaDonde)             //Si fuimos a cargar bateria, ya llegamos, cargamos y cambiamos vista.
         {
             actuador.CargarBateria();
             cambiaVista();
         }
         return;   //No necesitamos alterar nada, solo flota.
     }
     evitaMuros(); //Checa cuales caras estan disponibles para moverse en ese eje.
     if (bloqueados.Count != 0)
     {
         int toDeque = bloqueados[0];
         if (bloqueados.Contains(0))
         {
             if (!bloqueados.Contains(1))
             {
                 actuador.Ascender();
                 lookOnObject.y = 1;
                 if (candidateToMute.Contains('y'))
                 {
                     mute(1, 0);
                 }
                 if (lastDequed.Contains(1))
                 {
                     candidateToMute.Add('y');
                 }
                 if (toDeque == 0)
                 {
                     removeAt(0);
                 }
             }
         }
         else
         {
             actuador.Descender();
             if (candidateToMute.Contains('y'))
             {
                 mute(0, 1);
             }
             if (lastDequed.Contains(1))
             {
                 candidateToMute.Add('y');
             }
             if (toDeque == 1)
             {
                 removeAt(0);
             }
         }
         if (bloqueados.Contains(5))
         {
             if (!bloqueados.Contains(4))
             {
                 actuador.Izquierda();
                 if (candidateToMute.Contains('x'))
                 {
                     mute(4, 5);
                 }
                 if (lastDequed.Contains(1))
                 {
                     candidateToMute.Add('x');
                 }
                 if (toDeque == 5)
                 {
                     removeAt(0);
                 }
             }
         }
         else
         {
             actuador.Derecha();
             if (candidateToMute.Contains('x'))
             {
                 mute(5, 4);
             }
             if (lastDequed.Contains(1))
             {
                 candidateToMute.Add('x');
             }
             if (toDeque == 4)
             {
                 removeAt(0);
             }
         }
         if (bloqueados.Contains(3))
         {
             if (!bloqueados.Contains(2))
             {
                 actuador.Atras();
                 if (candidateToMute.Contains('z'))
                 {
                     mute(2, 3);
                 }
                 if (lastDequed.Contains(1))
                 {
                     candidateToMute.Add('z');
                 }
                 if (toDeque == 3)
                 {
                     removeAt(0);
                 }
             }
         }
         else
         {
             actuador.Adelante();
             if (candidateToMute.Contains('z'))
             {
                 mute(3, 2);
             }
             if (lastDequed.Contains(1))
             {
                 candidateToMute.Add('z');
             }
             if (toDeque == 2)
             {
                 removeAt(0);
             }
         }
     }
     //Si es conveniente se mueva en esa direccion, lo hace.
     if (lookOnObject.y > 0)
     {
         if (disponibles.Contains(1))
         {
             bloqueados.Remove(1);
         }
         if (!bloqueados.Contains(1))
         {
             actuador.Ascender();
         }
     }
     if (lookOnObject.y < 0)
     {
         if (disponibles.Contains(0))
         {
             bloqueados.Remove(0);
         }
         if (!bloqueados.Contains(0))
         {
             actuador.Descender();
         }
     }
     if (lookOnObject.z > 0)
     {
         if (disponibles.Contains(3))
         {
             bloqueados.Remove(3);
         }
         if (!bloqueados.Contains(3))
         {
             actuador.Adelante();
         }
     }
     if (lookOnObject.z < 0)
     {
         if (disponibles.Contains(2))
         {
             bloqueados.Remove(2);
         }
         if (!bloqueados.Contains(2))
         {
             actuador.Atras();
         }
     }
     if (lookOnObject.x > 0)
     {
         if (disponibles.Contains(5))
         {
             bloqueados.Remove(5);
         }
         if (!bloqueados.Contains(5))
         {
             actuador.Derecha();
         }
     }
     if (lookOnObject.x < 0)
     {
         if (disponibles.Contains(4))
         {
             bloqueados.Remove(4);
         }
         if (!bloqueados.Contains(4))
         {
             actuador.Izquierda();
         }
     }
 }
Exemplo n.º 3
0
    // Update y FixedUpdate son similares en uso, pero por regla general se recomienda usar
    // FixedUpdate para calcular elementos físicos como el uso de Rigidbody
    void FixedUpdate()
    {
        // El agente no realiza ninguna acción si no tiene batería
        if (sensor.Bateria() <= 0)
        {
            return;
        }

        // A continuación se muestran ejemplos de uso de actuadores y sensores
        // para ser utilizados de manera manual (por una persona):

        if (Input.GetKey(KeyCode.I))
        {
            actuador.Ascender();
        }
        if (Input.GetKey(KeyCode.K))
        {
            actuador.Descender();
        }
        if (!Input.GetKey(KeyCode.I) && !Input.GetKey(KeyCode.K))
        {
            actuador.Flotar();
        }

        if (Input.GetAxis("Vertical") > 0)
        {
            actuador.Adelante();
        }
        if (Input.GetAxis("Vertical") < 0)
        {
            actuador.Atras();
        }

        if (Input.GetKey(KeyCode.J))
        {
            actuador.GirarIzquierda();
        }
        if (Input.GetKey(KeyCode.L))
        {
            actuador.GirarDerecha();
        }

        if (Input.GetAxis("Horizontal") > 0)
        {
            actuador.Derecha();
        }
        if (Input.GetAxis("Horizontal") < 0)
        {
            actuador.Izquierda();
        }


        if (sensor.TocandoBasura())
        {
            Debug.Log("Tocando basura!");
            actuador.Limpiar(sensor.GetBasura());
        }
        if (sensor.TocandoPared())
        {
            Debug.Log("Tocando pared!");
        }

        if (sensor.CercaDeBasura())
        {
            Debug.Log("Cerca de una basura!");
        }
        if (sensor.CercaDePared())
        {
            Debug.Log("Cerca de una pared!");
        }

        if (sensor.FrenteAPared())
        {
            Debug.Log("Frente a pared!");
        }


        if (Input.GetKey(KeyCode.F))
        {
            actuador.Detener();
        }
        if (Input.GetKey(KeyCode.G))
        {
            Debug.Log(sensor.Ubicacion());
        }
    }