private void Awake()
 {
     this.projectileController = base.GetComponent <ProjectileController>();
     this.projectileDamage     = base.GetComponent <ProjectileDamage>();
     this.stopwatch            = this.maxCoefficient;
     Debug.LogWarning($"start stopwatch: {this.stopwatch}");
 }
Esempio n. 2
0
    void OnCollisionEnter2D(Collision2D collision)
    {
        ProjectileController projectile = collision.gameObject.GetComponent <ProjectileController> ();

        if (projectile && projectile.gameObject.tag == "Projectile")
        {
            health -= projectile.projectileDamage;
            projectile.Hit(health, gameObject);
        }
        // the impulse is taken from health for damage
        if (collision.gameObject.tag == "Projectile" ||
            collision.gameObject.tag == "Vessel" ||
            collision.gameObject.tag == "Scenery")
        {
            health -= collision.relativeVelocity.magnitude * collision.gameObject.GetComponent <Rigidbody2D>().mass / 20;
        }

        if (health <= 0f)
        {
            Die();
        }

        if (collision.gameObject.tag == "CivWp")
        {
            Destroy(collision.gameObject);
        }
    }
Esempio n. 3
0
    //applies kinetic effects
    private void ApplyKinetics(ProjectileController controller)
    {
        for (int i = 0; i < 3; i++)
        {
            switch (currentSpell.spellKinetics [i])
            {
            case -1: break;

            case 0: controller.LatchingKinetic(); break;

            case 1: controller.BlockingKinetic(); break;

            case 2: controller.EtherealKinetic(); break;

            case 3: controller.GuidedKinetic(); break;

            case 4: controller.PiercingKinetic(); break;

            case 5: controller.ReboundingKinetic(); break;

            case 6: controller.SeekingKinetic(); break;

            case 7: controller.ChainingKinetic(); break;
            }
        }
    }
Esempio n. 4
0
    private void OnTriggerEnter2D(Collider2D collision)
    {
        switch (collision.gameObject.tag)
        {
        case "Projectile":
            ProjectileController projectile = collision.gameObject.GetComponent <ProjectileController>();
            if (projectile.GetOwnerID() == photonView.Owner.UserId)
            {
                return;
            }
            if (!photonView.IsMine)
            {
                collision.gameObject.SetActive(false);
            }
            else
            {
                photonView.RPC("RPCSetDamage", RpcTarget.All, projectile.damage);    // collision.gameObject.GetPhotonView().InstantiationId, projectile.damage);
            }
            break;

        case "Collectible":
            CollectItem(collision.gameObject);
            break;

        default:
            break;
        }
    }
Esempio n. 5
0
    void Update()
    {
        GameObject blackBall = GameObject.Find("BlackBall");

        if (blackBall != null && GameMaster.levelReady)
        {
            ProjectileController blackBallScript = blackBall.GetComponent <ProjectileController>();

            if (blackBallScript.neighbours.Count == 0)
            {
                GameMaster.levelReady = false;
                stopBalls();
                changeLevel();
            }
        }


        //Debug to finish level
        if (Input.GetKey(KeyCode.Keypad3) && GameMaster.levelReady)
        {
            GameMaster.levelReady = false;
            stopBalls();
            changeLevel();
        }


        //Debug colors
        if (Input.GetKey(KeyCode.Keypad2))
        {
            ColorManager.checkAvailableColor();
        }
    }
Esempio n. 6
0
    private void PlayerCombat()
    {
        if (Input.GetMouseButtonDown(0))
        {
            isCasting = true;
        }
        if (Input.GetMouseButtonUp(0))
        {
            isCasting = false;
        }

        if (!isCasting)
        {
            timeBetweenCasts = 0;
        }
        else
        {
            timeBetweenCasts -= Time.deltaTime;
            if (timeBetweenCasts <= 0)
            {
                timeBetweenCasts = projCastSpeed;
                ProjectileController newProjectile = Instantiate(projectile, castFromPoint.position, castFromPoint.rotation) as ProjectileController;
                newProjectile.speed = projTravelSpeed;
            }
        }
    }
Esempio n. 7
0
    private void OnTriggerEnter2D(Collider2D collider)
    {
        TeamAssigner         teamAssigner = collider.GetComponent <TeamAssigner>();
        ProjectileController projectile   = collider.GetComponent <ProjectileController>();

        if (projectile != null)
        {
            if (projectile.firingTeam != firingTeam)
            {
                Destroy(projectile.gameObject);
                Destroy(gameObject);
                return;
            }
        }

        if (collider.isTrigger || teamAssigner != null && firingTeam == teamAssigner.team)
        {
            return;
        }
        else
        {
            HealthTracker healthTracker = collider.GetComponent <HealthTracker>();
            if (healthTracker != null)
            {
                healthTracker.TakeDamage(weaponInfo.damage);
            }
            Destroy(gameObject);
        }
    }
            private void ClearNearbyProjectiles()
            {
                float num  = cfgHoustonRadius.Value;
                float num2 = num * num;
                List <ProjectileController> instancesList = InstanceTracker.GetInstancesList <ProjectileController>();
                List <ProjectileController> list          = new List <ProjectileController>();
                int i     = 0;
                int count = instancesList.Count;

                while (i < count)
                {
                    ProjectileController projectileController = instancesList[i];
                    if (projectileController.teamFilter.teamIndex != teamIndex && (projectileController.transform.position - characterMaster.GetBody().corePosition).sqrMagnitude < num2)
                    {
                        list.Add(projectileController);
                    }
                    i++;
                }
                int j      = 0;
                int count2 = list.Count;

                while (j < count2)
                {
                    ProjectileController projectileController2 = list[j];
                    if (projectileController2)
                    {
                        UnityEngine.Object.Destroy(projectileController2.gameObject);
                    }
                    j++;
                }
            }
Esempio n. 9
0
    private void FireballAttack()
    {
        int numberProjectile = PlayerCharacteristics.GetValue(PowerShape.Type.FIRE_BALL_UP1) ? 3 : 1;

        for (int i = 0; i < numberProjectile; i++)
        {
            // Generate fireball
            GameObject fireball = Instantiate(fireballModel);
            fireball.transform.position = fireballOrigins[i].position;
            fireball.transform.right    = fireballOrigins[i].right;
            fireball.transform.SetParent(objects.transform);

            ProjectileController projectileController = fireball.GetComponent <ProjectileController>();
            projectileController.Shoot(fireball.transform.up, gameObject.tag, GameParameters.fireballSpeed, damage);

            CircleCollider2D fireballCollider = fireball.GetComponent <CircleCollider2D>();
            // Ignore collision between the player and the fireball (trigger ok)
            Physics2D.IgnoreCollision(mainCollider, fireballCollider);
            if (rockshield.Count > 0)
            {
                IgnoreCollisionWithRockShield(fireballCollider);
            }
            if (airshield != null)
            {
                IgnoreCollisionWithAirShield(fireballCollider);
            }
        }
    }
Esempio n. 10
0
        private void FireServer(Ray aimRay, float scale)
        {
            FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
            {
                projectilePrefab   = Projectiles.yokoPiercingRoundPrefab,
                position           = aimRay.origin,
                rotation           = Util.QuaternionSafeLookRotation(aimRay.direction),
                owner              = base.gameObject,
                damage             = YokoPiercingRifle.damageCoefficient * this.damageStat * scale,
                force              = 100f,
                crit               = base.RollCrit(),
                damageColorIndex   = DamageColorIndex.Default,
                target             = null,
                speedOverride      = YokoPiercingRifle.throwForce,
                fuseOverride       = -1f,
                damageTypeOverride = null
            };
            GameObject           gameObject = UnityEngine.Object.Instantiate <GameObject>(fireProjectileInfo.projectilePrefab, fireProjectileInfo.position, fireProjectileInfo.rotation);
            ProjectileController component  = gameObject.GetComponent <ProjectileController>();

            component.NetworkpredictionId = 0;
            ProjectileManager.InitializeProjectile(component, fireProjectileInfo);
            var scaleProjectileController = gameObject.GetComponent <ScaleProjectileController>();

            scaleProjectileController.NetworkChargeRate = scale;
            NetworkServer.Spawn(gameObject);
        }
Esempio n. 11
0
    void OnCollisionEnter(Collision collider)
    {
        // when something collides with our ship, we check its layer to see if it is a projectile
        // (Note: remember when you add projectiles to set the layers correctly!)
        // by default, we're using layer 17 for projectiles fired by enemies and layer 9 for projectiles fired
        // by the main player but all we need to know here is that it *is* a projectile of any type

        if (!isRespawning && !isInvulnerable)        // make sure no respawning or invulnerability is happening
        {
            // temp ref to this collider's gameobject so that we don't need to keep looking it up
            tempGO = collider.gameObject;

            // do a quick layer check to make sure that these are in fact projectiles
            if (tempGO.layer == 17 || tempGO.layer == 9)
            {
                // grab a ref to the projectile's controller
                aProj = tempGO.GetComponent <ProjectileController>();

                // quick check to make sure that this projectile was not launched by this player
                if (aProj.ownerType_id != id)
                {
                    // tell the hit function about this collision, passing in the gameobject so that we can
                    // get to its projectile controller script and find out more about where it came from
                    Hit();

                    // tell our battle controller that we got hit
                    battleControl.Fragged();

                    // tell the global battle controller who fragged us
                    GlobalBattleManager.Instance.RegisterFrag(aProj.ownerType_id);
                }
            }
        }
    }
Esempio n. 12
0
    protected override void LoadUpProjectile(ProjectileController projectileController)
    {
        base.LoadUpProjectile(projectileController);
        RocketProjectileController rocketController = projectileController as RocketProjectileController;

        rocketController.correctionPower = correctionPower;
    }
        private void Start()
        {
            this.projectileController = base.GetComponent <ProjectileController>();
            this.projectileDamage     = base.GetComponent <ProjectileDamage>();

            this.ResetOverlap();
        }
 // Token: 0x060015D7 RID: 5591 RVA: 0x0005D1FC File Offset: 0x0005B3FC
 private Transform FindAttachmentTransform()
 {
     this.projectileGhostController = base.GetComponent <ProjectileGhostController>();
     if (this.projectileGhostController)
     {
         Transform authorityTransform = this.projectileGhostController.authorityTransform;
         if (authorityTransform)
         {
             ProjectileController component = authorityTransform.GetComponent <ProjectileController>();
             if (component)
             {
                 GameObject owner = component.owner;
                 if (owner)
                 {
                     ModelLocator component2 = owner.GetComponent <ModelLocator>();
                     if (component2)
                     {
                         Transform modelTransform = component2.modelTransform;
                         if (modelTransform)
                         {
                             ChildLocator component3 = modelTransform.GetComponent <ChildLocator>();
                             if (component3)
                             {
                                 return(component3.FindChild(this.attachmentString));
                             }
                         }
                     }
                 }
             }
         }
     }
     return(null);
 }
    public virtual Transform MakeProjectile(int ownerID)
    {
        // create a projectile
        theProjectile         = SpawnController.Instance.Spawn(projectileGO, myTransform.position + spawnPosOffset + (myTransform.forward * launchForwardOffset), myTransform.rotation);
        theProjectileGO       = theProjectile.gameObject;
        theProjectileGO.layer = myLayer;

        // grab a ref to the projectile's controller so we can pass on some information about it
        theProjectileController = theProjectileGO.GetComponent <ProjectileController>();

        // set owner ID so we know who sent it
        theProjectileController.SetOwnerType(ownerID);

        Physics.IgnoreLayerCollision(myTransform.gameObject.layer, myLayer);

        // NOTE: Make sure that the parentCollider is a collision mesh which represents the firing object
        // or a collision mesh likely to be hit by a projectile as it is being fired from the vehicle.
        // One limitation with this system is that it only reliably supports a single collision mesh

        if (parentCollider != null)
        {
            // disable collision between 'us' and our projectile so as not to hit ourselves with it!
            Physics.IgnoreCollision(theProjectile.GetComponent <Collider>(), parentCollider);
        }

        // return this projectile incase we want to do something else to it
        return(theProjectile);
    }
Esempio n. 16
0
    // Fires the Weapon
    public void Fire()
    {
        CurrentAmmo  -= 1;
        _timeBtwShots = Weapon.FireRate;

        // Fire Effect
        Instantiate(FireEffect, ShotPoint.position, ShotPoint.rotation);
        // Recoiling the weapon
        if (Weapon.HasRecoil)
        {
            WeaponRecoiler.AddRecoil();
        }

        //Sound effect
        SoundManager.PlaySound(Weapon.FireSound, transform.position);

        // Creating bullets
        for (int i = 0; i < Weapon.BulletPerShot; i++)
        {
            float angelBtwBullets       = 10f;
            float zRotation             = ((1 - Weapon.BulletPerShot) * angelBtwBullets / 2) + (angelBtwBullets * i);
            ProjectileController bullet = Instantiate(Weapon.Bullet, ShotPoint.position, Quaternion.Euler(new Vector3(0, 0, ShotPoint.rotation.eulerAngles.z + zRotation)));
            bullet.ShotByPlayer = (transform.root.tag == "Player");
        }
    }
    //On collision with another ball
    void OnTriggerEnter(Collider other)
    {
        //Adds colliding ball to neighbour list. Second condition is to prevent blackBall from having grey neighbours
        if (other.tag == "BigBall" && !(gameObject.name == "BlackBall" && other.gameObject.renderer.material.color == Color.grey))
        {
            neighbours.Add(other.gameObject);
        }


        //If other target is smallBall ->destroy the smallBall
        if (other.tag == "SmallBall" && !other.transform.IsChildOf(transform) && this.tag != "MagazinedBall" && this.tag != "Floater")
        {
            //Rotate cluster according to impact
            Vector3 deltaVec   = other.transform.position - blackBall.transform.position;
            Vector3 rotateAxis = Vector3.Cross(deltaVec, direction);
            Vector3 sumVec     = deltaVec + direction;

            Vector3           ortogVec = Vector3.Cross(rotateAxis, deltaVec);
            float             rotSpeed = Vector3.Dot(ortogVec, sumVec);
            ClusterController clustCon = Camera.main.GetComponent <ClusterController>();
            clustCon.setVectors(rotSpeed * 30, rotateAxis);

            //Destroy the projectile's smallball
            GameObject           smallBall        = other.gameObject;
            GameObject           projectile       = smallBall.transform.parent.gameObject;
            ProjectileController projectileScript = projectile.GetComponent <ProjectileController>();
            projectileScript.collided = true;
            Destroy(smallBall);
        }

        if (other.tag == "Perimeter")
        {
            insidePerimeter = true;
        }
    }
Esempio n. 18
0
        public override void OnSkillLeveledUp(int level, CharacterBody characterBody, SkillDef skillDef)
        {
            base.OnSkillLeveledUp(level, characterBody, skillDef);
            var capedLevel        = Math.Min(25, level);
            var shadesWhirlPrefab = Projectiles.shadesWhirlPrefab;

            if (shadesWhirlPrefab)
            {
                var projectileDotZone = shadesWhirlPrefab.GetComponent <ProjectileDotZone>();
                if (projectileDotZone)
                {
                    projectileDotZone.damageCoefficient = AdditiveScaling(0.10f, 0.02f, capedLevel); // increase Dot damage by 20% every level (linear)
                }
                ProjectileController projectileController = shadesWhirlPrefab.GetComponent <ProjectileController>();
                if (projectileController)
                {
                    projectileController.ghostPrefab.transform.localScale = Vector3.one * AdditiveScaling(4.0f, 0.6f, capedLevel);// increase shades size by 15% every level (linear)
                }
                var hitbox = shadesWhirlPrefab.GetComponentInChildren <HitBox>();
                if (hitbox)
                {
                    hitbox.transform.localScale = new Vector3(8.0f, 3.0f, 8.0f) * AdditiveScaling(1.0f, 0.15f, capedLevel);
                }
            }
        }
        protected void FireChild(Vector3 direction)
        {
            GameObject           gameObject = UnityEngine.Object.Instantiate <GameObject>(this.childrenProjectilePrefab, base.transform.position, Util.QuaternionSafeLookRotation(direction));
            ProjectileController component  = gameObject.GetComponent <ProjectileController>();

            if (component)
            {
                component.procChainMask   = this.projectileController.procChainMask;
                component.procCoefficient = this.projectileController.procCoefficient;
                component.Networkowner    = this.projectileController.owner;
            }
            gameObject.GetComponent <TeamFilter>().teamIndex = base.GetComponent <TeamFilter>().teamIndex;
            ProjectileDamage component2 = gameObject.GetComponent <ProjectileDamage>();

            if (component2)
            {
                component2.damage           = this.projectileDamage.damage * this.childrenDamageCoefficient;
                component2.crit             = this.projectileDamage.crit;
                component2.force            = this.projectileDamage.force;
                component2.damageColorIndex = this.projectileDamage.damageColorIndex;
            }
            if (gameObject.GetComponent <ProjectileStickOnImpact>() != null)
            {
                ProjectileStickOnImpact stickComponent = gameObject.GetComponent <ProjectileStickOnImpact>();
                stickComponent.TrySticking(hitEnemyCollider, hitEnemyInfo.estimatedImpactNormal);
            }
            NetworkServer.Spawn(gameObject);
        }
Esempio n. 20
0
        private static void CreateVoidBlast()
        {
            voidBlastPrefab = CloneProjectilePrefab("CommandoGrenadeProjectile", "NemryVoidBlastProjectile");

            ProjectileImpactExplosion bombImpactExplosion = voidBlastPrefab.GetComponent <ProjectileImpactExplosion>();

            InitializeImpactExplosion(bombImpactExplosion);

            bombImpactExplosion.blastRadius    = 8f;
            bombImpactExplosion.destroyOnEnemy = true;
            bombImpactExplosion.lifetime       = 12f;
            bombImpactExplosion.impactEffect   = Resources.Load <GameObject>("Prefabs/Effects/NullifierExplosion");
            //bombImpactExplosion.lifetimeExpiredSound = Modules.Assets.CreateNetworkSoundEventDef("HenryBombExplosion");
            bombImpactExplosion.timerAfterImpact    = true;
            bombImpactExplosion.lifetimeAfterImpact = 0.1f;

            ProjectileDamage bombDamage = voidBlastPrefab.GetComponent <ProjectileDamage>();

            bombDamage.damageType = DamageType.Nullify;

            ProjectileController bombController = voidBlastPrefab.GetComponent <ProjectileController>();

            bombController.ghostPrefab = Resources.Load <GameObject>("Prefabs/ProjectileGhosts/NullifierPreBombGhost");
            bombController.startSound  = "";

            voidBlastPrefab.GetComponent <Rigidbody>().useGravity = false;
        }
        private void OnTriggerEnter(Collider other)
        {
            other.GetComponent <TeamFilter>();
            Rigidbody            component  = other.GetComponent <Rigidbody>();
            ProjectileController component2 = other.GetComponent <ProjectileController>();
            ProjectileDamage     component3 = other.GetComponent <ProjectileDamage>();

            if (component && !ReflectedProjectileTracker.rigidBodies.Contains(component) && component2 && component3)
            {
                if (component2.teamFilter.teamIndex != teamFilter.teamIndex)
                {
                    component2.teamFilter.teamIndex = teamFilter.teamIndex;
                    if (component2.owner)
                    {
                        component.rotation = Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position);
                    }
                }

                component2.procCoefficient = 0;
                var tracker = component2.gameObject.AddComponent <ReflectedProjectileTracker>();
                tracker.rigidBody = component;
                ProjectileManager.instance.FireProjectile(other.gameObject, other.transform.position, Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position),
                                                          component2.owner, damageMultiplier, component3.force, component3.crit, component3.damageColorIndex, component2.owner);
                Destroy(other.gameObject);
            }
        }
Esempio n. 22
0
        private static void CreateBazookaRocket()
        {
            bazookaRocketPrefab = CloneProjectilePrefab("CommandoGrenadeProjectile", "HenryBazookaRocketProjectile");
            bazookaRocketPrefab.AddComponent <Modules.Components.BazookaRotation>();
            bazookaRocketPrefab.transform.localScale *= 2f;

            ProjectileImpactExplosion bazookaImpactExplosion = bazookaRocketPrefab.GetComponent <ProjectileImpactExplosion>();

            InitializeImpactExplosion(bazookaImpactExplosion);

            bazookaImpactExplosion.blastRadius    = 8f;
            bazookaImpactExplosion.destroyOnEnemy = true;
            bazookaImpactExplosion.lifetime       = 12f;
            bazookaImpactExplosion.impactEffect   = Modules.Assets.bazookaExplosionEffect;
            //bazookaImpactExplosion.lifetimeExpiredSound = Modules.Assets.CreateNetworkSoundEventDef("HenryBazookaExplosion");
            bazookaImpactExplosion.timerAfterImpact    = true;
            bazookaImpactExplosion.lifetimeAfterImpact = 0f;

            ProjectileController bazookaController = bazookaRocketPrefab.GetComponent <ProjectileController>();

            GameObject bazookaGhost = CreateGhostPrefab("HenryBazookaRocketGhost");

            bazookaGhost.GetComponentInChildren <ParticleSystem>().gameObject.AddComponent <Modules.Components.DetachOnDestroy>();

            bazookaController.ghostPrefab = bazookaGhost;
            bazookaController.startSound  = "";
        }
    protected override void Fire()
    {
        float face = (float)characterMotor.FaceDirection;

        foreach (var fireStyle in fireStyles)
        {
            ProjectileController projectileController = projectileType.Get <ProjectileController>();
            fireOffset   = fireStyle.offset;
            fireRotation = fireStyle.rotation;
            LoadUpProjectile(projectileController);
            float   rad      = fireStyle.direction * Mathf.Deg2Rad;
            Vector3 velocity = new Vector3(Mathf.Cos(rad) * face, Mathf.Sin(rad), 0).normalized *firePower;
            projectileController.Fire(velocity);
        }

        if (attackSound)
        {
            _audioSource.PlayOneShot(attackSound.Source);
        }
        if (fireShake != Vector3.zero)
        {
            CameraManager.Shake(transform.position, fireShake);
        }
        if (fireEffect)
        {
            BurstParticleController explosion = fireEffect.Get <BurstParticleController>();
            explosion.transform.position = transform.position + new Vector3(transform.lossyScale.x / 2f, 0, 0);
            explosion.Burst();
        }
    }
Esempio n. 24
0
    /*
     * For the most part this is very similar to the Shoot() coroutine in my GunController. I should
     * work to combine these ideas into a more generic "Shootable" interface (maybe Fireable? shootable
     * sort of implies that it's being hit by the shot)
     */
    void Shoot()
    {
        if (target == null)
        {
            Debug.LogError("Error: No target for this EnemyShooter Shoot method.");
        }

        canShoot = false;
        GameObject thisShot =
            (GameObject)Instantiate(projectilePrefab, transform.position + new Vector3(0f, -1.5f, 0f), transform.rotation);
        ProjectileController shotController = thisShot.GetComponent <ProjectileController> ();

        shotController.spawnerTag = gameObject.tag;
        shotController.speed      = shotSpeed;
        shotController.shotDamage = shotDamage;
        shotController.gameObject.transform.LookAt(target.gameObject.transform);


        // right now this won't work as the shot isn't rotated to face the player
        shotController.GetComponent <Rigidbody> ().velocity =
            shotController.transform.forward * shotController.speed;

        /*
         * shotController.GetComponent<Rigidbody> ().velocity =
         *      Vector3.down * shotController.speed;
         */

        Invoke("ResetShoot", shootDelay);
    }
Esempio n. 25
0
 public void Render()
 {
     TowerController.Render();
     EnemyController.Render();
     ProjectileController.Render();
     Statistics.Render();
 }
Esempio n. 26
0
    // Use this for initialization
    void Start()
    {
        this.currentWeapon = 0;
        this.SwitchWeapons();

        projectiles = GetComponent <ProjectileController>();
    }
    public IEnumerator Enemy_BatHealthOnImpact3()
    {
        NetworkServer.Listen(7777);
        Instantiate(Resources.Load("Tests/maincanvas"));
        Instantiate(Resources.Load("Tests/maincamera"));
        Instantiate(Resources.Load("Tests/gamemanager"));
        GameObject enemyBat   = Instantiate(Resources.Load("Tests/Enemy_Bat 1")) as GameObject;
        GameObject projectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject;

        enemyBat.transform.position   = new Vector2(0, 0);
        projectile.transform.position = new Vector2(5, 0);
        ProjectileController pc = projectile.GetComponent <ProjectileController> ();

        pc.setVelocityAndRotation(new Vector2(-4, 0), 0);

        int startHp = enemyBat.GetComponentInChildren <Enemy> ().hp;
        int damage  = startHp - 1;

        pc.projectileDamage = damage;

        yield return(new WaitForSeconds(5));

        GameObject[] spawnedEnemyBatList = GameObject.FindGameObjectsWithTag("Enemy");
        GameObject   spawnedEnemyBat     = spawnedEnemyBatList[0];
        Enemy        enemyScript         = spawnedEnemyBat.GetComponent <Enemy>();
        int          expectedhealth      = startHp - damage;

        Assert.AreEqual(expectedhealth, enemyScript.hp);
    }
Esempio n. 28
0
    private void OnTriggerEnter2D(Collider2D otherCollider)
    {
        ProjectileController projectile = null;
        int destructionLevel            = CONSTRUCTION_LEVEL_INVALID;

        //Debug.Log("Debug : ObstacleController : on trigger enter.");
        if (otherCollider.gameObject != null)
        {
            projectile = otherCollider.gameObject.GetComponent <ProjectileController>();
            if (projectile != null)
            {
                destructionLevel = projectile.GetDestructionLevel();
                if ((destructionLevel != CONSTRUCTION_LEVEL_INVALID) && (destructionLevel >= constructionLevel))
                {
                    /*halmeida - in this case, the projectile may affect the obstacle.*/
                    if (projectile.GetEffectCode() == ProjectileController.EFFECT_CODE_HP_DAMAGE)
                    {
                        DamageObstacle(projectile.GetEffectIntensity(), otherCollider.gameObject);
                    }
                    else if (projectile.GetEffectCode() == ProjectileController.EFFECT_CODE_HP_RECOVERY)
                    {
                        DamageObstacle(projectile.GetEffectIntensity() * -1f, otherCollider.gameObject);
                    }
                }
                projectile.Deactivate();
            }
        }
    }
Esempio n. 29
0
        // Token: 0x06001854 RID: 6228 RVA: 0x00069274 File Offset: 0x00067474
        private static void SetProjectilePrefabs(GameObject[] newProjectilePrefabs)
        {
            ProjectileCatalog.projectilePrefabs = HGArrayUtilities.Clone <GameObject>(newProjectilePrefabs);
            int num = 256;

            if (ProjectileCatalog.projectilePrefabs.Length > num)
            {
                Debug.LogErrorFormat("Cannot have more than {0} projectile prefabs defined, which is over the limit for {1}. Check comments at error source for details.", new object[]
                {
                    num,
                    typeof(byte).Name
                });
                for (int i = num; i < ProjectileCatalog.projectilePrefabs.Length; i++)
                {
                    Debug.LogErrorFormat("Could not register projectile [{0}/{1}]=\"{2}\"", new object[]
                    {
                        i,
                        num - 1,
                        ProjectileCatalog.projectilePrefabs[i].name
                    });
                }
            }
            ProjectileCatalog.projectilePrefabProjectileControllerComponents = new ProjectileController[ProjectileCatalog.projectilePrefabs.Length];
            ProjectileCatalog.projectileNames = new string[ProjectileCatalog.projectilePrefabs.Length];
            for (int j = 0; j < ProjectileCatalog.projectilePrefabs.Length; j++)
            {
                GameObject           gameObject = ProjectileCatalog.projectilePrefabs[j];
                ProjectileController component  = gameObject.GetComponent <ProjectileController>();
                component.catalogIndex = j;
                ProjectileCatalog.projectilePrefabProjectileControllerComponents[j] = component;
                ProjectileCatalog.projectileNames[j] = gameObject.name;
            }
        }
    public IEnumerator Enemy_BatDestroyOnImpact3()
    {
        NetworkServer.Listen(7777);
        Instantiate(Resources.Load("Tests/maincanvas"));
        Instantiate(Resources.Load("Tests/maincamera"));
        Instantiate(Resources.Load("Tests/gamemanager"));
        GameObject enemyBat = Instantiate(Resources.Load("Tests/Enemy_Bat 1")) as GameObject;

        enemyBat.transform.position = new Vector2(0, 0);
        GameObject demoprojectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject;
        int        starthealth    = enemyBat.GetComponentInChildren <Enemy> ().hp;
        int        damage         = demoprojectile.GetComponent <ProjectileController> ().getProjectileDamage();
        int        count          = starthealth / damage;


        for (int i = 0; i < count - 1; i++)
        {
            GameObject projectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject;
            projectile.transform.position = new Vector2(5, 0);
            ProjectileController pc = projectile.GetComponent <ProjectileController> ();
            pc.setVelocityAndRotation(new Vector2(-4, 0), 0);
            //projectile [i] = projectile;
        }
        yield return(new WaitForSeconds(5));

        Assert.AreEqual((GameObject.FindGameObjectsWithTag("Enemy")).Length, 1);
    }
 public void handleProjectileHit(ProjectileController projectile)
 {
     if (projectile.Owner == GameplayManager.Samus && m_invincibilityCounter <= 0)
     {
         GameplayManager.Samus.model.setStat("damageDone", GameplayManager.Samus.model.getStat("damageDone") + projectile.Damage);
         handleSamusProjectileHit(projectile);
     }
 }
        protected override void handleSamusProjectileHit(ProjectileController projectile)
        {
            projectile.handleSceneryHit();

            if (projectile.Freezes)
            {
                this.m_frozenCounter = s_frozenDuration;
                this.m_collider.m_type = ColliderType.FrozenEnemy;

                this.m_invincibilityCounter = s_invincibilityDuration;
            }
        }
        protected virtual void handleSamusProjectileHit(ProjectileController projectile)
        {
            projectile.handleSceneryHit();

            if (projectile.Freezes && this.Health <= this.MaxHealth / 2 && !this.IsFrozen)
            {
                this.m_frozenCounter = s_frozenDuration;
                this.m_collider.m_type = ColliderType.FrozenEnemy;

                this.m_invincibilityCounter = s_invincibilityDuration;
            }
            else
            {
                this.takeDamage(projectile.Damage);

                if (this.Health <= 0)
                {
                    Vector2 explosion = new Vector2(
                        m_position.X,
                        m_position.Y - (float)m_collider.Bounds.Height / 2);
                    GameplayManager.ActiveZone.add(new BulletExplosion(explosion, 8.0f));
                }
            }
        }
Esempio n. 34
0
    private void UpgradeProjectile(ProjectileController projectile, WeaponType weaponType)
    {
        if (GetWeaponRank(weaponType) < 5)
        {
            projectile.Damage *= 1.25f;
        }
        else if (GetWeaponRank(weaponType) < 10)
        {
            projectile.Damage *= 1.15f;
        }
        else
        {
            projectile.Damage *= 1.05f;
        }

        ObjectChaser chaser = projectile.GetComponent<ObjectChaser>();
        if (chaser != null)
        {
            //increase weapon stats
            if (GetWeaponRank(weaponType) < 5)
            {
                chaser.Delay /= 1.25f;
                chaser.Precision *= 1.25f;
            }
            else if (GetWeaponRank(weaponType) < 10)
            {
                chaser.Delay /= 1.15f;
                chaser.Precision *= 1.15f;
            }
            else
            {
                chaser.Delay /= 1.05f;
                chaser.Precision *= 1.05f;
            }
        }
    }
Esempio n. 35
0
        public override void LoadContent()
        {
            ContentManager content = ScreenManager.Game.Content;

            map = content.Load<Map>("map");
            MapGeneration.Generate(map);

            camera = new Camera(ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight, map);

            //camera.Zoom = 0.5f;

            text = content.Load<Texture2D>("titles");

            hud = new HUD(content.Load<Texture2D>("hud"));

            waterLevel = ScreenManager.Game.RenderHeight;
            waterParallax = new Parallax(content.Load<Texture2D>("abovewater-parallax"), 12, 0.5f, waterLevel, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, true);
            underwaterBGParallax = new Parallax(content.Load<Texture2D>("underwater-bg"), 4, 1f, waterLevel + 20, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), true, false);
            skyBGParallax = new Parallax(content.Load<Texture2D>("sky-bg"), 72, 1f, 70, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false);
            rocksParallax = new Parallax(content.Load<Texture2D>("seabed-rocks"), 16, 0.35f, (map.TileHeight*map.Height) -15, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false);
            cloudsParallax = new Parallax(content.Load<Texture2D>("clouds"), 16, 0.35f, 25, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false, true);

            playerShip = new Ship(content.Load<Texture2D>("playership"), new Rectangle(0,0,10,10), null, Vector2.Zero);
            playerShip.Position = new Vector2(64, 190);

            particleController.LoadContent(content);

            projectileController = new ProjectileController(1000, sheet => new Projectile(sheet, new Rectangle(0, 0, 4, 4), null, new Vector2(0, 0)) , content.Load<Texture2D>("projectiles"));
            enemyController = new EnemyController(content.Load<Texture2D>("enemies"), content.Load<Texture2D>("boss"));
            powerupController = new PowerupController(1000,sheet => new Powerup(sheet, new Rectangle(0, 0, 6, 6), null, Vector2.Zero),content.Load<Texture2D>("powerup"));

            powerupController.BoxCollidesWith.Add(playerShip);
            projectileController.BoxCollidesWith.Add(playerShip);
            projectileController.BoxCollidesWith.Add(enemyController);
            projectileController.BoxCollidesWith.Add(projectileController);
            enemyController.BoxCollidesWith.Add(playerShip);
            enemyController.BoxCollidesWith.Add(projectileController);

            GameController.Reset();

            //enemyController.SpawnInitial(GameController.Wave, map);

            base.LoadContent();
        }
Esempio n. 36
0
    // Use this for initialization
    void Start () {
        this.currentWeapon = 0;
        this.SwitchWeapons();

        projectiles = GetComponent<ProjectileController>();
    }
 public void handleProjectileHit(ProjectileController projectile)
 {
     m_state = State.ItemRevealed;
     m_collider.m_type = ColliderType.Trigger;
 }
        protected override void handleSamusProjectileHit(ProjectileController projectile)
        {
            this.takeDamage(projectile.Damage);

            if (this.Health % 3 == 1)
            {
                changeState(State.Open);
            }
        }
        private void fireSpike(int spikeIdx)
        {
            Vector2 shootPoint = AnimationController.getShootPoint(this.DrawPosition);

            shootPoint += getSpikeOffset(spikeIdx);

            ProjectileController spike = new ProjectileController(
                this,
                shootPoint,
                new Vector2(m_facingRight ? c_spikeSpeed : -c_spikeSpeed, 0),
                ProjectileType.Spike,
                30,
                c_SpikeTexturePath);

            GameplayManager.ActiveZone.add(spike);
        }
Esempio n. 40
0
    private void UpgradeWeapons(int iterationCount, ProjectileController projectilePrefab, WeaponType weaponType)
    {
        //upgrade weapons and projectiles for each upgrade point
        for (int i = 0; i < iterationCount; i++)
        {
            //increase stats of projectile prefab
            UpgradeProjectile(projectilePrefab, weaponType);

            foreach (WeaponController weapon in player.GetWeapons())
            {
                if (weapon.GetWeaponType() == weaponType)
                {
                    //increase weapon stats
                    if (GetWeaponRank(weaponType) < 5)
                    {
                        weapon.Interval /= 1.25f;
                    }
                    else if (GetWeaponRank(weaponType) < 10)
                    {
                        weapon.Interval /= 1.15f;
                    }
                    else
                    {
                        weapon.Interval /= 1.05f;
                    }

                    ObjectPooler pooler = weapon.GetComponent<ObjectPooler>();
                    if (pooler != null)
                    {
                        //increase stats of pooled projectiles
                        foreach (GameObject obj in pooler.GetPooledObjects())
                        {
                            ProjectileController projectile = obj.GetComponent<ProjectileController>();
                            UpgradeProjectile(projectile, weaponType);
                        }
                    }
                }
            }
        }
    }
Esempio n. 41
0
    void Update()
    {
        if(Input.GetKey(KeyCode.Keypad9)){
            freeView = true;
        }

        if(Input.GetKey(KeyCode.Keypad7)){
            freeView = false;
        }

        time += Time.deltaTime;
        if(!GameMaster.hasWon && !GameMaster.levelComplete && !GameMaster.hasLost &&  Time.timeScale == 1.0f){

            positionSelected = new Vector3(-1,-1,-1);

            foreach (Touch touch in Input.touches) {
                if (touch.phase == TouchPhase.Began) {
                    positionSelected = touch.position;
                }
            }
            if (Input.GetButtonDown("Fire1") && positionSelected==new Vector3(-1,-1,-1)) {
                positionSelected = Input.mousePosition;
            }
            if(freeView){
            }else{

                if(positionSelected != new Vector3(-1,-1,-1) &&  weaponReady){
                    Ray ray = Camera.main.ScreenPointToRay (positionSelected);
                    RaycastHit hit;
                    if (Physics.Raycast(Camera.main.transform.position, ray.direction, out hit) && raycastMagazinedBalls(hit.transform)){
                        swapBall();
                    }else if(positionSelected[0] <130 && positionSelected[1] <260){
                        //Stop from shooting when clicking bomb powerup icon. Values are by trial and error
                    }else{
                        //Shoots

                        //Sets bomb model and bomb collider size
                        if(balls[0].name=="Bomb"){
                            float radius = (float)GameMaster.upgrades["BombSize"]/20;
                            (balls[0].gameObject.collider as SphereCollider).radius = radius;

                            Transform bombModel = balls[0].FindChild("Bomb(Clone)");
                            float size = (float)GameMaster.upgrades["BombSize"]/10;
                            bombModel.transform.localScale = new Vector3(size,size,size);
                        }

                        //Count a freeView powerup used
                        if(freeViewUsedThisRound){
                            freeViewUsedThisRound = false;
                            GameMaster.upgrades["FreeView"]--;
                        }

                        controllerScript = balls[0].GetComponent<ProjectileController>();
                        balls[0].transform.localPosition = new Vector3(0,0,0);
                        balls[0].transform.rotation = transform.rotation;
                        balls[0].transform.parent = null;
                        controllerScript.StartMove(ray.direction);
                        balls[0].tag = "BigBall";

                        weaponReady = false;
                        time = 0;

                        EventManager.ObjectFired(balls[0].name);
                        //Set balls[0] variable to null so a new ball can be loaded
                        balls[0] = null;

                    }
                }
            }
        }

        /*if(Input.GetKey(KeyCode.Keypad2)){
            balls[0].renderer.material.color = Color.blue;
            magazinedBall.renderer.material.color = Color.blue;

        }*/
    }