public void HookBase(HookPoint hookPoint, HookOrder order, NLua.LuaFunction callback)
{
var targetType = hookPoint.DelegateType.GetGenericArguments()[0];
var call = this.GetType().GetMethod("InternalCall");//.MakeGenericMethod(targetType);
var act = typeof(HookAction <>).MakeGenericType(targetType);
var inst = Activator.CreateInstance(act, call);
//if (initialized)
//hookPoint.HookBase(this, new HookAction<Object>((ref HookContext ctx, ref Object args) =>
//{
// callback.Call(ctx, args);
//}));
//else
//{
// lock (desiredHooks)
// desiredHooks.Add(new HookEntry
// {
// hookPoint = hookPoint,
// callback = new HookAction<Object>((ref HookContext ctx, ref Object args) =>
// {
// callback.Call(ctx, args);
// }),
// order = order
// });
//}
}
// -------------------------------------------------EVENTS-----------------------------------------------------
public void CommandReceived(User user, bool IsMod, string Message)
{
// Should probably add an event handler, but RegisterLuaDelegateType is poorly documented.
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object state)
{
try
{
List <string> strlist = new List <string>(Message.Split(" "));
if (Environment["command_" + strlist[0].Substring(1)] == null)
{
//IRC_Functions.SendMessage(ParentChannel, "Command not found.");
return;
}
NLua.LuaFunction MessageReceived = Environment["command_" + strlist[0].Substring(1)] as NLua.LuaFunction;
strlist.RemoveAt(0);
MessageReceived.Call(user.Username, IsMod, strlist); // Safer way to call than using DoString
} catch (NLua.Exceptions.LuaScriptException e)
{
//IRC_Functions.SendMessage(ParentChannel, "Script failed");
Log.Logger.OutputToConsole(e.ToString());
} catch {
// Do nothing
}
}), null);
}
public Array ArraySort(Array arr, NLua.LuaFunction callback)
{
var comparer = new LuaSorter(callback);
Array.Sort(arr, comparer);
return(arr);
}
public CozyLuaFunction GetFunction(string fullPath)
{
NLua.LuaFunction func = mLua.GetFunction(fullPath);
if (func != null)
{
return(new CozyLuaFunction(func));
}
return(null);
}
public CozyLuaFunction RegisterFunction(string path, object target, MethodBase function)
{
NLua.LuaFunction func = mLua.RegisterFunction(path, target, function);
if (func != null)
{
return(new CozyLuaFunction(func));
}
return(null);
}
public void Process(NLua.Lua state)
{
try
{
F = state[FName] as NLua.LuaFunction;
}
catch (Exception)
{
}
}
internal void InitFrom(CommandInfo other)
{
description = other.description;
helpText = other.helpText;
accessLevel = other.accessLevel;
tokenCallback = other.tokenCallback;
stringCallback = other.stringCallback;
LuaCallback = other.LuaCallback;
ClearEvents();
}
public void AddEvent(Guid Id, string Occasion, NLua.LuaFunction Func)
{
Delegate Handler;
switch (Occasion)
{
case "OnTurn":
Handler = new EventHandler((Sender, Args) => { Console.WriteLine(@"CallSuccess"); Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
OnTurn += (EventHandler)Handler;
break;
case "Attacking":
Handler = new EventHandler <DoingEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
Attacking += (EventHandler <DoingEventArgs>)Handler;
break;
case "Attacked":
Handler = new EventHandler <DoneEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
Attacked += (EventHandler <DoneEventArgs>)Handler;
break;
case "UnderAttack":
Handler = new EventHandler <UnderAttackEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
UnderAttack += (EventHandler <UnderAttackEventArgs>)Handler;
break;
case "Defending":
Handler = new EventHandler <DoingEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
Defending += (EventHandler <DoingEventArgs>)Handler;
break;
case "Defended":
Handler = new EventHandler <DoneEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
Defended += (EventHandler <DoneEventArgs>)Handler;
break;
case "CountAttacking":
Handler = new EventHandler <DoingEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
CounterAttacking += (EventHandler <DoingEventArgs>)Handler;
break;
case "CountAttacked":
Handler = new EventHandler <DoneEventArgs>((Sender, Args) => { Func.Call(Sender, Args); });
EventDictionary.Add(Id, Handler);
CounterAttacked += (EventHandler <DoneEventArgs>)Handler;
break;
}
}
public void Wait(double Seconds, NLua.LuaFunction Action)
{
DispatcherTimer Timer = new DispatcherTimer()
{
Interval = System.TimeSpan.FromSeconds(Seconds)
};
Timer.Tick += delegate
{
Action.Call();
Timer.Stop();
};
Timer.Start();
}
public void ForEach(IEnumerable List, NLua.LuaFunction Function)
{
try
{
foreach (var Object in List)
{
Function.Call(Object);
}
}
catch (Exception ex)
{
((LuaDebug)LuaMain.LuaState["Debug"]).Log(
ex.Message, "Red");
}
}
public override void AddEventScript(string EventType, NLua.LuaFunction Event)
{
EventHandler <MouseEventArgs> E = new EventHandler <MouseEventArgs>(delegate(object s, MouseEventArgs e) { Event.Call(this, e); });
switch (EventType.ToLower())
{
case "click": OnClick += E; break;
case "right-click": OnRightClick += E; break;
case "mouse-over": OnMouseOver += E; break;
case "mouse-out": OnMouseOut += E; break;
case "leave": OnLeave += E; break;
case "update": base.AddEventScript("update", Event); break;
}
}
public void ChatMessageReceived(User user, bool IsMod, string Message)
{
// Should probably add an event handler, but RegisterLuaDelegateType is poorly documented.
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object state)
{
try
{
NLua.LuaFunction MessageReceived = Environment["event_MessageReceived"] as NLua.LuaFunction;
MessageReceived.Call(user.Username, IsMod, Message); // Safer way to call than using DoString
} catch (NLua.Exceptions.LuaScriptException e)
{
IRC_Functions.SendMessage(ParentChannel, "Script failed");
Log.Logger.OutputToConsole(e.ToString());
} catch {
// Do nothing
}
}), null);
}
internal bool CheckScript()
{
if (scriptFunction.Equals(""))
{
return(false);
}
else if (!scriptLoc.Equals(""))
{
NLua.Lua state = new NLua.Lua();
state.LoadCLRPackage();
try
{
state.DoFile(Game1.rootContent + scriptLoc);
}
catch (Exception)
{
script = null;
return(false);
}
bool bIsCorrectScriptAndFunction = state.GetFunction(scriptFunction) != null;
if (bIsCorrectScriptAndFunction)
{
script = state;
if (!modFunctionName.Equals(""))
{
modFunction = state.GetFunction(modFunctionName);
}
else
{
modFunction = null;
}
return(true);
}
return(false);
}
return(false);
}
public CommandInfo LuaCall(NLua.LuaFunction callback)
{
LuaCallback = callback;
return(this);
}
internal DangerTile(BasicTile tile, NLua.LuaFunction f)
{
parentLocation = tile;
callFunction = f;
}
public LuaSorter(NLua.LuaFunction callback)
{
_callback = callback;
}
public void SetAction(NLua.LuaFunction Action, object args)
{
_Load = delegate() { Action.Call(args); Finish(); };
}
public LuaList <T> Where(NLua.LuaFunction Function)
{
return(new LuaList <T>(Core.Where(O =>
(bool)Function.Call(O)[0]).ToList()));
}
public LuaDangerTile(LuaPoint p, NLua.LuaFunction f)
{
tile = p;
SetFunction(f);
}
internal void InitFrom(CommandInfo other)
{
description = other.description;
helpText = other.helpText;
accessLevel = other.accessLevel;
tokenCallback = other.tokenCallback;
stringCallback = other.stringCallback;
LuaCallback = other.LuaCallback;
ClearEvents();
}
internal void ClearCallbacks()
{
tokenCallback = null;
stringCallback = null;
LuaCallback = null;
}
public void DiceControl(int Probability, NLua.LuaFunction EndAction)
{
DiceControlAction?.Invoke(Probability, delegate { EndAction.Call(); });
}
public LuaList <T> OrderByDescending(NLua.LuaFunction Function)
{
return(new LuaList <T>(Core.OrderByDescending(O =>
Function.Call(O)[0]).ToList()));
}
public void SetFunction(NLua.LuaFunction f)
{
function = f;
}
internal void ClearCallbacks()
{
tokenCallback = null;
stringCallback = null;
LuaCallback = null;
}
public CommandInfo LuaCall(NLua.LuaFunction callback)
{
LuaCallback = callback;
return this;
}
/// <summary>
/// Constructor, takes a lua function.
/// </summary>
/// <param name="fun">Lua function running the task.</param>
public GroundScriptedTask(NLua.LuaFunction fun)
{
Status = EStatus.Waiting;
Task = new TransientScriptEvent(fun);
}
public LuaBindingInstance(LuaEvent <TArgs> handler, NLua.LuaFunction func)
{
Handler = handler;
BindFunction = func;
}
