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);
        }
示例#2
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 Explosion(GameWorld world, Vector2 position, Vector2 velocity, float diameter, Vector2 size, Vector2 world2model, int imgIndex)
            : base(world, new Vector2(position.x, position.y), velocity, diameter, size, world2model, imgIndex, 1)
        {
            // Give explosion an animation
            this.anim = new Animation(world.engine.resourceComponent, "Sprites/008_explosion/", 0, 0, 2, false);

            // Create a new animation action to remove explosion from game
            Animation.Action destroy = (frame) =>
            {
                removeMe = true;
            };

            // Trigger destroy function after last frame of animation
            this.anim.addEndAct(destroy);
        }
示例#4
0
 public void Proc_ChangeActionForce(Animation.Action action)
 {
     return; // TODO: stub
 }
示例#5
0
        public BlobSpawnerBehavior(Actor actor, Actor target)
            : base(actor)
        {
            this.actor = actor;


            this.target = target;
            color       = actor.world.tileEngine.randGen.NextDouble();

            spawningGreen = new Animation(0, 9, 8f, false, 20, 20);
            spawningBlue  = new Animation(10, 18, 8f, false, 20, 20);
            spawningRed   = new Animation(19, 27, 8f, false, 20, 20);
            spawningWhite = new Animation(28, 36, 8f, false, 20, 20);

            Animation.Action spawnSound = (frame) =>
            {
                actor.world.tileEngine.audioComponent.playSound(actor.audioSet[0], false);
            };
            spawningGreen.addFrameAct(7, spawnSound);
            spawningBlue.addFrameAct(16, spawnSound);
            spawningRed.addFrameAct(25, spawnSound);
            spawningWhite.addFrameAct(34, spawnSound);


            spawningGreen.addEndAct((frame) =>
            {
                Blob b = (Blob)actor.world.actorFactory.createActor(actor.world.actorFactory.getActorId("Blob"), actor.position + new Vector2(74, 80), null, color);
                actor.world.addActor(b);
                (b as ILife).life.deathEvent += spawn;
                blobCount++;
                spawnCount++;
                actor.anim = spawningNone;
            });


            spawningBlue.addEndAct((frame) =>
            {
                Blob b = (Blob)actor.world.actorFactory.createActor(actor.world.actorFactory.getActorId("Blob"), actor.position + new Vector2(74, 80), null, color);
                actor.world.addActor(b);
                (b as ILife).life.deathEvent += spawn;
                blobCount++;
                spawnCount++;
                actor.anim = spawningNone;
            });


            spawningRed.addEndAct((frame) =>
            {
                Blob b = (Blob)(actor.world.actorFactory as GameActorFactory).createActor(actor.world.actorFactory.getActorId("Blob"), actor.position + new Vector2(74, 80), null, color);
                actor.world.addActor(b);
                (b as ILife).life.deathEvent += spawn;
                blobCount++;
                spawnCount++;
                actor.anim = spawningNone;
            });
            spawningWhite.addEndAct((frame) =>
            {
                Blob b = (Blob)(actor.world.actorFactory as GameActorFactory).createActor(actor.world.actorFactory.getActorId("Blob"), actor.position + new Vector2(74, 80), null, color);
                actor.world.addActor(b);
                (b as ILife).life.deathEvent += spawn;
                blobCount++;
                spawnCount++;
                actor.anim = spawningNone;
            });
        }
示例#6
0
 public void addEndAct(Animation.Action endAct)
 {
     this.endAct = endAct;
 }
示例#7
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);
            }
        }