public OctoBehavior(Octo actor, Actor target)
            : base(actor)
        {
            this.actor            = actor;
            this.target           = target;
            this.pathFindBehavior = new PathfindBehavior(actor, target, .06f);

            this.shootBehavior         = new ShootAttack(actor);
            shootBehavior.target       = target;
            shootBehavior.speed        = 6;
            shootBehavior.projectileId = actor.world.actorFactory.getActorId("SlimeBall");

            actor.octoball.addEndAct(
                (frame) => {
                shootBehavior.run(); actor.world.tileEngine.audioComponent.playSound(actor.audioSet[1], false);
            }
                );

            actor.octoball.addEndAct(
                (frame) => {
                actor.anim.reset(); actor.anim = actor.floatingAnimation; shotcooldown = 100f;
            }
                );

            this.shotcooldown = 160f;
            this.shotrate     = 140f;
        }
        public ChargerBehavior(Actor actor, Actor target)
            : base(actor)
        {
            this.charger          = actor;
            this.target           = target;
            this.pathFindBehavior = new PathfindBehavior(actor, target, Constants.CHARGER_BEHAVIOR_PATHFIND);


            // Add
            Animation.Action chargerAttack = (frame) =>
            {
                foreach (Actor a in charger.getConeAround(dmgSize[frame], new Vector2(1.0f, 1.0f), 360, null))
                {
                    if (a == target)
                    {
                        if (!dmgDone)
                        {
                            charger.velocity = new Vector2(0.0f, 0.0f);

                            Life.basicDamage(charger, a, Constants.CHARGER_DAMAGE);

                            dmgDone = true;
                        }
                    }
                }
            };
            chargerAttackAnim.addPredAct(((frame) => { return(true); }), chargerAttack);
        }
 public SpikonBehavior(Actor actor, Actor target)
     : base(actor)
 {
     this.actor            = actor;
     this.target           = target;
     this.pathFindBehavior = new PathfindBehavior(actor, target, Constants.SPIKON_BEHAVIOR_PATHFIND);
 }
        public DiscoBlobBehavior(Actor actor, Actor target)
            : base(actor)
        {
            this.target           = target;
            this.actor            = actor;
            this.pathFindBehavior = new PathfindBehavior(actor, target, Constants.BLOB_BEHAVIOR_PATHFIND);
            colorSwap             = 0;
            count = 0;

            blobColor = new Color[] {
                /*
                 * new Color(.7f,0,0),
                 * new Color(.7f,.7f,0),
                 * new Color(0,.7f,0),
                 * new Color(0,.7f,.7f),
                 * new Color(0,0,.7f),
                 * new Color(.7f,0,.7f),
                 */
                new Color(1f, 0, 0),
                new Color(1f, 1f, 0),
                new Color(0, 1f, 0),
                new Color(0, 1f, 1f),
                new Color(0, 0, 1f),
                new Color(1f, 0, 1f),
            };
        }
 public BasiliskBehavior(Actor actor, Actor target)
     : base(actor)
 {
     this.target       = target;
     this.actor        = actor;
     this.seen         = false;
     this.lockCooldown = 0;
     pathFindBehavior  = new PathfindBehavior(actor, target, 0.12f);
 }
Beispiel #6
0
        public WizBlobBehavior(WizBlob actor, Actor target)
            : base(actor)
        {
            this.actor            = actor;
            this.target           = target;
            this.pathFindBehavior = new PathfindBehavior(actor, target, .1f);

            this.shootBehavior         = new ShootAttack(actor);
            shootBehavior.target       = target;
            shootBehavior.speed        = 1;
            shootBehavior.projectileId = actor.world.actorFactory.getActorId("FireBlob");

            this.shotcooldown = 160f;
            this.lockCooldown = 0;
            this.shotrate     = 150f;

            Animation.Action shootFireblob = frame =>
            {
                this.shootBehavior.run();
                actor.anim.reset();
            };

            Animation.Action reset = frame =>
            {
                determineDirectionAnimation();
            };

            int animNum = 0;

            foreach (Animation a in ((WizBlob)actor).shootFireblobAnimation)
            {
                switch (animNum)
                {
                case 0:
                    a.addFrameAct(84, shootFireblob);
                    break;

                case 1:
                    a.addFrameAct(36, shootFireblob);
                    break;

                case 2:
                    a.addFrameAct(60, shootFireblob);
                    break;

                case 3:
                    a.addFrameAct(12, shootFireblob);
                    break;
                }
                //a.addEndAct(reset);
                animNum++;
            }
        }
 public BlobBehavior(Actor actor, Actor target)
     : base(actor)
 {
     this.shotcooldown          = Constants.BLOB_BEHAVIOR_SHOTCOOLDOWN;
     this.shotrate              = Constants.BLOB_BEHAVIOR_SHOTRATE;
     this.target                = target;
     this.actor                 = actor;
     this.pathFindBehavior      = new PathfindBehavior(actor, target, Constants.BLOB_BEHAVIOR_PATHFIND);
     this.shootBehavior         = new ShootAttack(actor);
     shootBehavior.target       = target;
     shootBehavior.projectileId = actor.world.actorFactory.getActorId(Constants.BLOB_BEHAVIOR_SHOT);
 }
    void SpawnInstance()
    {
        GameObject       spawnedEnemy     = Instantiate(objectToSpawn, transform.position, transform.rotation);
        PathfindBehavior pathfindBehavior = spawnedEnemy.GetComponent <PathfindBehavior>();

        if (pathfindBehavior != null)
        {
            pathfindBehavior.target = behaviorTarget;
        }
        MouseShootBehavior mouseShootBehavior = spawnedEnemy.GetComponent <MouseShootBehavior>();

        if (mouseShootBehavior != null)
        {
            mouseShootBehavior.scoreKeeper = scoreKeeper;
        }
    }
Beispiel #9
0
    void SpawnInstance()
    {
        GameObject       spawnedEnemy     = Instantiate(objectToSpawn, transform.position, transform.rotation);
        PathfindBehavior pathfindBehavior = spawnedEnemy.GetComponent <PathfindBehavior>();

        if (pathfindBehavior != null)
        {
            pathfindBehavior.target = behaviorTarget;
        }
        EnemyStats enemyStats = spawnedEnemy.GetComponent <EnemyStats>();

        if (enemyStats != null)
        {
            enemyStats.scoreKeeping = scoreKeeping;
        }
    }
        public GeneratorBehaviour(Actor actor, Actor target)
            : base(actor)
        {
            this.actor                = actor;
            this.target               = target;
            spawningCharger           = new Animation(0, 9, 8f, true, -0, -0);
            this.pathFindBehavior     = new PathfindBehavior(actor, target, Constants.GENERATOR_BEHAVIOR_PATHFIND);
            this.maintainDistBehavior = new MaintainDistBehavior(actor, target, Constants.GENERATOR_SPAWNCHARGER_RANGE, Constants.GENERATOR_BEHAVIOR_PATHFIND);  // TODO: make constant

            spawningCharger.addEndAct((frame) =>
            {
                Charger b = (Charger)actor.world.actorFactory.createActor(actor.world.actorFactory.getActorId("Charger"), actor.position + new Vector2(0, 0), null);
                if (b != null)
                {
                    actor.world.addActor(b);
                    ChargerBehavior.current_chargers++;
                }
                (b as ILife).life.deathEvent += spawn;
                chargerCount++;
                actor.anim = spawningNone;
            });
        }
Beispiel #11
0
        private Vector2 chargeForce;  // Force to use while charging


        public MrHammerBehavior(Actor actor, Actor target)
            : base(actor)
        {
            this.actor            = actor;
            this.target           = target;
            this.pathFindBehavior = new PathfindBehavior(actor, target, Constants.MRHAMMER_PATHFIND);
            this.shotCooldown     = 0;
            this.lockCooldown     = 0;
            this.chargeCount      = 480;
            this.chargeTimeOut    = 0;
            this.isCharging       = false;

            // Define animation actions
            // Hammer attack
            Animation.Action beginSmash = (frame) =>
            {
                actor.world.tileEngine.audioComponent.playSound(actor.audioSet[0], false);
            };

            Animation.Action smash = (frame) =>
            {
                //Spawn explosions
                // Outer Outer Ring
                for (int i = 0; i < 30; i++)
                {
                    Vector2 rotated = Vector2.Transform(new Vector2(0f, 4f), Matrix.CreateRotationZ(MathHelper.ToRadians(12 * i)));
                    actor.world.addActor(new Explosion(actor.world as GameWorld, actor.position + rotated * (actor.size / 3 + 5),
                                                       rotated * 4f));
                }

                // Outer Ring
                for (int i = 0; i < 18; i++)
                {
                    Vector2 rotated = Vector2.Transform(new Vector2(0f, 3f), Matrix.CreateRotationZ(MathHelper.ToRadians(20 * i)));
                    actor.world.addActor(new Explosion(actor.world as GameWorld, actor.position + rotated * (actor.size / 3 + 5),
                                                       rotated * 4f));
                }

                // Inner Ring
                for (int i = 0; i < 9; i++)
                {
                    Vector2 rotated = Vector2.Transform(new Vector2(0f, 2f), Matrix.CreateRotationZ(MathHelper.ToRadians(40 * i)));
                    actor.world.addActor(new Explosion(actor.world as GameWorld, actor.position + rotated * (actor.size / 3 + 5),
                                                       rotated * 4f));
                }


                //Determine which actors are hit
                foreach (Actor a in actor.getConeAround(100, new Vector2(0, 0), 360, null))
                {
                    ILife   liveAct = a as ILife;
                    Vector2 impulse = new Vector2();
                    impulse = a.position - this.actor.position;
                    impulse.Normalize();
                    impulse *= Constants.MRHAMMER_KNOCKBACK;

                    if (a.collisionimmunitymask != Actor.ActorCategory.enemy)
                    {
                        if (liveAct != null)
                        {
                            liveAct.life.life -= Constants.MRHAMMER_HAMMER_DAMAGE;
                        }
                    }
                    a.addImpulse(impulse);
                }

                // Play explosion sound
                AudioSet temp = actor.world.tileEngine.resourceComponent.getAudioSet("020_FirePillar");
                actor.world.tileEngine.audioComponent.playSound(temp[0], false);
            };


            // Charge attack
            Animation.Action castStunWarning = frame =>
            {
                actor.world.addActor(new StunWarning(actor.world as GameWorld, target.position, new Vector2(0, 0)));
            };

            Animation.Action castCircle = frame =>
            {
                // Ring of Icy Stun
                int randomHole = (actor.world as GameWorld).tileEngine.randGen.Next(0, 9);

                for (int i = 0; i < 9; i++)
                {
                    // Spawn ice ball unless it's the one being left out
                    Vector2 rotated = Vector2.Transform(new Vector2(0f, 2f), Matrix.CreateRotationZ(MathHelper.ToRadians(40 * i)));
                    if (i != randomHole)
                    {
                        actor.world.addActor(new MagicPrimary(actor.world as GameWorld, target.position + rotated * (actor.size / 3 + 8),
                                                              rotated * 4f));
                    }
                }

                // Initiate charge
                pathFindBehavior.run();
                isCharging  = true;
                chargeForce = actor.force / 2;
            };

            // Add actions to the hammer animation
            int animNum = 0;

            foreach (Animation a in ((MrHammer)actor).smashAnimation)
            {
                switch (animNum)
                {
                case 0:
                    a.addFrameAct(163, smash);
                    break;

                case 1:
                    a.addFrameAct(85, smash);
                    break;

                case 2:
                    a.addFrameAct(124, smash);
                    break;

                case 3:
                    a.addFrameAct(46, smash);
                    break;
                }
                a.addBeginAct(beginSmash);
                animNum++;
            }

            // Add actions to the casting animation
            foreach (Animation a in ((MrHammer)actor).castCircleAnimation)
            {
                a.addBeginAct(castStunWarning);
                a.addEndAct(castCircle);
            }
        }