Exemple #1
0
        public SpellAttributes(bool goFuckYourself)
        {
            type         = SpellType.Shield;
            caster       = TargetType.Self;
            target       = TargetType.Opponent;
            targetAspect = TargetedAspect.None;

            potencyMod  = 0;
            sizeMod     = 0;
            rangeMod    = 0;
            costMod     = 0;
            timeMod     = 0;
            echoMod     = 0;
            silenceMod  = 0;
            durationMod = 0;
            weak        = false;
            fizzle      = false;
            descriptor  = "";
            damageType  = DamageType.Force;
        }
Exemple #2
0
        public void ParseWords()
        {
            int count = sentence.subj.suffixes.Count + sentence.verb.suffixes.Count + sentence.obj.suffixes.Count;

            foreach (Suffix suffix in sentence.subj.suffixes.FindAll(suffix => weakSuffixes.Contains(suffix)))
            {
                count -= 2;
                time++;
            }
            for (int i = 0; i < count; i++)
            {
                cost = cost + i;
                time++;
            }
            switch (sentence.obj.word)
            {
            case ObjectEnum.so:
                target = TargetType.Self;
                break;

            case ObjectEnum.ya:
                target = TargetType.Opponent;
                break;

            case ObjectEnum.Fizzle:
                fizzle = true;
                break;

            default:
                break;
            }
            switch (sentence.subj.word)
            {
            case SubjectEnum.so:
                caster = TargetType.Self;
                break;

            case SubjectEnum.ya:
                caster = TargetType.Opponent;
                break;

            default:
                fizzle = true;
                break;
            }
            foreach (Suffix suffix in sentence.verb.suffixes)
            {
                switch (suffix)
                {
                case Suffix.la:
                    echoes++;
                    break;

                case Suffix.te:
                    potency++;
                    break;

                case Suffix.noth:
                    damageTypes.Add(DamageType.Fire);
                    break;

                case Suffix.noz:
                    damageTypes.Add(DamageType.Cold);
                    break;

                case Suffix.fui:
                    damageTypes.Add(DamageType.Electricity);
                    break;

                case Suffix.iai:
                    damageTypes.Add(DamageType.Sonic);
                    break;

                case Suffix.laz:
                    echoes--;
                    break;

                case Suffix.tez:
                    potency--;
                    break;

                case Suffix.gen:
                    size++;
                    break;

                case Suffix.nig:
                    damageTypes.Add(DamageType.Profane);
                    break;

                case Suffix.wis:
                    damageTypes.Add(DamageType.Sacred);
                    break;

                case Suffix.kyf:
                    damageTypes.Add(DamageType.Acid);
                    break;

                case Suffix.iaz:
                    silence += 3;
                    break;

                case Suffix.gez:
                    size--;
                    break;

                default:
                    fizzle = true;
                    break;
                }
            }
            switch (sentence.verb.word)
            {
            case VerbEnum.fukrak:
                type  = SpellType.TargetExplode;
                size += 2;
                range++;
                cost++;
                potency++;
                break;

            case VerbEnum.fulua:
                type   = SpellType.TargetBolt;
                range += 3;
                break;

            case VerbEnum.fuilien:
                type = SpellType.TargetGas;
                range--;
                size++;
                break;

            case VerbEnum.krak:
                type  = SpellType.Nova;
                size += 2;
                range = 0;
                break;

            case VerbEnum.ilien:
                type = SpellType.Cloud;
                size++;
                range = 0;
                duration++;
                break;

            case VerbEnum.sadem:
                type = SpellType.Shield;
                break;

            case VerbEnum.diestalaminya:
                type    = SpellType.TargetKill;
                cost   += 3;
                potency = 10;
                break;

            case VerbEnum.turya:
                type     = SpellType.Enhance;
                duration = 3;
                break;

            case VerbEnum.turza:
                type     = SpellType.Diminish;
                duration = 3;
                break;

            default:
                fizzle = true;
                break;
            }
            foreach (Suffix suffix in sentence.obj.suffixes)
            {
                switch (suffix)
                {
                case Suffix.so:
                    target = TargetType.Self;
                    switch (sentence.obj.word)
                    {
                    case ObjectEnum.erin:
                        aspectTarget = TargetedAspect.Senses;
                        break;

                    case ObjectEnum.iill:
                        aspectTarget = TargetedAspect.Speed;
                        break;

                    case ObjectEnum.pret:
                        aspectTarget = TargetedAspect.ManaRegen;
                        break;
                    }
                    break;

                case Suffix.ya:
                    target = TargetType.Opponent;
                    switch (sentence.obj.word)
                    {
                    case ObjectEnum.erin:
                        aspectTarget = TargetedAspect.Senses;
                        break;

                    case ObjectEnum.iill:
                        aspectTarget = TargetedAspect.Speed;
                        break;

                    case ObjectEnum.pret:
                        aspectTarget = TargetedAspect.ManaRegen;
                        break;
                    }
                    break;

                default:
                    fizzle = true;
                    break;
                }
            }
        }