コード例 #1
0
            public SkryptObject Sort(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var m = TypeConverter.ToMethod(values, 0);

                if (m.Parameters.Count < 2)
                {
                    engine.ThrowError("Input function must have 2 parameters!");
                }

                ((Array)self).List.Sort((x, y) => {
                    var scope         = SkryptMethod.GetPopulatedScope(m, new[] { x, y });
                    scope.ParentScope = ScopeContext;

                    var r = m.Execute(engine, self, new[] { x, y }, scope);

                    if (r.ReturnObject.ToBoolean())
                    {
                        return(1);
                    }
                    else
                    {
                        return(-1);
                    }
                });

                return(self);
            }
コード例 #2
0
        public void AnalizeStatement(Node node, ScopeContext scopeContext)
        {
            // Check statement
            Node         conditionNode = node.SubNodes[0];
            SkryptObject result        = engine.executor.ExecuteExpression(conditionNode, scopeContext);

            // Check block
            Node blockNode = node.SubNodes[1];

            Analize(blockNode, scopeContext);

            // Check else/elseif
            if (node.SubNodes.Count > 2)
            {
                for (int i = 2; i < node.SubNodes.Count; i++)
                {
                    // elseif block
                    Node elseNode = node.SubNodes[i];

                    if (elseNode.Body == "elseif")
                    {
                        AnalizeStatement(elseNode, scopeContext);
                    }
                    else
                    {
                        Analize(elseNode, scopeContext);
                    }
                }
            }
        }
コード例 #3
0
            public static SkryptObject Mod(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var a = TypeConverter.ToNumeric(values, 0);
                var b = TypeConverter.ToNumeric(values, 1);

                return(engine.Create <Numeric>(a % b));
            }
コード例 #4
0
    public static SkryptObject Position(SkryptEngine engine, SkryptObject self)
    {
        var hitResultInstance = self as HitResultInstance;
        var point             = hitResultInstance.raycastHit.point;

        return(engine.CreateVector3(point.x, point.y, point.z));
    }
コード例 #5
0
    public static SkryptObject Normal(SkryptEngine engine, SkryptObject self)
    {
        var hitResultInstance = self as HitResultInstance;
        var normal            = hitResultInstance.raycastHit.normal;

        return(engine.CreateVector3(normal.x, normal.y, normal.z));
    }
コード例 #6
0
ファイル: Executor.cs プロジェクト: yoranmandema/Skrypt-Old
        /// <summary>
        ///     Executes an index opeation.
        /// </summary>
        public SkryptObject ExecuteIndex(IndexNode node, ScopeContext scopeContext)
        {
            var arguments = new List <SkryptObject>();

            foreach (var subNode in node.Arguments)
            {
                var result = ExecuteExpression(subNode, scopeContext);

                arguments.Add(result);
            }

            var Object = ExecuteExpression(node.Getter, scopeContext);

            // Dynamically change type so we can get it's actual operations.
            dynamic left = Convert.ChangeType(Object, Object.GetType());

            Operation opLeft = SkryptObject.GetOperation(Operators.Index, Object.GetType(), arguments[0].GetType(), left.Operations);

            OperationDelegate operation = null;

            if (opLeft != null)
            {
                operation = opLeft.OperationDelegate;
            }
            else
            {
                _engine.ThrowError("No such operation as index " + left.Name + "!", node.Getter.Token);
            }

            var inputArray = new List <SkryptObject>(arguments);

            inputArray.Insert(0, Object);

            return(operation(inputArray.ToArray(), _engine));
        }
コード例 #7
0
ファイル: Executor.cs プロジェクト: yoranmandema/Skrypt-Old
 public void SetFunctionOwner(SkryptObject function, SkryptObject owner)
 {
     if (function.GetType() == typeof(UserFunction))
     {
         ((UserFunction)function).Class = owner;
     }
 }
コード例 #8
0
        private static SkryptObject Benchmark(SkryptEngine engine, SkryptObject self, Arguments arguments)
        {
            var function   = arguments.GetAs <FunctionInstance>(0);
            var amount     = arguments.GetAs <NumberInstance>(1).Value;
            var lastResult = default(SkryptObject);

            var sw = System.Diagnostics.Stopwatch.StartNew();

            for (int x = 0; x < amount; x++)
            {
                lastResult = function.Function.Run(engine, null, Arguments.Empty);
            }

            sw.Stop();

            Console.WriteLine($"Executed function {amount} times in {sw.Elapsed.TotalMilliseconds}ms");
            Console.WriteLine($"Equals {1 / sw.Elapsed.TotalSeconds * amount} times per second");
            Console.WriteLine($"Average {(sw.Elapsed.TotalMilliseconds / amount).ToString(".####################")}ms");
            if (lastResult != null)
            {
                Console.WriteLine($"Last result: {lastResult}");
            }

            return(null);
        }
コード例 #9
0
            public static SkryptObject ToHex(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
            {
                var n   = TypeConverter.ToNumeric(input, 0);
                var str = Sys.Convert.ToString((long)n, 16);

                return(engine.Create <String>(str));
            }
コード例 #10
0
        private static SkryptObject Print(SkryptEngine engine, SkryptObject self, Arguments arguments)
        {
            Console.ForegroundColor = ConsoleColor.White;

            var str = "";

            for (var j = 0; j < arguments.Length; j++)
            {
                if (arguments[j] == null)
                {
                    str += "null";
                }
                else
                {
                    str += arguments[j].ToString();
                }

                if (j < arguments.Length - 1)
                {
                    str += ", ";
                }
            }

            Console.WriteLine(str);

            return(null);
        }
コード例 #11
0
        private void CreateProperty(SkryptObject target, IScopedContext ctx, ParserRuleContext propertyTree, bool isPrivate)
        {
            IToken nameToken = null;

            if (propertyTree.GetChild(0) is MemberDefinitionStatementContext assignCtx)
            {
                nameToken = assignCtx.name().NAME().Symbol;
            }
            else if (propertyTree.GetChild(0) is FunctionStatementContext fnCtx)
            {
                nameToken = fnCtx.name().NAME().Symbol;
            }
            else if (propertyTree.GetChild(0) is ModuleStatementContext moduleCtx)
            {
                nameToken = moduleCtx.name().NAME().Symbol;
            }
            else if (propertyTree.GetChild(0) is StructStatementContext structCtx)
            {
                nameToken = structCtx.name().NAME().Symbol;
            }

            var value = ctx.LexicalEnvironment.Variables[nameToken.Text].Value;

            if (value == null)
            {
                CompileErrorHandler.TolerateError(nameToken, "Field can't be set to an undefined value.");
            }

            target.CreateProperty(nameToken.Text, value, isPrivate, ctx.LexicalEnvironment.Variables[nameToken.Text].IsConstant);
        }
コード例 #12
0
        public object EvaluatePlusExpression(SkryptObject left, SkryptObject right)
        {
            if (left is NumberInstance && right is NumberInstance)
            {
                return((left as NumberInstance) + (right as NumberInstance));
            }

            if (left is StringInstance)
            {
                return((left as StringInstance).Value + right);
            }

            if (right is StringInstance)
            {
                return(left + (right as StringInstance).Value);
            }

            if (left is VectorInstance && right is VectorInstance)
            {
                return(VectorInstance.ComponentMath(_engine, left as VectorInstance, right as VectorInstance, (x, y) => x + y));
            }

            if (left is NumberInstance && right is VectorInstance)
            {
                return(VectorInstance.ComponentMathNumeric(_engine, right as VectorInstance, (x) => (left as NumberInstance) + x));
            }

            if (left is VectorInstance && right is NumberInstance)
            {
                return(VectorInstance.ComponentMathNumeric(_engine, left as VectorInstance, (x) => x + (right as NumberInstance)));
            }

            return(new InvalidOperation());
        }
コード例 #13
0
ファイル: System.cs プロジェクト: yoranmandema/Skrypt-Old
        public static SkryptObject error(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
        {
            var s = TypeConverter.ToString(values, 0, engine);

            engine.ThrowError(s, engine.CurrentNode?.Token);

            return(engine.Create <Null>(s));
        }
コード例 #14
0
            public static SkryptObject Clamp(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var x = TypeConverter.ToNumeric(values, 0);
                var a = TypeConverter.ToNumeric(values, 1);
                var b = TypeConverter.ToNumeric(values, 2);

                return(engine.Create <Numeric>(SysMath.Min(SysMath.Max(x, a), b)));
            }
コード例 #15
0
            public static SkryptObject Lerp(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var a = TypeConverter.ToNumeric(values, 0);
                var b = TypeConverter.ToNumeric(values, 1);
                var t = TypeConverter.ToNumeric(values, 2);

                return(engine.Create <Numeric>(a * (1 - t) + b * t));
            }
コード例 #16
0
ファイル: Canvas.cs プロジェクト: yoranmandema/Skrypt-Old
            public SkryptObject Draw(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var s = (Canvas)self;

                s.Window.Draw();

                return(s);
            }
コード例 #17
0
            public SkryptObject Push(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var a = TypeConverter.ToAny(values, 0);

                ((Array)self).List.Add(a);

                return((Array)self);
            }
コード例 #18
0
ファイル: FileIO.cs プロジェクト: yoranmandema/Skrypt-Old
            public static SkryptObject Open(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
            {
                var path = TypeConverter.ToString(values, 0, engine);

                var file = engine.Create <File>(path);

                return(file);
            }
コード例 #19
0
        public object EvaluateBitNotExpression(SkryptObject value)
        {
            if (value is NumberInstance)
            {
                return(~(int)(value as NumberInstance).Value);
            }

            return(new InvalidOperation());
        }
コード例 #20
0
        public object EvaluateGreaterEqualExpression(SkryptObject left, SkryptObject right)
        {
            if (left is NumberInstance && right is NumberInstance)
            {
                return((left as NumberInstance).Value >= (right as NumberInstance).Value);
            }

            return(new InvalidOperation());
        }
コード例 #21
0
        public object EvaluateExponentExpression(SkryptObject left, SkryptObject right)
        {
            if (left is NumberInstance && right is NumberInstance)
            {
                return(Math.Pow(left as NumberInstance, right as NumberInstance));
            }

            return(new InvalidOperation());
        }
コード例 #22
0
        public object EvaluateNotExpression(SkryptObject value)
        {
            if (value is BooleanInstance)
            {
                return(!(value as BooleanInstance));
            }

            return(new InvalidOperation());
        }
コード例 #23
0
            public static SkryptObject ToUTF16(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
            {
                var str = TypeConverter.ToString(input, 0, engine);

                byte[] bytes   = Sys.Text.Encoding.Default.GetBytes(str);
                var    encoded = Sys.Text.UnicodeEncoding.Unicode.GetString(bytes);

                return(engine.Create <String>(encoded));
            }
コード例 #24
0
            public static SkryptObject GetPixel(SkryptEngine engine, SkryptObject self, Arguments arguments)
            {
                var x = arguments.GetAs <NumberInstance>(0);
                var y = arguments.GetAs <NumberInstance>(1);

                var color = self.AsType <ImageInstance>().bitMap.GetPixel((int)x, (int)y);

                return(engine.GetValue("Color").AsType <ColorType>().Construct(color.R, color.G, color.B));
            }
コード例 #25
0
 public void AddVariable(string Name, SkryptObject Value, bool IsConstant = false)
 {
     Variables[Name] = new Variable {
         Name       = Name,
         Value      = Value,
         IsConstant = IsConstant,
         Scope      = this
     };
 }
コード例 #26
0
        public static Sys.String ToString(SkryptObject[] args, int index, SkryptEngine engine)
        {
            if (args == null || index > args.Length - 1)
            {
                return(new Sys.String(""));
            }

            return(SkryptObject.GetString(args[index], engine));
        }
コード例 #27
0
 public void SetVariable(string name, SkryptObject value, Modifier modifiers = Modifier.None)
 {
     Variables[name] = new Variable {
         Name      = name,
         Value     = value,
         Modifiers = modifiers,
         Scope     = this
     };
 }
コード例 #28
0
            public SkryptObject Reverse(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
            {
                var s = (String)self;

                char[] charArray = s.Value.ToCharArray();
                Sys.Array.Reverse(charArray);

                return(engine.Create <String>(new string(charArray)));
            }
コード例 #29
0
 public SkryptObject Find(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
 {
     return(engine.Create <Numeric>(
                ((String)self).Value.IndexOf(
                    TypeConverter.ToString(input, 0, engine),
                    (int)TypeConverter.ToNumeric(input, 1)
                    )
                ));
 }
コード例 #30
0
 public SkryptObject Replace(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
 {
     return(engine.Create <String>(
                ((String)self).Value.Replace(
                    TypeConverter.ToString(input, 0, engine),
                    TypeConverter.ToString(input, 1, engine)
                    )
                ));
 }