public void ComputeRealDamage(DamageKeyFrame KeyFrame)
        {
            DamageOld = DamageCurrent = ComputeDamage(KeyFrame);

            DamageNext = 0;
            TextSize   = fntDamage.MeasureString(DamageCurrent.ToString());
        }
            protected override VisibleAnimationObjectKeyFrame CopyAsVisibleAnimationObjectKeyFrame(AnimationClass.AnimationLayer ActiveLayer)
            {
                DamageKeyFrame NewAnimatedBitmapKeyFrame = new DamageKeyFrame();

                NewAnimatedBitmapKeyFrame.UpdateFrom(this);
                NewAnimatedBitmapKeyFrame._Damage = _Damage;

                return(NewAnimatedBitmapKeyFrame);
            }
Beispiel #3
0
        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);
                }
            }
        }
        private int ComputeDamage(DamageKeyFrame KeyFrame)
        {
            int DamageDealt = GetDamageFromText(KeyFrame.Damage);

            string[] DamageSplit = KeyFrame.Damage.Split('/');
            if (DamageSplit.Length == 1)
            {
                return(DamageDealt);
            }
            else if (DamageSplit.Length == 2)
            {
                return((int)(DamageDealt / Convert.ToDouble(DamageSplit[1], System.Globalization.CultureInfo.InvariantCulture)));
            }

            return(0);
        }
        private DamageTimeline(BinaryReader BR, ContentManager Content)
            : base(BR, TimelineType)
        {
            _SpawnFrame = BR.ReadInt32();
            _DeathFrame = BR.ReadInt32();

            fntDamage         = Content.Load <SpriteFont>("Fonts/Battle Damage");
            fntDamage.Spacing = -5;

            int DicAnimationSpriteKeyFrameCount = BR.ReadInt32();

            for (int E = 0; E < DicAnimationSpriteKeyFrameCount; E++)
            {
                int Key = BR.ReadInt32();

                DamageKeyFrame NewAnimatedBitmapKeyFrame = new DamageKeyFrame(BR);

                DicAnimationKeyFrame.Add(Key, NewAnimatedBitmapKeyFrame);
            }
        }
        public void ComputeNextDamage(DamageKeyFrame KeyFrame)
        {
            DamageNext = ComputeDamage(KeyFrame);
            TextSize   = fntDamage.MeasureString(DamageNext.ToString());
            int DamageDifference = DamageNext - DamageCurrent;

            DamageChangeValue = DamageDifference;
            string DamageString = DamageNext.ToString();

            RoundTrip = new int[Math.Max(DamageString.Length, DamageCurrent.ToString().Length)];

            for (int i = DamageString.Length - 1; i >= 0; --i)
            {
                if (DamageDifference > 0)
                {
                    RoundTrip[i]      = DamageDifference;
                    DamageDifference /= 10;
                }
                else
                {
                    RoundTrip[i] = 0;
                }
            }
        }