public static void Clean(string ignoreName = "", object target = null, object targetMethod = null)
{
foreach (var eventListener in Events.listeners)
{
string eventName = eventListener.name;
object eventTarget = eventListener.target;
object eventMethod = eventListener.method;
bool duplicate = eventName != ignoreName && eventTarget == target && eventMethod.Equals(targetMethod);
bool invalid = eventTarget.IsNull() || eventMethod.IsNull() || (!eventListener.isStatic && ((Delegate)eventMethod).Target.IsNull());
if (duplicate || invalid)
{
UtilityCall.Delay(() => Events.listeners.Remove(eventListener));
if (Events.HasDebug("Remove"))
{
string messageType = eventMethod.IsNull() ? "empty method" : "duplicate method";
string message = "[Events] Removing " + messageType + " from -- " + eventTarget + "/" + eventName;
Log.Show(message, target);
}
}
}
foreach (var current in Events.callers)
{
object scope = current.Key;
if (scope.IsNull())
{
UtilityCall.Delay(() => Events.callers.Remove(scope));
}
}
}
public static void DelayCall(object target, object key, string name, float delay = 0.5f, params object[] values)
{
if (target.IsNull())
{
return;
}
UtilityCall.Delay(key, () => Events.Call(target, name, values), delay);
}
static Events()
{
Events.callers.Clear();
Events.cache.Clear();
Events.listeners.RemoveAll(x => x.name != "On Events Reset" && (!x.permanent || x.occurrences == 0));
UtilityCall.Delay(Events.Repair);
Events.Add("On Destroy", () => UtilityCall.Delay(Events.Repair));
foreach (var listener in Events.listeners)
{
var scope = Events.cache.AddNew(listener.target).AddNew(listener.name);
scope[listener.method] = listener;
}
Events.Call("On Events Reset");
}
public static void Remove(string name, object method, params object[] targets)
{
if (Events.HasDisabled("Add"))
{
return;
}
targets = Events.VerifyAll(targets);
foreach (var target in targets)
{
var removals = Events.listeners.Where(x => x.method == method && x.target == target && x.name == name).ToList();
removals.ForEach(x => x.Remove());
}
UtilityCall.Delay(Events.OnEventsChanged);
}
public static void RemoveAll(params object[] targets)
{
if (Events.HasDisabled("Add"))
{
return;
}
targets = Events.VerifyAll(targets);
foreach (var target in targets)
{
var removals = Events.listeners.Where(x => x.target == target || x.method.As <Delegate>().Target == target).ToList();
removals.ForEach(x => x.Remove());
Events.cache.AddNew(target).SelectMany(x => x.Value).Select(x => x.Value).ToList().ForEach(x => x.Remove());
Events.cache.Remove(target);
}
UtilityCall.Delay(Events.OnEventsChanged);
}
public static EventListener Add(string name, object method, int amount, params object[] targets)
{
if (Events.HasDisabled("Add"))
{
Log.Warning("[Events] : Add attempted while Events disabled. " + name);
return(null);
}
targets = Events.VerifyAll(targets);
var listener = Events.emptyListener;
foreach (object current in targets)
{
var target = current;
if (target.IsNull())
{
continue;
}
if (Events.unique.ContainsKey(target) && Events.unique[target].ContainsKey(name))
{
listener = Events.unique[target][name];
continue;
}
if (!Events.cache.AddNew(target).AddNew(name).ContainsKey(method))
{
listener = new EventListener();
if (Events.HasDebug("Add"))
{
var info = (Delegate)method;
Log.Show("[Events] : Adding event -- " + Events.GetMethodName(info) + " -- " + name, target);
}
Events.listeners.Add(listener);
UtilityCall.Delay(Events.OnEventsChanged);
}
else
{
listener = Events.cache[target][name].AddNew(method);
}
listener.name = name;
listener.method = method;
listener.target = target;
listener.occurrences = amount;
listener.isStatic = ((Delegate)method).Target.IsNull();
Events.cache.AddNew(target).AddNew(listener.name)[listener.method] = listener;
Events.cache.AddNew(Events.all).AddNew(listener.name)[listener.method] = listener;
}
return(listener);
}
