示例#1
0
 public static void RunOneShotEmitter(SKEmitterNode emitter, float duration)
 {
     emitter.RunAction(SKAction.Sequence(new [] {
         SKAction.WaitForDuration(duration),
         SKAction.Run(() => {
             emitter.ParticleBirthRate = 0;
         }),
         SKAction.WaitForDuration(emitter.ParticleLifetime + emitter.ParticleLifetimeRange),
         SKAction.RemoveFromParent()
     }));
 }
示例#2
0
        public void FollowPath(GKGraphNode[] path, Action <bool> completion)
        {
            if (path == null)
            {
                completion(false);
                return;
            }

            CharacterSpriteComponent comp = Entity.GetComponent <CharacterSpriteComponent> ();

            if (comp == null)
            {
                completion(false);
                return;
            }

            var dropFirst             = path.Skip(1);
            Queue <SKAction> sequence = new Queue <SKAction> ();
            var sprite = comp.Sprite;

            sprite.RemoveActionForKey(WalkingKey);

            foreach (MapGraphNode node in dropFirst)
            {
                Entity centity              = (Entity)Entity;
                CoreGraphics.CGPoint point  = GameViewController.CurrentScene.CurrentMap.PositionToPoint(node.NodePosition, true);
                List <SKAction>      subseq = new List <SKAction> ();

                subseq.Add(SKAction.Run(() => {
                    comp.Direction = centity.Model.StartPosition.DirectionToPosition(node.NodePosition);
                    centity.Model.StartPosition = node.NodePosition;
                    sprite.ZPosition            = GameViewController.CurrentScene.CurrentMap.ZLevelForPosition(node.NodePosition);
                    comp.Walking = true;
                }));

                subseq.Add(SKAction.MoveTo(point, 0.8));

                sequence.Enqueue(SKAction.Sequence(subseq.ToArray()));
            }

            sequence.Enqueue(SKAction.Run(() => comp.Walking = false));
            if (completion != null)
            {
                sequence.Enqueue(SKAction.Run(() => completion(true)));
            }

            currentWalk = sequence;
            if (!comp.Walking)
            {
                RunNextStep(sprite);
            }
        }
        void FireAnimationForState(AnimationState animationState, SKTexture[] frames, string key)
        {
            SKAction animAction = GetActionForKey(key);

            if (animAction != null || frames.Length < 1)
            {
                return;                 // we already have a running animation or there aren't any frames to animate
            }
            ActiveAnimationKey = key;
            RunAction(SKAction.Sequence(new [] {
                SKAction.AnimateWithTextures(frames, AnimationSpeed, true, false),
                SKAction.Run(() => AnimationHasCompleted(animationState))
            }), key);
        }
示例#4
0
        void RunNextStep(SKSpriteNode sprite)
        {
            if (currentWalk.Count == 0)
            {
                return;
            }

            List <SKAction> actions = new List <SKAction> ();

            // Pull the next step off the queue
            actions.Add(currentWalk.Dequeue());
            actions.Add(SKAction.Run(() => {
                RunNextStep(sprite);
            }));

            sprite.RunAction(SKAction.Sequence(actions.ToArray()));
        }
        protected override void CreateSceneContents()
        {
            base.CreateSceneContents();

            // no point in recomputing constant values each time
            var half_range = range / 2.0f;

            basex = (float)Scene.Frame.GetMidX() - half_range;
            basey = (float)Scene.Frame.GetMidY() - half_range;

            Scene.AddDescription("These textured sprite nodes are combined using an additive blend",
                                 new CGPoint(Scene.Frame.GetMidX(), 100));

            Scene.RunAction(SKAction.RepeatActionForever(SKAction.Sequence(
                                                             SKAction.Run(AddLight),
                                                             SKAction.WaitForDuration(0.5f, 0.1f)
                                                             )));
        }
        public override void AnimationDidComplete(AnimationState animation)
        {
            base.AnimationDidComplete(animation);

            if (animation != AnimationState.Death)
            {
                return;
            }

            RemoveAllActions();

            RunAction(SKAction.Sequence(new [] {
                SKAction.WaitForDuration(0.75),
                SKAction.FadeOutWithDuration(1),
                SKAction.Run(() => {
                    RemoveFromParent();
                    Cave.Recycle(this);
                })
            }));
        }
        public override void AnimationDidComplete(AnimationState animation)
        {
            switch (animation)
            {
            case AnimationState.Death:
                var emitter = (SKEmitterNode)DeathEmitter.Copy();
                emitter.ZPosition = -0.8f;
                AddChild(emitter);
                GraphicsUtilities.RunOneShotEmitter(emitter, 4.5f);

                RunAction(SKAction.Sequence(new [] {
                    SKAction.WaitForDuration(4),
                    SKAction.Run(() => CharacterScene.HeroWasKilled(this)),
                    SKAction.RemoveFromParent()
                }));
                break;

            case AnimationState.Attack:
                FireProjectile();
                break;
            }
        }
示例#8
0
        public override void PerformDeath()
        {
            base.PerformDeath();

            var splort = (SKNode)DeathSplort.Copy();

            splort.ZPosition = -1;
            splort.ZRotation = VirtualZRotation;
            splort.Position  = Position;
            splort.Alpha     = 0.1f;
            splort.RunAction(SKAction.FadeAlphaTo(1, 0.5));

            MultiplayerLayeredCharacterScene scene = CharacterScene;

            scene.AddNode(splort, WorldLayer.BelowCharacter);

            RunAction(SKAction.Sequence(new [] {
                SKAction.FadeAlphaTo(0, 0.5f),
                SKAction.RemoveFromParent()
            }));

            smokeEmitter.RunAction(SKAction.Sequence(new [] {
                SKAction.WaitForDuration(2),
                SKAction.Run(() => {
                    smokeEmitter.ParticleBirthRate = 2;
                }),

                SKAction.WaitForDuration(2),
                SKAction.Run(() => {
                    smokeEmitter.ParticleBirthRate = 0;
                }),

                SKAction.WaitForDuration(10),
                SKAction.FadeAlphaTo(0, 0.5),
                SKAction.RemoveFromParent()
            }));

            inactiveGoblins.Clear();
        }