示例#1
0
 public PetIdleState(PetObject obj) : base(obj)
 {
     m_OwnerTarget    = pet.owner.GetComponent <PlayerTarget>();
     m_OwnerDamagable = pet.owner.GetComponent <DamagableObject>();
     m_PetWeapon      = pet.GetComponent <PetWeapon>();
     m_PetTarget      = pet.GetComponent <PlayerTarget>();
 }
示例#2
0
 public void SetOwner(DamagableObject _owner)
 {
     if (owner == null)
     {
         owner = _owner;
     }
 }
示例#3
0
    protected override void MoveToNext()
    {
        if (currentPathIndex + 1 >= pathToTarget.Count)
        {
            //lock position so drones dont float away
            lockPosition = StartCoroutine(LockPosition(transform.position));

            //a little unclean
            currentTarget  = EnemyPathManager.Instance.EnemyDestination.Occupying.GetComponent <DamagableObject> ();
            explicitTarget = true;

            layersToHit.Add("Target");

            FireCoroutine = StartCoroutine(Fire(currentTarget, currentTarget.GetComponentInChildren <Collider>()));

            Debug.Log(currentTarget.GetComponentInChildren <Collider> ());
            disengaging = false;
        }
        else
        {
            base.MoveToNext();

            if (currentTarget == null)
            {
                LookAt(destinationPosition);
            }
        }
    }
示例#4
0
    IEnumerator Fire()
    {
        firing = true;

        if (rotating != null)
        {
            StopCoroutine(rotating);
        }

        rotating = StartCoroutine(SmoothLookAt(currentTarget.transform));

        yield return(new WaitForSeconds(weaponChargeTime));

        if (currentTarget == null)
        {
            //the target has been destroyed before this got a chance to shoot at it
            firing = false;
            yield break;
        }

        GameObject proj = Instantiate(projectile, transform.position, Quaternion.identity);

        proj.GetComponent <Projectile> ().Launch(currentTarget.transform.position, this.damage, this.projectileSpeed, gameObject, new string[] { "Enemy" });

        currentTarget = null;

        firing = false;
    }
示例#5
0
    //Search for targets if not firing. If there are no targets, disengage
    protected override void Update()
    {
        //Currently attacking
        if (firing == false)
        {
            //Needs a new target
            if (currentTarget == null)
            {
                Collider[] cols = Physics.OverlapSphere(transform.position, attackRange, LayerMask.GetMask("Friendly"));

                if (cols.Length > 0)
                {
                    //decide which enemy to shoot - currently we just pick the first target found
                    currentTarget = cols [0].GetComponentInParent <DamagableObject> ();

                    FireCoroutine = StartCoroutine(Fire(currentTarget, cols[0]));
                    disengaging   = false;
                    //No target found
                }
                else if (disengaging == false)
                {
                    Disengage();
                    disengaging = true;
                }
            }
        }
    }
示例#6
0
    private IEnumerator Fire(DamagableObject target, Collider c)
    {
        firing = true;

        Track(c.transform);

        //the charge sound should finish just as the weapon fires
        if (target is GamePlayer)
        {
            chargeAS.Play();
        }

        yield return(new WaitForSeconds(weaponChargeTime));

        if (c != null)
        {
            OnFire(c);
        }

        firing = false;

        if (explicitTarget == false)
        {
            currentTarget = null;
        }
        else
        {
            FireCoroutine = StartCoroutine(Fire(currentTarget, c));
        }
    }
    void OnCollisionEnter(Collision collision)
    {
        DamagableObject damObj = collision.gameObject.GetComponent <DamagableObject>();

        if (damObj)
        {
            damObj.TakeDamage(damage);
        }
        Destroy(gameObject);
    }
示例#8
0
    void Start()
    {
        this.tag = "Asteroid";
        DamagableObject damObj = gameObject.GetComponent <DamagableObject> ();

        if (damObj)
        {
            damObj.OnDeath += Death;
        }
    }
示例#9
0
    void UpdatePathToTarget(Vector2 distanceBetween, float minDistance)
    {
        if (distanceBetween.x < minDistance && distanceBetween.y < 0.2f)
        {
            if (aiPhase == AIPhase.PathToEnemy)
            {
                aiPhase = AIPhase.InCombat;
            }
            else if (aiPhase == AIPhase.PathToPickup)
            {
                if (targetObject.gameObject.GetComponent <DamagableObject>() != null)
                {
                    enemyControl = targetObject.gameObject.GetComponent <DamagableObject>();
                    aiPhase      = AIPhase.BreakingCrate;
                }
                else
                {
                    GetClosestTarget();
                }
            }
            else if (aiPhase == AIPhase.FreePath)
            {
                if (navPath.Count == 0)
                {
                    GetClosestTarget();
                }
            }
            else
            {
                GetClosestTarget();
            }
        }

        if (jumpPrepare)
        {
            if (playerControl.JumpCount == 0)
            {
                playerControl.Jump();
                jumpPrepare = false;
            }
        }
        else
        {
            if (destinationNode != null)
            {
                MoveTowardsNode(destinationNode);
            }
        }

        if (destinationNode == null || Vector2.Distance(transform.position, destinationNode.node.transform.position) < 0.5f)
        {
            ChooseNextPathNode();
        }
    }
示例#10
0
    // Update is called once per frame
    void Update()
    {
        currentGun = guns[currentGunIndex];


        if (Input.GetKeyDown(KeyCode.Tab))
        {
            if (currentGunIndex + 1 < maxGunIndex)
            {
                currentGunIndex++;
            }
            else
            {
                currentGunIndex = 0;
            }
        }



        if (Input.GetMouseButton(0) && currentGun.canShoot)
        {
            currentGun.canShoot = false;
            StartCoroutine(reloadGun(currentGun));


            if (currentGun.shotType == 0)
            {
                //Debug.Log("Gun shot");
                RaycastHit2D hit = Physics2D.Raycast(gameObject.transform.position, gameObject.transform.up, 30000f, layerMask: LayerMask.GetMask("enemy"));

                Debug.Log(hit.collider.gameObject.tag);
                if (hit.collider.gameObject.tag == "enemy")
                {
                    Debug.Log("Hit enemy");
                    DamagableObject d = hit.collider.GetComponent <DamagableObject>();
                    d.RecieveHit(currentGun.dmg);
                }

                for (int i = 0; i < 300; i++)
                {
                    //GameObject p = Instantiate(particle, nose.position,Quaternion.identity);
                    //p.GetComponent<Rigidbody2D>().AddForce(gameObject.transform.up  * Time.deltaTime, ForceMode2D.Impulse);
                }
            }
            else if (currentGun.shotType == 1)
            {
                GameObject bul = Instantiate(currentGun.bullet, gameObject.transform.position, Quaternion.identity);
                bul.transform.rotation = Quaternion.Euler(bul.transform.rotation.x + 45f, bul.transform.rotation.y + 45f, bul.transform.rotation.z + 45f);
                bul.GetComponent <Rigidbody2D>().AddForce(gameObject.transform.up * miniGunBulSpeed, ForceMode2D.Impulse);
            }
        }
    }
示例#11
0
    private void OnTriggerStay(Collider other)
    {
        DamagableObject damagableObject = other.GetComponent <DamagableObject> ();

        if (damagableObject == null)
        {
            return;
        }

        Vector3 forceDirection = GetForceDirection(other.transform.position);

        damagableObject.GetDamage(m_force, forceDirection, m_damage);
    }
示例#12
0
    void OnCollisionEnter(Collision collision)
    {
        DamagableObject damObj     = collision.gameObject.GetComponent <DamagableObject> ();
        DamagableObject damObjMine = gameObject.GetComponent <DamagableObject> ();

        if (damObj)
        {
            damObj.TakeDamage(damage);
        }
        if (damObjMine)
        {
            damObjMine.TakeDamage(damage);
        }
    }
示例#13
0
    void OnCollisionEnter(Collision col)
    {
        //we have defined layers and this isn't one of them
        if (this.layersToHit == null || (this.layersToHit != null && layersToHit.Contains(LayerMask.LayerToName(col.gameObject.layer))))
        {
            DamagableObject dObj = col.collider.GetComponentInParent <DamagableObject> ();

            if (dObj != null && dObj.enabled)
            {
                dObj.Hit(col.contacts[0].point, this.firedFrom, this.damage);
            }
        }

        Destroy(rootParent.gameObject);
    }
示例#14
0
    private void GetClosestTarget()
    {
        if (playerControl.IsDead)
        {
            return;
        }

        if (Random.Range(0, 100) < 50)
        {
            aiPhase      = AIPhase.PathToEnemy;
            enemyControl = enemies[Random.Range(0, enemies.Count)].GetComponentInParent <PlayerController>();
            GetDestinationPath(enemyControl.transform.position);

            return;
        }

        float distance = 100000;
        int   target   = -1;

        for (int i = 0; i < enemies.Count; i++)
        {
            if (!enemies[i].GetComponent <PlayerController>().IsDead&& !enemies[i].GetComponent <PlayerController>().Invulnerable)
            {
                float tempDistance = Vector2.Distance(enemies[i].position, rigidbody2D.position);
                if (tempDistance < distance)
                {
                    distance = tempDistance;
                    target   = i;
                }
            }
        }

        if (target > -1)
        {
            aiPhase      = AIPhase.PathToEnemy;
            enemyControl = enemies[target].GetComponentInParent <PlayerController>();
            GetDestinationPath(enemyControl.transform.position);
        }
        else
        {
            enemyControl = null;
        }
    }
示例#15
0
    protected override void Update()
    {
        //Attacking
        Collider[] cols = Physics.OverlapSphere(transform.position, range, LayerMask.GetMask("Enemy"));

        if (firing == false)
        {
            if (currentTarget == null)
            {
                foreach (Collider c in cols)
                {
                    if (c.GetComponentInParent <Enemy>() != null && c.GetComponentInParent <Enemy> ().CurrentHealth > 0)
                    {
                        //decide which enemy to shoot - currently we just pick the first target found
                        currentTarget = c.GetComponentInParent <DamagableObject> ();
                        StartCoroutine(Fire());
                        break;
                    }
                }
            }
        }

        base.Update();
    }
示例#16
0
    private void OnParticleCollision(GameObject other)
    {
        DamagableObject damObj = other.GetComponent <DamagableObject>();

        damObj?.TakeDamage();
    }
示例#17
0
 private bool IgnoreListContains(DamagableObject item)
 {
     return(ignoreList.Contains(item));
 }