public void Explode(ScriptThread thread)
        {
            string explodee = thread.GetStringParameter(0);
            char seperator = thread.GetStringParameter(1)[0];
            string[] exploded = explodee.Split(new char[] { seperator });

            int arrayMemoryIndex = thread.AllocateArray(DataType.String, exploded.Length);
            for (int i = 0; i < exploded.Length; i++)
                thread.SetArrayElement(arrayMemoryIndex, i, exploded[i]);

            thread.SetReturnValueArray(arrayMemoryIndex);
        }
        /// <summary>
        ///     Copies a runtime array value from one thread to another whilst keeping track of objects and memory allocations.
        /// </summary>
        /// <param name="value">Value to copy.</param>
        /// <param name="toThread">Thread to copy from.</param>
        /// <param name="fromThread">Thread to copy to.</param>
        /// <returns>Memory index of new array.</returns>
        public int CopyValueArrayFromThread(RuntimeValue value, ScriptThread toThread, ScriptThread fromThread)
        {
            // Create the array.
            int arraySize = GetArrayLength(value.MemoryIndex);
            int arrayIndex = toThread.AllocateArray(value.DataType.DataType, arraySize);

            // Array of objects, how fun.
            if (value.DataType.DataType == DataType.Object)
            {
                for (int j = 0; j < arraySize; j++)
                {
                    RuntimeValue elementValue = fromThread._process.MemoryHeap[arrayIndex + j];
                    if (elementValue.ObjectIndex == -1)
                        toThread.SetArrayElement(arrayIndex, j, (RuntimeObject)null);
                    else
                        toThread.SetArrayElement(arrayIndex, j, fromThread._process.ObjectHeap[elementValue.ObjectIndex]);
                }
            }

            // Yay, an array of normal stuff.
            else
            {
                for (int j = 0; j < arraySize; j++)
                    toThread.SetArrayElement(arrayIndex, j, fromThread._process.MemoryHeap[arrayIndex + j]);
            }

            return arrayIndex;
        }
 public void EntityChildren(ScriptThread thread)
 {
     EntityNode entity = ((NativeObject)thread.GetObjectParameter(0)).Object as EntityNode;
     if (entity == null)
     {
         DebugLogger.WriteLog((thread.Process.Url != null && thread.Process.Url != "" ? thread.Process.Url : "A script") + " called EntityChildren with an invalid object.", LogAlertLevel.Error);
         return;
     }
     if (entity.Children.Count > 0)
     {
         int memoryIndex = thread.AllocateArray(DataType.Object, entity.Children.Count);
         for (int i = 0; i < entity.Children.Count; i++)
         {
             thread.SetArrayElement(memoryIndex, i, new SceneNodeScriptObject((SceneNode)entity.Children[i]));
         }
         thread.SetReturnValueArray(memoryIndex);
     }
 }
 public void EntityCollisionLayer(ScriptThread thread)
 {
     EntityNode entity = ((NativeObject)thread.GetObjectParameter(0)).Object as EntityNode;
     if (entity == null)
     {
         DebugLogger.WriteLog((thread.Process.Url != null && thread.Process.Url != "" ? thread.Process.Url : "A script") + " called EntityCollisionLayers with an invalid object.", LogAlertLevel.Error);
         return;
     }
     if (entity.CollisionPolygon == null) return;
     int arrayIndex = thread.AllocateArray(DataType.Int, entity.CollisionPolygon.Layers.Length);
     for (int i = 0; i < entity.CollisionPolygon.Layers.Length; i++)
         thread.SetArrayElement(arrayIndex, i, entity.CollisionPolygon.Layers[i]);
     thread.SetReturnValueArray(arrayIndex);
 }
        public void EntitiesOfType(ScriptThread thread)
        {
            string typeName = thread.GetStringParameter(0);
            ArrayList list = new ArrayList();
            foreach (SceneNode node in Fusion.Engine.Engine.GlobalInstance.Map.SceneGraph.EnumerateNodes())
            {
                if (node is ScriptedEntityNode && ((ScriptedEntityNode)node).Type.ToLower() == typeName)
                    list.Add(node);
            }

            if (list.Count > 0)
            {
                int memoryIndex = thread.AllocateArray(DataType.Object, list.Count);
                for (int i = 0; i < list.Count; i++)
                {
                    thread.SetArrayElement(memoryIndex, i, new SceneNodeScriptObject((SceneNode)list[i]));
                }
                thread.SetReturnValueArray(memoryIndex);
            }
        }