public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } VisibleAnimationObjectKeyFrame ActiveKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveKeyFrame)) { //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveKeyFrame)) { if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } if (AnimationMarker != null) { AnimationMarker.UpdateKeyFrame(AnimationMarker.ActiveKeyFrame); AnimationMarker.ActiveKeyFrame++; if (AnimationMarker.LoopEnd > 0 && AnimationMarker.ActiveKeyFrame >= AnimationMarker.LoopEnd) { AnimationMarker.ActiveKeyFrame = AnimationMarker.LoopStart; AnimationMarker.CurrentQuote = ""; AnimationMarker.ListActiveSFX.Clear(); for (int L = 0; L < AnimationMarker.ListAnimationLayer.Count; L++) { AnimationMarker.ListAnimationLayer[L].ResetAnimationLayer(); } AnimationMarker.UpdateKeyFrame(0); if (AnimationMarker.ActiveKeyFrame > 0) { AnimationMarker.UpdateKeyFrame(AnimationMarker.ActiveKeyFrame); } } } }
public override void UpdateAnimationObject(int KeyFrame) { if (ActiveSprite == null) { return; } //An Event is being executed. if (NextEvent != null) { PixelPerSecond = PixelPerSecondOld + (int)(AnimationValue * (KeyFrame - EventKeyFrameOld)); _MaxWidth = MaxWidthOld + (int)(MaxWidthValue * (KeyFrame - EventKeyFrameOld)); UpdateAnimationSprite(KeyFrame); } Offset += PixelPerSecond * (1 / 60f); AnimatedTileKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedTileKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); PixelPerSecond = ActiveKeyFrame.PixelPerSecond; MaxWidth = ActiveKeyFrame.MaxWidth; if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedTileKeyFrame)ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); PixelPerSecondOld = PixelPerSecond; MaxWidthOld = MaxWidth; float KeyFrameChange = KeyFrame - NextKeyFrame; //Calculate of how many pixel the AnimatedBitmap will move per step. AnimationValue = (PixelPerSecond - ActiveKeyFrame.PixelPerSecond) / KeyFrameChange; MaxWidthValue = (MaxWidth - ActiveKeyFrame.MaxWidth) / KeyFrameChange; } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { if (ActiveSprite == null) { return; } //An Event is being executed. if (NextEvent != null) { ActiveSprite.FramesPerSecond = AnimationSpeedOld + (int)(AnimationValue * (KeyFrame - EventKeyFrameOld)); UpdateAnimationSprite(KeyFrame); } ActiveSprite.Update(ActiveSprite.FramesPerSecond * (1 / 60f)); if (ActiveSprite.AnimationEnded) { ActiveSprite.LoopAnimation(); } AnimatedBitmapKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedBitmapKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); ActiveSprite.FramesPerSecond = ActiveKeyFrame.FramesPerSecond; if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedBitmapKeyFrame)ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); AnimationSpeedOld = ActiveSprite.FramesPerSecond; float KeyFrameChange = KeyFrame - NextKeyFrame; //Calculate of how many pixel the AnimatedBitmap will move per step. AnimationValue = (ActiveSprite.FramesPerSecond - ActiveKeyFrame.FramesPerSecond) / KeyFrameChange; } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); for (int C = ListCollisionPolygon.Count - 1; C >= 0; --C) { ListCollisionPolygon[C].Offset(Position.X, Position.Y); } if (Owner != null) { MeleeBox NewAttackBox = new MeleeBox(_Damage, Owner, (DeathFrame - SpawnFrame) / FramesPerSeconds, true); for (int C = ListCollisionPolygon.Count - 1; C >= 0; --C) { ListCollisionPolygon[C].Offset(Owner.Position.X - Owner.AnimationOrigin.Position.X, Owner.Position.Y - Owner.AnimationOrigin.Position.Y); } NewAttackBox.ListCollisionPolygon = ListCollisionPolygon; //TODO: delete the attack box is the animation is cancelled Owner.CreateAttackBox(NewAttackBox); } if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { Progress = 0; //An Event is being executed. if (NextEvent != null) { Progress = (KeyFrame - EventKeyFrameOld) / (float)(NextEventKeyFrame - EventKeyFrameOld); int OldDamageCurrent = DamageCurrent; DamageCurrent = DamageOld + (int)(DamageChangeValue * Progress); if (Owner != null) { Owner.DamageEnemyUnit(DamageCurrent - OldDamageCurrent); } UpdateAnimationSprite(KeyFrame); } DamageKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (DamageKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); ComputeRealDamage(ActiveKeyFrame); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { DamageKeyFrame NextActiveKeyFrame = (DamageKeyFrame)ActiveAnimationSpriteKeyFrame; if (NextActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(NextActiveKeyFrame, KeyFrame, NextKeyFrame); ComputeNextDamage(NextActiveKeyFrame); } else { NextEvent = null; } } if (Owner != null && (!ActiveKeyFrame.IsProgressive || KeyFrame == SpawnFrame)) { Owner.DamageEnemyUnit(DamageCurrent); } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); if (Owner != null) { if (_ShootSecondaryWeapon) { Owner.Shoot(Position, _ShootSecondaryWeapon); } else if (OwnerWeapon != null) { int i = Owner.PrimaryWeapons.ActiveWeapons.IndexOf(OwnerWeapon); Owner.Shoot(Position, OwnerWeapon, i); } } if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } else { Position = PositionOld; ScaleFactor = ScaleFactorOld; Angle = AngleOld; Alpha = AlphaOld; DrawingDepth = DrawingDepthOld; } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } AnimatedChainKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedChainKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); CurrentChainLengthInPixel = ActiveKeyFrame.ChainLengthInPixel; ListCurrentChainSplinePoints = new List <Vector2>(ActiveKeyFrame.ListChainSplinePoints); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedChainKeyFrame)ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); float KeyFrameChange = KeyFrame - NextKeyFrame; //Calculate of how many pixel the AnimatedBitmap will move per step. } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); for (int C = ListCollisionPolygon.Count - 1; C >= 0; --C) { ListCollisionPolygon[C].Offset(Position.X, Position.Y); } if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { Progress = 0; //An Event is being executed. if (NextEvent != null) { Progress = (KeyFrame - EventKeyFrameOld) / (float)(NextEventKeyFrame - EventKeyFrameOld); UpdateAnimationSprite(KeyFrame); } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (VisibleAnimationObjectKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { VisibleAnimationObjectKeyFrame NextActiveKeyFrame = (VisibleAnimationObjectKeyFrame)ActiveAnimationSpriteKeyFrame; if (NextActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(NextActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { double TimeElapsedInSeconds = 1 / 60d; TimeElapsedSinceLastParticle += TimeElapsedInSeconds; while (TimeElapsedSinceLastParticle >= TimeBetweenEachParticle) { TimeElapsedSinceLastParticle -= TimeBetweenEachParticle; Vector2 SpawnPosition = new Vector2(Position.X + SpawnOffset.X + (float)Random.NextDouble() * SpawnOffsetRandom.X, Position.Y + SpawnOffset.Y + (float)Random.NextDouble() * SpawnOffsetRandom.Y); Vector2 ParticleSpeed = new Vector2(SpawnSpeed.X + (float)Random.NextDouble() * SpawnSpeedRandom.X, SpawnSpeed.Y + (float)Random.NextDouble() * SpawnSpeedRandom.Y); ParticleSystem.AddParticle(SpawnPosition, ParticleSpeed); } ParticleSystem.Update(TimeElapsedInSeconds); //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); } else { Position = PositionOld; ScaleFactor = ScaleFactorOld; Angle = AngleOld; Alpha = AlphaOld; DrawingDepth = DrawingDepthOld; } VisibleAnimationObjectKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = ActiveAnimationSpriteKeyFrame; if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null && ArrayMoveValue != null) { UpdateAnimationSprite(KeyFrame); for (int P = 0; P < ListPolygon.Count; P++) { for (int V = 0; V < ListPolygon[P].ArrayVertex.Length; V++) { Vector2 Result = ArrayMoveValue[P][V] * (KeyFrame - EventKeyFrameOld); ListPolygon[P].ArrayVertex[V] = new Vector2(EventOld.ListPolygon[P].ArrayVertex[V].X + (int)Result.X, EventOld.ListPolygon[P].ArrayVertex[V].Y + (int)Result.Y); } if (PolygonCutterType == PolygonCutterTypes.Crop) { ListPolygon[P].ComputeColorAndUVCoordinates(ActiveLayer.Owner.ScreenWidth, ActiveLayer.Owner.ScreenHeight); } ListPolygon[P].ComputePerpendicularAxis(); ListPolygon[P].UpdateWorldPosition(Position, Angle); } } VisibleAnimationObjectKeyFrame ActiveKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveKeyFrame)) { //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); PolygonCutterKeyFrame ActivePolygonCutterKeyFrame = (PolygonCutterKeyFrame)ActiveKeyFrame; EventOld = ActivePolygonCutterKeyFrame; if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveKeyFrame)) { PolygonCutterKeyFrame NextActivePolygonCutterKeyFrame = (PolygonCutterKeyFrame)ActiveKeyFrame; //Get the next polygons. if (NextActivePolygonCutterKeyFrame.ListPolygon.Count != ListPolygon.Count) { ListPolygon.Clear(); for (int P = 0; P < NextActivePolygonCutterKeyFrame.ListPolygon.Count; P++) { Polygon ActivePolygon = new Polygon(NextActivePolygonCutterKeyFrame.ListPolygon[P]); ListPolygon.Add(ActivePolygon); } } for (int P = 0; P < NextActivePolygonCutterKeyFrame.ListPolygon.Count; P++) { Polygon ActivePolygon = NextActivePolygonCutterKeyFrame.ListPolygon[P]; if (PolygonCutterType == PolygonCutterTypes.Crop) { ActivePolygon.ComputeColorAndUVCoordinates(AnimationClass.GraphicsDevice.PresentationParameters.BackBufferWidth, AnimationClass.GraphicsDevice.PresentationParameters.BackBufferHeight); } } if (ActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(ActiveKeyFrame, KeyFrame, NextKeyFrame); float KeyFrameChange = KeyFrame - NextKeyFrame; ArrayMoveValue = null; if (ActivePolygonCutterKeyFrame.ListPolygon.Count == NextActivePolygonCutterKeyFrame.ListPolygon.Count) { ArrayMoveValue = new Vector2[NextActivePolygonCutterKeyFrame.ListPolygon.Count][]; for (int P = 0; P < NextActivePolygonCutterKeyFrame.ListPolygon.Count; P++) { if (ActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex.Length != NextActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex.Length) { ArrayMoveValue = null; break; } else { ArrayMoveValue[P] = new Vector2[NextActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex.Length]; for (int V = 0; V < NextActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex.Length; V++) { ArrayMoveValue[P][V] = new Vector2( (ActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex[V].X - NextActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex[V].X) / KeyFrameChange, (ActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex[V].Y - NextActivePolygonCutterKeyFrame.ListPolygon[P].ArrayVertex[V].Y) / KeyFrameChange); } } } } } else { NextEvent = null; } } } }
public override void UpdateAnimationObject(int KeyFrame) { //An Event is being executed. if (NextEvent != null) { UpdateAnimationSprite(KeyFrame); for (int L = 0; L < NextActiveKeyFrame.ListChainSplinePoints.Count; ++L) { Vector2 Result = NextActiveKeyFrame.ListChainSplinePointsMoveValue[L] * (KeyFrame - EventKeyFrameOld); ListCurrentChainSplinePoints[L] = new Vector2(ListCurrentChainSplinePointsOld[L].X + (int)Result.X, ListCurrentChainSplinePointsOld[L].Y + (int)Result.Y); } } if (ChainLink != null) { ChainLink.Update(ChainLink.FramesPerSecond * (1 / 60f)); if (ChainLink.AnimationEnded) { ChainLink.LoopAnimation(); } } if (ChainEnd != null) { ChainEnd.Update(ChainEnd.FramesPerSecond * (1 / 60f)); if (ChainEnd.AnimationEnded) { ChainEnd.LoopAnimation(); } } if (ChainStart != null) { ChainStart.Update(ChainStart.FramesPerSecond * (1 / 60f)); if (ChainStart.AnimationEnded) { ChainStart.LoopAnimation(); } } AnimatedChainKeyFrame ActiveKeyFrame; VisibleAnimationObjectKeyFrame ActiveAnimationSpriteKeyFrame; if (DicAnimationKeyFrame.TryGetValue(KeyFrame, out ActiveAnimationSpriteKeyFrame)) { ActiveKeyFrame = (AnimatedChainKeyFrame)ActiveAnimationSpriteKeyFrame; //If that animation has already been used, skip it. if (ActiveKeyFrame.IsUsed) { return; } int NextKeyFrame = ActiveKeyFrame.NextKeyFrame; OnNewKeyFrameAnimationSprite(ActiveKeyFrame); CurrentChainLengthInPixel = ActiveKeyFrame.ChainLengthInPixel; ListCurrentChainSplinePoints = new List <Vector2>(ActiveKeyFrame.ListChainSplinePoints); ListCurrentChainSplinePointsOld = new List <Vector2>(ActiveKeyFrame.ListChainSplinePoints); if (DicAnimationKeyFrame.TryGetValue(NextKeyFrame, out ActiveAnimationSpriteKeyFrame)) { NextActiveKeyFrame = (AnimatedChainKeyFrame)ActiveAnimationSpriteKeyFrame; if (NextActiveKeyFrame.IsProgressive) { OnProgressiveNextKeyFrameAnimationSprite(NextActiveKeyFrame, KeyFrame, NextKeyFrame); float KeyFrameChange = KeyFrame - NextKeyFrame; for (int L = 0; L < ActiveKeyFrame.ListChainSplinePoints.Count; ++L) { NextActiveKeyFrame.ListChainSplinePointsMoveValue[L] = new Vector2((ActiveKeyFrame.ListChainSplinePoints[L].X - NextActiveKeyFrame.ListChainSplinePoints[L].X) / KeyFrameChange, (ActiveKeyFrame.ListChainSplinePoints[L].Y - NextActiveKeyFrame.ListChainSplinePoints[L].Y) / KeyFrameChange); } } else { NextEvent = null; } } } }