Exemple #1
0
        private static EffectArgument ParseEffectArgument(string filename, Effect effect, string operand)
        {
            var effectArgument = new EffectArgument();

            effectArgument.Type = GetEffectArgumentType(operand);

            switch (effectArgument.Type)
            {
            case EffectArgumentType.Int:

                if (!int.TryParse(operand, out effectArgument.IntVal))
                {
                    if (effect.Quality != null && effect.Quality.StatType == StatType.Int && effect.Quality.StatIdx == (int)PropertyInt.ImbuedEffect && Enum.TryParse(operand, out ImbuedEffectType imbuedEffectType))
                    {
                        effectArgument.IntVal = (int)imbuedEffectType;
                    }
                    else if (Enum.TryParse(operand, out WieldRequirement wieldRequirement))
                    {
                        effectArgument.IntVal = (int)wieldRequirement;
                    }
                    else if (Enum.TryParse(operand, out Skill skill))
                    {
                        effectArgument.IntVal = (int)skill;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse IntVal {operand}");
                    }
                }
                break;
Exemple #2
0
        public bool StoreValue(WorldObject item, EffectArgument result)
        {
            // here the resolved value (result) is applied to the qualities specified by our value

            if (!result.IsValid)
            {
                return(false);
            }

            switch (Type)
            {
            case EffectArgumentType.Quality:

                switch (StatType)
                {
                case StatType.Int:
                    item.SetProperty((PropertyInt)StatIdx, result.ToInt());
                    break;

                case StatType.Int64:
                    item.SetProperty((PropertyInt64)StatIdx, result.ToLong());
                    break;

                case StatType.Bool:
                    item.SetProperty((PropertyBool)StatIdx, Convert.ToBoolean(result.ToInt()));
                    break;

                case StatType.Float:
                    item.SetProperty((PropertyFloat)StatIdx, result.ToDouble());
                    break;

                case StatType.DID:
                    item.SetProperty((PropertyDataId)StatIdx, (uint)result.ToInt());
                    break;
                }
                break;

            case EffectArgumentType.Variable:

                // TODO

                /*if (IntVal < 0 || IntVal > GTVariables.Count)
                 *  break;
                 *
                 * GTVariables[IntVal] = result;*/
                break;
            }
            return(true);
        }
Exemple #3
0
        public EffectArgument(EffectArgument other)
        {
            if (other == null)
            {
                return;
            }

            Type = other.Type;

            StatType = other.StatType;
            StatIdx  = other.StatIdx;

            IntVal = other.IntVal;

            DoubleVal = other.DoubleVal;

            MinVal = other.MinVal;
            MaxVal = other.MaxVal;
        }
Exemple #4
0
        public bool Validate(WorldObject wo, EffectArgument result, EffectArgument arg1, EffectArgument arg2, MutationEffectType type)
        {
            /*if (!result.IsValid)
             * {
             *  log.Error($"{wo.Name} ({wo.Guid}).TryMutate({type}) - result invalid");
             *  return false;
             * }*/

            if (!arg1.IsValid)
            {
                log.Error($"{wo.Name} ({wo.Guid}).TryMutate({type}) - argument 1 invalid");
                return(false);
            }

            switch (type)
            {
            case MutationEffectType.AtLeastAdd:
            case MutationEffectType.AtMostSubtract:
            case MutationEffectType.AddMultiply:
            case MutationEffectType.AddDivide:
            case MutationEffectType.SubtractMultiply:
            case MutationEffectType.SubtractDivide:
            case MutationEffectType.AssignAdd:
            case MutationEffectType.AssignSubtract:
            case MutationEffectType.AssignMultiply:
            case MutationEffectType.AssignDivide:

                if (!arg2.IsValid)
                {
                    log.Error($"{wo.Name} ({wo.Guid}).TryMutate({type}) - argument 2 invalid");
                    return(false);
                }
                break;
            }

            return(true);
        }
Exemple #5
0
        public bool TryMutate(WorldObject wo)
        {
            // type:enum - invalid, double, int32, quality (2 int32s: type and quality), float range (min, max), variable index (int32)
            // a=b,a+=b,a-=b,a*=b,a/=b,a=a<b?b:a+c,a=a>b?b:a-c,a+=b*c,a+=b/c,a-=b*c,a-=b/c,a=b+c,a=b-c,a=b*c,a=b/c

            // do not make changes to the members since this object will be reused

            var result = new EffectArgument(Quality);
            var arg1   = new EffectArgument(Arg1);
            var arg2   = new EffectArgument(Arg2);

            result.ResolveValue(wo);
            arg1.ResolveValue(wo);
            arg2.ResolveValue(wo);

            if (!Validate(wo, result, arg1, arg2, Type))
            {
                return(false);
            }

            switch (Type)
            {
            case MutationEffectType.Assign:

                result = arg1;
                break;

            case MutationEffectType.Add:

                result = result + arg1;
                break;

            case MutationEffectType.Subtract:

                result = result - arg1;
                break;

            case MutationEffectType.Multiply:

                result = result * arg1;
                break;

            case MutationEffectType.Divide:

                result = result / arg1;
                break;

            case MutationEffectType.AtLeastAdd:

                result = (!result.IsValid || result < arg1) ? arg1 : result + arg2;
                break;

            case MutationEffectType.AtMostSubtract:

                result = (!result.IsValid || result > arg1) ? arg1 : result - arg2;
                break;

            case MutationEffectType.AddMultiply:

                result = result + (arg1 * arg2);
                break;

            case MutationEffectType.AddDivide:

                result = result + (arg1 / arg2);
                break;

            case MutationEffectType.SubtractMultiply:

                result = result - (arg1 * arg2);
                break;

            case MutationEffectType.SubtractDivide:

                result = result - (arg1 / arg2);
                break;

            case MutationEffectType.AssignAdd:

                result = arg1 + arg2;
                break;

            case MutationEffectType.AssignSubtract:

                result = arg1 - arg2;
                break;

            case MutationEffectType.AssignMultiply:

                result = arg1 * arg2;
                break;

            case MutationEffectType.AssignDivide:

                result = arg1 * arg2;
                break;
            }

            Quality.StoreValue(wo, result);

            return(true);
        }
Exemple #6
0
        private static EffectArgument ParseEffectArgument(string filename, string operand)
        {
            var effectArgument = new EffectArgument();

            effectArgument.Type = GetEffectArgumentType(operand);

            switch (effectArgument.Type)
            {
            case EffectArgumentType.Int:

                if (!int.TryParse(operand, out effectArgument.IntVal))
                {
                    if (Enum.TryParse(operand, out WieldRequirement wieldRequirement))
                    {
                        effectArgument.IntVal = (int)wieldRequirement;
                    }
                    else if (Enum.TryParse(operand, out Skill skill))
                    {
                        effectArgument.IntVal = (int)skill;
                    }
                    else if (Enum.TryParse(operand, out ImbuedEffectType imbuedEffectType))
                    {
                        effectArgument.IntVal = (int)imbuedEffectType;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse IntVal {operand}");
                    }
                }
                break;

            case EffectArgumentType.Double:

                if (!double.TryParse(operand, out effectArgument.DoubleVal))
                {
                    log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse DoubleVal {operand}");
                }
                break;

            case EffectArgumentType.Quality:

                effectArgument.StatType = GetStatType(operand);

                switch (effectArgument.StatType)
                {
                case StatType.Int:

                    if (System.Enum.TryParse(operand, out PropertyInt propInt))
                    {
                        effectArgument.StatIdx = (int)propInt;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse PropertyInt.{operand}");
                    }
                    break;

                case StatType.Float:

                    if (System.Enum.TryParse(operand, out PropertyFloat propFloat))
                    {
                        effectArgument.StatIdx = (int)propFloat;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse PropertyFloat.{operand}");
                    }
                    break;

                case StatType.Bool:

                    if (System.Enum.TryParse(operand, out PropertyBool propBool))
                    {
                        effectArgument.StatIdx = (int)propBool;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse PropertyBool.{operand}");
                    }
                    break;

                case StatType.DataID:

                    if (System.Enum.TryParse(operand, out PropertyDataId propDID))
                    {
                        effectArgument.StatIdx = (int)propDID;
                    }
                    else
                    {
                        log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse PropertyBool.{operand}");
                    }
                    break;

                default:
                    log.Error($"MutationCache.BuildMutation({filename}) - unknown PropertyType.{operand}");
                    break;
                }
                break;

            case EffectArgumentType.Random:

                var match = Regex.Match(operand, @"Random\(([\d.-]+), ([\d.-]+)\)");

                if (!match.Success || !float.TryParse(match.Groups[1].Value, out effectArgument.MinVal) || !float.TryParse(match.Groups[2].Value, out effectArgument.MaxVal))
                {
                    log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse {operand}");
                }

                break;

            case EffectArgumentType.Variable:

                match = Regex.Match(operand, @"\[(\d+)\]");

                if (!match.Success || !int.TryParse(match.Groups[1].Value, out effectArgument.IntVal))
                {
                    log.Error($"MutationCache.BuildMutation({filename}) - couldn't parse {operand}");
                }

                break;

            default:
                log.Error($"MutationCache.BuildMutation({filename}) - unknown EffectArgumentType from {operand}");
                break;
            }
            return(effectArgument);
        }