コード例 #1
0
        private static AttackInformation MagicFrom(MagicDefinition magic, FDCreature subject, FDCreature target, GameField field)
        {
            bool isHit = FDRandom.BoolFromRate(magic.HittingRate);

            int changedHp = 0;

            if (isHit)
            {
                OccupationDefinition occupation = DefinitionStore.Instance.GetOccupationDefinition(target.Definition.Occupation);
                double hitRate = 1.0f;

                if (occupation != null)
                {
                    hitRate = (100 - occupation.MagicDefendRate) / 100.0f;
                }

                switch (magic.Type)
                {
                case MagicType.Attack:
                    changedHp = -FDRandom.IntFromSpan(magic.Span) + magic.ApInvoledRate * subject.Data.CalculatedAp / 100;
                    changedHp = (int)(changedHp * hitRate);
                    changedHp = Math.Min(0, changedHp);
                    break;

                case MagicType.Recover:
                    changedHp = FDRandom.IntFromSpan(magic.Span);
                    changedHp = Math.Max(0, changedHp);
                    break;

                case MagicType.Offensive:
                    TakeOffensiveEffect(magic, target);
                    break;

                case MagicType.Defensive:
                    TakeDefensiveEffect(magic, target);
                    break;

                default:
                    break;
                }
            }

            AttackInformation info = new AttackInformation(target.Data.Hp, target.Data.Hp + changedHp, false);

            target.Data.UpdateHp(changedHp);

            return(info);
        }
コード例 #2
0
        private static AttackInformation AttackFrom(FDCreature subject, FDCreature target, GameField field)
        {
            bool isHit      = FDRandom.BoolFromRate(subject.Data.CalculatedHit - target.Data.CalculatedEv);
            bool isCritical = FDRandom.BoolFromRate(commonCriticalAttackRate);

            int reduceHp = 0;

            if (isHit)
            {
                FDPosition      pos        = subject.Position;
                ShapeDefinition shape      = field.GetShapeAt(pos.X, pos.Y);
                int             adjustedAp = subject.Data.CalculatedAp * (100 + shape.AdjustedAp) / 100;

                FDPosition      targetPos   = target.Position;
                ShapeDefinition targetShape = field.GetShapeAt(targetPos.X, targetPos.Y);
                int             adjustedDp  = target.Data.CalculatedDp * (100 + shape.AdjustedDp) / 100;

                int attackMax = adjustedAp - adjustedDp;
                int attackMin = (int)(attackMax * 0.9f);
                reduceHp = FDRandom.IntFromSpan(attackMin, attackMax);
                reduceHp = (reduceHp < 0) ? 0 : reduceHp;

                if (isCritical)
                {
                    reduceHp *= 2;
                }

                // Poisoned
                AttackItemDefinition attackItem = subject.Data.GetAttackItem();
                if (attackItem != null)
                {
                    bool isPoisoned = FDRandom.BoolFromRate(attackItem.GetPoisonRate());
                    if (isPoisoned)
                    {
                        target.Data.SetEffect(CreatureData.CreatureEffects.Poisoned);
                    }
                }
            }

            AttackInformation info = new AttackInformation(target.Data.Hp, target.Data.Hp - reduceHp, isCritical);

            target.Data.UpdateHp(-reduceHp);

            return(info);
        }