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;
}
}
}
}
