void Start()
    {
        BlendShape = GetComponentInChildren <SkinnedMeshRenderer> ();
        StartCoroutine(getReady());
        shooter = GetComponentInParent <DragonInterest> ();

        ApplyAngles(Vector2.zero);
        CalculateOffsets();
        previous_angles = rotation_offset;
    }
Example #2
0
 public void Update(DragonInterest DI)
 {
     if (sqrDist < DI.sqrDist2Care)
     {
         interest_ += DI.baseGainSpeed * Time.deltaTime * (inv_sqr_dist);
     }
     else
     {
         interest_ = Mathf.MoveTowards(interest_, minInterest, DI.baseDecreaseSpeed * Time.deltaTime);
     }
     interest_ = Mathf.Clamp(interest_, minInterest, maxInterest);
 }
Example #3
0
    void OnTriggerExit(Collider col)
    {
        DragonInterest DI = col.GetComponentInParent <DragonInterest> ();

        if (DI)
        {
            if (DI.tag == "Pickable")
            {
                RemoveFromSensed(DI, true);
            }
            else if (col.tag == "Vehicle")
            {
                RemoveFromSensed(DI, false);
            }
        }
    }
Example #4
0
    void OnTriggerEnter(Collider col)
    {
        DragonInterest DI = col.GetComponentInParent <DragonInterest> ();

        if (DI)
        {
            if (DI.tag == "Pickable")
            {
                SensedCrystals.Add(DI);
            }
            else if (col.tag == "Vehicle")
            {
                SensedEnemies.Add(DI);
            }
        }
    }
Example #5
0
 public void RemoveFromSensed(DragonInterest item, bool crystal)
 {
     if (crystal)
     {
         if (SensedCrystals.Contains(item))
         {
             SensedCrystals.Remove(item);
         }
     }
     else
     {
         if (SensedEnemies.Contains(item))
         {
             SensedEnemies.Remove(item);
         }
     }
 }
 // Use this for initialization
 void Awake()
 {
     BlendShape = GetComponentInChildren <SkinnedMeshRenderer> ();
     StartCoroutine(getReady());
     shooter = GetComponentInParent <DragonInterest> ();
 }
    IEnumerator Sense()
    {
        while (true)
        {
            //float sum_crystals_temp=0f;
            //float sum_machines_temp=0f;
            float          max_crystals_temp = -0.1f;
            DragonInterest most_machine_temp = null;

            float          max_machines_temp = -0.1f;
            DragonInterest most_crystal_temp = null;

            float          min_sqrDist          = float.PositiveInfinity;
            DragonInterest closest_machine_temp = null;

            float          min_sqrDist_drone  = float.PositiveInfinity;
            DragonInterest closest_drone_temp = null;

            float          min_sqrDist_robot  = float.PositiveInfinity;
            DragonInterest closest_robot_temp = null;

            float          min_sqrDist_tractor  = float.PositiveInfinity;
            DragonInterest closest_tractor_temp = null;

            foreach (DragonInterest interested in DragonManager.Instance.sensable)
            {
                interested.Dragons [interestID].sqrDist = (interested.transform.position - transform.position).sqrMagnitude;
                if (interested.gameObject.tag == "Pickable")
                {
                    //sum_crystals_temp += interested.Dragons [interestID].interest;
                    if (interested.Dragons [interestID].interest > max_crystals_temp)
                    {
                        max_crystals_temp = interested.Dragons [interestID].interest;
                        most_crystal_temp = interested;
                    }
                }
                else
                {
                    //sum_machines_temp += interested.Dragons [interestID].interest;
                    if (interested.Dragons [interestID].interest > max_machines_temp)
                    {
                        max_machines_temp = interested.Dragons [interestID].interest;
                        most_machine_temp = interested;
                    }
                    if (interested.Dragons [interestID].sqrDist < min_sqrDist)
                    {
                        min_sqrDist          = interested.Dragons [interestID].sqrDist;
                        closest_machine_temp = interested;
                    }
                    switch (interested.Type)
                    {
                    case VehicleType.Drone:
                        if (interested.Dragons [interestID].sqrDist < min_sqrDist_drone)
                        {
                            min_sqrDist_drone  = interested.Dragons [interestID].sqrDist;
                            closest_drone_temp = interested;
                        }
                        break;

                    case VehicleType.Tractor:
                        if (interested.Dragons [interestID].sqrDist < min_sqrDist_tractor)
                        {
                            min_sqrDist_tractor  = interested.Dragons [interestID].sqrDist;
                            closest_tractor_temp = interested;
                        }
                        break;

                    case VehicleType.Robot:
                        if (interested.Dragons [interestID].sqrDist < min_sqrDist_robot)
                        {
                            min_sqrDist_robot  = interested.Dragons [interestID].sqrDist;
                            closest_robot_temp = interested;
                        }
                        break;

                    default:
                        throw new System.ArgumentOutOfRangeException();
                    }
                }
                //foreach(KeyValuePair<GameObject, float> k in damage_done){
                //	if (interested.gameObject == k.Key) {
                //		interested.Dragons [interestID].interest += k.Value*damage2interest_factor;
                //	}
                //}
                //interested.Dragons [interestID].interested = 1f / interested.Dragons [interestID].sqrDist;
                yield return(null);
            }
            //sum_crystals = sum_crystals_temp;
            //sum_machines = sum_machines_temp;
//			if (closest_machine != closest_machine_temp) {
//				print ("closest machine changed in "+interestID+" from "+(closest_machine?closest_machine.name:"null") +" to "+(closest_machine_temp?closest_machine_temp.name:"null"));
//			}
            closest_machine = closest_machine_temp;
            closest_drone   = closest_drone_temp;
            closest_tractor = closest_tractor_temp;
            closest_robot   = closest_robot_temp;

            most_crystal = most_crystal_temp;
//			if (most_machine != most_machine_temp) {
//				print ("machine changed in "+interestID+" from "+(most_machine?most_machine.name:"null") +" to "+(most_machine_temp?most_machine_temp.name:"null"));
//			}
            if ((state == DragonActionState.Collect || state == DragonActionState.Patrol || state == DragonActionState.Nest) && max_machines_temp > interest2triggerAttack)
            {
                state = DragonActionState.Attack;
                boredom.Init();
                apathy.Init();
                panic.Init();
            }
            most_machine = most_machine_temp;
            yield return(null);
        }
    }
Example #8
0
 public void DropItem()
 {
     found.transform.SetParent(null);
     RobotGrabber.SetCollidersInItem(found.transform, true);
     found = null;
 }
Example #9
0
        override public void Update()
        {
            base.Update();
            if (DB.atPoint)
            {
                if (hasCrystal)
                {
                    //put crystal
                    DropItem();
                }
                else
                {
                    //take crystal
                    foreach (DragonInterest sensed in DB.DS.SensedCrystals)
                    {
                        if (sensed == DB.DSA.most_crystal)
                        {
                            found = sensed;
                            break;
                        }
                    }
                    if (found)
                    {
                        RobotGrabber.SetCollidersInItem(found.transform, false);
                        found.transform.SetParent(HoldingPoint);
                        found.transform.localPosition = Vector3.zero;
                        DB.SetNewTarget(DragonManager.Instance.nests [Random.Range(0, DragonManager.Instance.nests.Length)].position);
                    }
                    else
                    {
                        print("smth wrong with grabbing crystal");
                    }
                }
            }
            else
            {
                if (DB.path_built)
                {
                    float sqrDist2target = (DB.targetPoint - DB.transform.position).sqrMagnitude;
                    if (sqrDist2target < sqrDist2Land)
                    {
                        DB.atPoint = true;

                        DB.DM.flying = false;
                    }
                    else
                    {
                        float dist2body = (DB.DM.transform.position - DB.transform.position).sqrMagnitude;
                        if (dist2body < sqrDist2Keep)
                        {
                            DB.progress += (dist2Keep) / DB.curve.length * Time.deltaTime;
                            Vector3 dir = DB.curve.GetPointAt(DB.progress + Time.deltaTime) - DB.curve.GetPointAt(DB.progress);
                            dir.y = 0;
                            if (dir != Vector3.zero)
                            {
                                DB.transform.rotation = Quaternion.LookRotation(dir);
                            }
                            DB.transform.position = DB.curve.GetPointAt(DB.progress);
                            DB.DM.flying          = true;
                        }
                    }
                }
            }
        }