Beispiel #1
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 3)
            {
                var xValue = parameters[0].Evaluate(variables);
                var yValue = parameters[1].Evaluate(variables);
                var zValue = parameters[2].Evaluate(variables);

                if (!xValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, xValue.Type, VariableType.Float);
                }

                if (!yValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, yValue.Type, VariableType.Float);
                }

                if (!zValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, zValue.Type, VariableType.Float);
                }

                return(VariableValue.Create(new Vector3(xValue.Number, yValue.Number, zValue.Number)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 3);
        }
Beispiel #2
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count >= 2)
            {
                var biggestValue  = VariableValue.Empty;
                var biggestNumber = float.MinValue;

                for (var i = 0; i < parameters.Count; i++)
                {
                    var p = parameters[i].Evaluate(variables);

                    if (!p.HasNumber)
                    {
                        throw CommandEvaluationException.WrongParameterType(name, i, p.Type, VariableType.Int, VariableType.Float);
                    }

                    if (p.Number > biggestNumber)
                    {
                        biggestNumber = p.Number;
                        biggestValue  = p;
                    }
                }

                return(biggestValue);
            }
            else
            {
                throw CommandEvaluationException.TooFewParameters(name, parameters.Count, 2);
            }
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 0)
            {
                return(VariableValue.Create(new VariableStore()));
            }
            else if (parameters.Count == 1)
            {
                var schemaName = parameters[0].Evaluate(variables);

                if (!schemaName.HasString)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, schemaName.Type, VariableType.String);
                }

                var schema = Resources.Load <VariableSchema>(schemaName.String);

                if (!schema)
                {
                    Debug.LogWarningFormat(_invalidSchemaWarning, schemaName.String);
                }

                return(VariableValue.Create(schema ? new ConstrainedStore(schema) : new VariableStore()));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 0, 1);
        }
Beispiel #4
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 3)
            {
                var rValue = parameters[0].Evaluate(variables);
                var gValue = parameters[1].Evaluate(variables);
                var bValue = parameters[2].Evaluate(variables);

                if (!rValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, rValue.Type, VariableType.Float);
                }

                if (!gValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, gValue.Type, VariableType.Float);
                }

                if (!bValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, bValue.Type, VariableType.Float);
                }

                return(VariableValue.Create(new Color(rValue.Number, gValue.Number, bValue.Number)));
            }
            else if (parameters.Count == 4)
            {
                var rValue = parameters[0].Evaluate(variables);
                var gValue = parameters[1].Evaluate(variables);
                var bValue = parameters[2].Evaluate(variables);
                var aValue = parameters[3].Evaluate(variables);

                if (!rValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, rValue.Type, VariableType.Float);
                }

                if (!gValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, bValue.Type, VariableType.Float);
                }

                if (!bValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, gValue.Type, VariableType.Float);
                }

                if (!aValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 3, aValue.Type, VariableType.Float);
                }

                return(VariableValue.Create(new Vector4(rValue.Number, gValue.Number, bValue.Number, aValue.Number)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 3, 4);
        }
 public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
 {
     if (parameters.Count == 0)
     {
         return(VariableValue.Create(Time.time));
     }
     else
     {
         throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 0);
     }
 }
Beispiel #6
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 3)
            {
                var a = parameters[0].Evaluate(variables);
                var b = parameters[1].Evaluate(variables);
                var t = parameters[2].Evaluate(variables);

                if (!t.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, t.Type, VariableType.Float);
                }

                if (a.HasNumber && b.HasNumber)
                {
                    return(VariableValue.Create(Mathf.Lerp(a.Number, b.Number, t.Number)));
                }
                else if (a.HasNumber2 && b.HasNumber2)
                {
                    return(VariableValue.Create(Vector2.Lerp(a.Number2, b.Number2, t.Number)));
                }
                else if (a.HasNumber3 && b.HasNumber3)
                {
                    return(VariableValue.Create(Vector3.Lerp(a.Number3, b.Number3, t.Number)));
                }
                else if (a.HasNumber4 && b.HasNumber4)
                {
                    return(VariableValue.Create(Vector4.Lerp(a.Number4, b.Number4, t.Number)));
                }
                else if (a.Type == VariableType.Quaternion && b.Type == VariableType.Quaternion)
                {
                    return(VariableValue.Create(Quaternion.Lerp(a.Quaternion, b.Quaternion, t.Number)));
                }
                else if (a.Type == VariableType.Color && b.Type == VariableType.Color)
                {
                    return(VariableValue.Create(Color.Lerp(a.Color, b.Color, t.Number)));
                }

                if (a.HasNumber || a.HasNumber4 || a.Type == VariableType.Quaternion || a.Type == VariableType.Color)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, b.Type, a.Type);
                }
                else
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, a.Type, VariableType.Float, VariableType.Vector2, VariableType.Vector3, VariableType.Vector4, VariableType.Quaternion, VariableType.Color);
                }
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 3);
            }
        }
Beispiel #7
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 2)
            {
                var positionValue = parameters[0].Evaluate(variables);
                var sizeValue     = parameters[1].Evaluate(variables);

                if (!positionValue.HasNumber2)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, positionValue.Type, VariableType.Vector2);
                }

                if (!sizeValue.HasNumber2)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, sizeValue.Type, VariableType.Vector2);
                }

                return(VariableValue.Create(new Rect(positionValue.Number2, sizeValue.Number2)));
            }
            else if (parameters.Count == 4)
            {
                var xValue      = parameters[0].Evaluate(variables);
                var yValue      = parameters[1].Evaluate(variables);
                var widthValue  = parameters[2].Evaluate(variables);
                var heightValue = parameters[3].Evaluate(variables);

                if (xValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, xValue.Type, VariableType.Float);
                }

                if (yValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, yValue.Type, VariableType.Float);
                }

                if (widthValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, widthValue.Type, VariableType.Float);
                }

                if (heightValue.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 3, heightValue.Type, VariableType.Float);
                }

                return(VariableValue.Create(new Rect(xValue.Number, yValue.Number, widthValue.Number, heightValue.Number)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 2, 4);
        }
Beispiel #8
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            switch (parameters.Count)
            {
            case 1:
            {
                var value = parameters[0].Evaluate(variables);

                if (value.TryGetFloat(out var number))
                {
                    return(VariableValue.Create(Mathf.Atan(number)));
                }
                else if (value.TryGetVector2(out var vector))
                {
                    return(VariableValue.Create(Mathf.Atan2(vector.y, vector.x)));
                }
                else
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Float, VariableType.Vector2);
                }
            }

            case 2:
            {
                var y = parameters[0].Evaluate(variables);
                var x = parameters[1].Evaluate(variables);

                if (!y.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, y.Type, VariableType.Float);
                }

                if (!x.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, x.Type, VariableType.Float);
                }

                return(VariableValue.Create(Mathf.Atan2(y.Number, x.Number)));
            }

            default:
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 1, 2);
            }
            }
        }
Beispiel #9
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            switch (parameters.Count)
            {
            case 1:
            {
                var value = parameters[0].Evaluate(variables);

                if (value.TryGetFloat(out var number))
                {
                    return(VariableValue.Create(Mathf.Log(number, 10.0f)));
                }
                else
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Float);
                }
            }

            case 2:
            {
                var value = parameters[0].Evaluate(variables);
                var power = parameters[1].Evaluate(variables);

                if (!value.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Float);
                }

                if (!power.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, power.Type, VariableType.Int, VariableType.Float);
                }

                return(VariableValue.Create(Mathf.Log(value.Number, power.Number)));
            }

            default:
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 1, 2);
            }
            }
        }
Beispiel #10
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 1)
            {
                var result = parameters[0].Evaluate(variables);

                switch (result.Type)
                {
                case VariableType.Int: return(VariableValue.Create(Math.Abs(result.Int)));

                case VariableType.Float: return(VariableValue.Create(Math.Abs(result.Float)));
                }

                throw CommandEvaluationException.WrongParameterType(name, 0, result.Type, VariableType.Int, VariableType.Float);
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 1);
            }
        }
Beispiel #11
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 0)
            {
                return(VariableValue.Create(new VariableList()));
            }
            else if (parameters.Count == 1)
            {
                var count = parameters[0].Evaluate(variables);

                if (count.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, count.Type, VariableType.Int);
                }

                return(VariableValue.Create(new VariableList(count.Int)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 0, 1);
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 1)
            {
                var result = parameters[0].Evaluate(variables);

                if (result.Type == VariableType.Float)
                {
                    return(VariableValue.Create(Mathf.CeilToInt(result.Float)));
                }
                else
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, result.Type, VariableType.Float);
                }
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 1);
            }
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 2)
            {
                var positionValue = parameters[0].Evaluate(variables);
                var sizeValue     = parameters[1].Evaluate(variables);

                if (!positionValue.HasNumber3)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, positionValue.Type, VariableType.Vector3);
                }

                if (!sizeValue.HasNumber3)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, sizeValue.Type, VariableType.Vector3);
                }

                return(VariableValue.Create(new Bounds(positionValue.Number3, sizeValue.Number3)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 2);
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 2)
            {
                var xValue = parameters[0].Evaluate(variables);
                var yValue = parameters[1].Evaluate(variables);

                if (xValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, xValue.Type, VariableType.Int);
                }

                if (yValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, yValue.Type, VariableType.Int);
                }

                return(VariableValue.Create(new Vector2Int(xValue.Int, yValue.Int)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 2);
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 3)
            {
                var value = parameters[0].Evaluate(variables);
                var min   = parameters[1].Evaluate(variables);
                var max   = parameters[2].Evaluate(variables);

                if (!value.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Int, VariableType.Float);
                }

                if (!min.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, min.Type, VariableType.Int, VariableType.Float);
                }

                if (!max.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, max.Type, VariableType.Int, VariableType.Float);
                }

                if (value.Type == VariableType.Int && min.Type == VariableType.Int && max.Type == VariableType.Int)
                {
                    return(VariableValue.Create(Mathf.Clamp(value.Int, min.Int, max.Int)));
                }
                else
                {
                    return(VariableValue.Create(Mathf.Clamp(value.Number, min.Number, max.Number)));
                }
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 3);
            }
        }
Beispiel #16
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 2)
            {
                var value = parameters[0].Evaluate(variables);
                var power = parameters[1].Evaluate(variables);

                if (!value.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Int, VariableType.Float);
                }

                if (!power.HasNumber)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, power.Type, VariableType.Int, VariableType.Float);
                }

                return(VariableValue.Create(Mathf.Pow(value.Number, power.Number)));
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 2);
            }
        }
Beispiel #17
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 1)
            {
                var result = parameters[0].Evaluate(variables);

                switch (result.Type)
                {
                case VariableType.Int: return(result);

                case VariableType.Int2: return(result);

                case VariableType.Int3: return(result);

                case VariableType.IntRect: return(result);

                case VariableType.IntBounds: return(result);

                case VariableType.Float: return(VariableValue.Create((int)result.Float));

                case VariableType.Vector2: return(VariableValue.Create(new Vector2Int((int)result.Vector2.x, (int)result.Vector2.y)));

                case VariableType.Vector3: return(VariableValue.Create(new Vector3Int((int)result.Vector3.x, (int)result.Vector3.y, (int)result.Vector3.z)));

                case VariableType.Rect: return(VariableValue.Create(new RectInt((int)result.Rect.x, (int)result.Rect.y, (int)result.Rect.width, (int)result.Rect.height)));

                case VariableType.Bounds: return(VariableValue.Create(new BoundsInt((int)result.Bounds.min.x, (int)result.Bounds.min.y, (int)result.Bounds.min.z, (int)result.Bounds.size.x, (int)result.Bounds.size.y, (int)result.Bounds.size.z)));
                }

                throw CommandEvaluationException.WrongParameterType(name, 0, result.Type, VariableType.Float, VariableType.Vector2, VariableType.Vector3, VariableType.Rect, VariableType.Bounds);
            }
            else
            {
                throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 1);
            }
        }
Beispiel #18
0
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            if (parameters.Count == 2)
            {
                var positionValue = parameters[0].Evaluate(variables);
                var sizeValue     = parameters[1].Evaluate(variables);

                if (positionValue.Type != VariableType.Int3)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, positionValue.Type, VariableType.Int3);
                }

                if (sizeValue.Type != VariableType.Int3)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, sizeValue.Type, VariableType.Int3);
                }

                return(VariableValue.Create(new BoundsInt(positionValue.Int3, sizeValue.Int3)));
            }
            else if (parameters.Count == 6)
            {
                var xValue      = parameters[0].Evaluate(variables);
                var yValue      = parameters[1].Evaluate(variables);
                var zValue      = parameters[2].Evaluate(variables);
                var widthValue  = parameters[3].Evaluate(variables);
                var heightValue = parameters[4].Evaluate(variables);
                var depthValue  = parameters[4].Evaluate(variables);

                if (xValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, xValue.Type, VariableType.Int);
                }

                if (yValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 1, yValue.Type, VariableType.Int);
                }

                if (zValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 2, zValue.Type, VariableType.Int);
                }

                if (widthValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 3, widthValue.Type, VariableType.Int);
                }

                if (heightValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 4, heightValue.Type, VariableType.Int);
                }

                if (depthValue.Type != VariableType.Int)
                {
                    throw CommandEvaluationException.WrongParameterType(name, 5, depthValue.Type, VariableType.Int);
                }

                return(VariableValue.Create(new BoundsInt(xValue.Int, yValue.Int, zValue.Int, widthValue.Int, heightValue.Int, depthValue.Int)));
            }

            throw CommandEvaluationException.WrongParameterCount(name, parameters.Count, 2, 6);
        }
        public VariableValue Evaluate(IVariableStore variables, string name, List <Operation> parameters)
        {
            switch (parameters.Count)
            {
            case 0:
            {
                return(VariableValue.Create(Random.value));
            }

            case 1:
            {
                var value = parameters[0].Evaluate(variables);

                switch (value.Type)
                {
                case VariableType.Int: return(VariableValue.Create(Random.Range(0, value.Int)));

                case VariableType.Float: return(VariableValue.Create(Random.Range(0.0f, value.Float)));

                case VariableType.List: return(value.List.GetVariable(Random.Range(0, value.List.Count)));

                default: throw CommandEvaluationException.WrongParameterType(name, 0, value.Type, VariableType.Int, VariableType.Float, VariableType.List);
                }
            }

            case 2:
            {
                var min = parameters[0].Evaluate(variables);
                var max = parameters[1].Evaluate(variables);

                if (min.Type == VariableType.Int)
                {
                    if (max.Type == VariableType.Int)
                    {
                        return(VariableValue.Create(Random.Range(min.Int, max.Int)));
                    }
                    else if (max.Type == VariableType.Float)
                    {
                        return(VariableValue.Create(Random.Range(min.Int, max.Float)));
                    }
                    else
                    {
                        throw CommandEvaluationException.WrongParameterType(name, 1, max.Type, VariableType.Int, VariableType.Float);
                    }
                }
                else if (min.Type == VariableType.Float)
                {
                    if (max.Type == VariableType.Int)
                    {
                        return(VariableValue.Create(Random.Range(min.Float, max.Int)));
                    }
                    else if (max.Type == VariableType.Float)
                    {
                        return(VariableValue.Create(Random.Range(min.Float, max.Float)));
                    }
                    else
                    {
                        throw CommandEvaluationException.WrongParameterType(name, 1, max.Type, VariableType.Int, VariableType.Float);
                    }
                }
                else
                {
                    throw CommandEvaluationException.WrongParameterType(name, 0, min.Type, VariableType.Int, VariableType.Float);
                }
            }

            default:
            {
                throw CommandEvaluationException.TooManyParameters(name, parameters.Count, 2);
            }
            }
        }