local   double      timeTemp;


method void Init(ScriptParam par)
{
   this.ChangeDir();
   timeTemp.Set(Program.Rnd.NextDouble() * 3.0d);
}

method void Update(ScriptParam par)
{
   timeTemp.Set(timeTemp.Get() + Program.FrameCount.TimeDelta / 60.0d);
   if (timeTemp.Get() > 3.0d)
   {
      timeTemp.Set(0.0d);
      this.ChangeDir();
      this.ZVel = 5.0d;
   }
}

method void CollideTile(ScriptParam par)
{
   this.ChangeDir();
}

method void ChangeDir()
{
   this.Control.Reset();
   switch (Program.Rnd.Next(4))
   {
      case 0:
         this.Control.MoveDown();
         break;
      case 1:
         this.Control.MoveUp();
         break;
      case 2:
         this.Control.MoveLeft();
         break;
      case 3:
         this.Control.MoveRight();
         break;
   }
   switch (Program.Rnd.Next(4))
   {
      case 0:
         this.Dir = Math.PI;
         break;
      case 1:
         this.Dir = 0.0d;
         break;
      case 2:
         this.Dir = Func.HalfPi * 3.0d;
         break;
      case 3:
         this.Dir = Func.HalfPi;
         break;
   }
}

CSScript.Compiler scrProv = new CSScript.Compiler(
   scriptSelfType,
   new string[]
   {
      "System",
      "Rpg_Project",
      "ScriptParam = Rpg_Project.GameObj.ScriptParam",
      "Fetze.Module",
      "Fetze.Utility",
      "Fetze.Utility.Color"
   });

scrProv.AddExtSafeTypes(
   typeof(List<>),
   typeof(Dictionary<,>),
   typeof(Stack<>),
   typeof(Queue<>),
   typeof(BitArray),
   
   typeof(Point<>),
   typeof(Rect<>),
   typeof(Vector2D),
   typeof(Vector3D),
   typeof(Clr.RGBA),
   typeof(Clr.RGBAf),
   typeof(Clr.HSVA));

public delegate void ScriptDelegate(GameObject parentObj, ScriptParam par);

ScriptDelegate myMethod = (ScriptDelegate)csScriptInstance.CreateDelegate(typeof(GameObject), "Name_Deiner_Methode");

myMethod(thisObject, paramOne);

#region CSScript.IValueProvider implementation
private         Dictionary<string,object>   localScriptVar      = new Dictionary<string,object>();
private   static   Dictionary<string,object>   globalScriptVar      = new Dictionary<string,object>();

public T GetLocalVar<T>(string var)
{
   object value;
   if (this.localScriptVar.TryGetValue(var, out value))
   {
      return (T)value;
   }
   else
   {
      T newVal = default(T);
      this.localScriptVar.Add(var, newVal);
      return newVal;
   }
}
public T GetGlobalVar<T>(string var)
{
   object value;
   if (GameObj.globalScriptVar.TryGetValue(var, out value))
   {
      return (T)value;
   }
   else
   {
      T newVal = default(T);
      GameObj.globalScriptVar.Add(var, newVal);
      return newVal;
   }
}
public void SetLocalVar<T>(string var, T value)
{
   this.localScriptVar[var] = (object)value;
}
public void SetGlobalVar<T>(string var, T value)
{
   GameObj.globalScriptVar[var] = (object)value;
}
#endregion

public void LoadScript(string file)
{
   file = Path.Combine("Content\\Script", file);

   if (this.compiledScripts.ContainsKey(file)) return;
   Assembly[] references = AppDomain.CurrentDomain.GetAssemblies();

   #region Loading script code
   FileStream      stream      = File.OpenRead(file);
   StreamReader   reader      = new StreamReader(stream, Encoding.Default, true);
   string         sourceFile   = reader.ReadToEnd();
   reader.Close();
   #endregion

   #region Compiling
   CSharpCodeProvider   codeProv   = new CSharpCodeProvider();
   CompilerParameters   compArgs   = new CompilerParameters();
   CompilerResults      ret;
   compArgs.GenerateInMemory         = true;
   compArgs.GenerateExecutable         = false;
   #if DEBUG
      compArgs.IncludeDebugInformation   = true;
   #else
      compArgs.IncludeDebugInformation   = false;
      compArgs.CompilerOptions         = "/optimize";
   #endif
   for (int i = 0; i < references.Length; i++)
   {
      compArgs.ReferencedAssemblies.Add(references[i].Location);
   }

   ret = codeProv.CompileAssemblyFromSource(compArgs, sourceFile);
   if (ret.Errors.Count > 0)
   {
      SteApp.Current.ErrorLog.WriteLine(
         String.Format("Error {2} compiling script '{0}', line {1}: {3}",
         file,
         ret.Errors[0].Line,
         ret.Errors[0].ErrorNumber,
         ret.Errors[0].ErrorText)
         );
      #if DEBUG
      System.Diagnostics.Debugger.Break();
      #endif
      return;
   }
   #endregion

   this.compiledScripts.Add(file, ret.CompiledAssembly);
}

<...>

foreach (Assembly asm in this.compiledScripts.Values)
{
   foreach (Type t in asm.GetTypes())
   {
      method = t.GetMethod(
         myInfo.name,
         BindingFlags.Static | BindingFlags.Public,
         null,
         new Type[] {myInfo.objType, myInfo.argsType},
         null);
      if (method != null) break;
   }
   if (method != null) break;
}


<...>


// Generate delegate
if (method != null)
{
   func = (ScriptFunc<T,U>)Delegate.CreateDelegate(typeof(ScriptFunc<T,U>), method);
}

<...>

using System;
using System.Collections.Generic;
using SteCore;

namespace Script
{
   public static class General
   {
      public static bool TestFunc(GameObject obj, ScriptEventArgs args)
      {
         Console.WriteLine("Begin");
         Console.WriteLine("Mid");
         Console.WriteLine("End");
         return true;
      }
   }
}

namespace Script {
    public class Player {
        public static IEnumerable<ScriptCondition> Update( ScriptObject self ) {
            self.setSize( 20, 40 );
            while ( true ) { //endlos schleife, welche jedes Frame aufgerufen wird
                ZweiDe.DrawRect( self.X, self.Y, self.Width, self.Height );
                if ( ZweiDe.KeyDown( ZweiDe.KeyID.Left ) ) {
                    self.move( -1f, 0 );
                }
                if ( ZweiDe.KeyDown( ZweiDe.KeyID.Right ) ) {
                    self.move( 1f, 0 );
                }
                if ( ZweiDe.KeyDown( ZweiDe.KeyID.Space ) && self.touchGround()) {
                    self.move( 0, -10 );
                }
                self.updatePhysics( );
                yield return new ScriptWaitCondition( 0 );
            }
        }
    }
}