Initial

3 files changed, 2244 insertions, 0 deletions

diff --git a/System.c4g/Global.c b/System.c4g/Global.c
new file mode 100644
index 0000000..d3b126c
--- /dev/null
+++ b/System.c4g/Global.c
@@ -0,0 +1,419 @@
+#strict 2

+

+static Event_Stack;

+static Event_StackPos;

+static Event_Listeners;

+

+static const Event_Sender = 0;

+static const Event_Name = 1;

+static const Event_ReturnValue = 2;

+static const Event_Accepted = 3;

+static const Event_Prevented = 4;

+

+global func AddEventListener(eventName, array listener, int priority, customArgs)

+{

+	if(GetType(eventName) == C4V_Array)

+	{

+		for(var i = 0; i < GetLength(eventName); ++i)

+		{

+			if(GetType(customArgs) == C4V_Array)

+			{

+				AddEventListener(eventName[i], listener, priority, customArgs[i]);

+			}

+			else

+			{

+				AddEventListener(eventName[i], listener, priority, customArgs);

+			}

+		}

+		return;

+	}

+

+	if(GetType(customArgs) != C4V_Array)

+	{

+		customArgs = [customArgs];

+	}

+

+	var sender = this;

+	if(GetType(sender) == C4V_C4Object)

+	{

+		sender = ObjectNumber(sender);

+	}

+	if(GetLength(listener) == 3)

+	{

+		customArgs = listener[2];

+		listener = [listener[0], listener[1]];

+	}

+	var newListener = [listener, customArgs];

+	var listeners = GetEventListeners(sender, eventName);

+	var i;

+	for(i = 0; i < GetLength(listeners); ++i)

+	{

+		if(GetType(listeners[i]) != C4V_Array)

+		{

+			listeners[i] = [priority, [newListener]];

+			i = -1;

+			break;

+		}

+		else if(listeners[i][0] == priority)

+		{

+			listeners[i][1][GetLength(listeners[i][1])] = newListener;

+			i = -1;

+			break;

+		}

+		else if(listeners[i][0] > priority)

+		{

+			break;

+		}

+	}

+	if(i != -1)

+	{

+		var swap = listeners[i], swap2;

+		listeners[i] = [priority, [newListener]];

+		var length = GetLength(listeners);

+		for(; i < length; ++i)

+		{

+			swap2 = listeners[i + 1];

+			listeners[i + 1] = swap;

+			swap = swap2;

+		}

+	}

+	SetEventListeners(sender, eventName, listeners);

+}

+

+global func RemoveEventListener(sender, eventName, listener, customArgs)

+{

+	if(GetType(sender) == C4V_C4Object)

+	{

+		sender = ObjectNumber(sender);

+	}

+	if(sender == -1)

+	{

+		var i = 0;

+		for(var i = 0; i < GetLength(Event_Listeners); ++i)

+		{

+			if(GetType(Event_Listeners[i]) == C4V_Array)

+			{

+				RemoveEventListener(i, eventName, listener, customArgs);

+			}

+		}

+	}

+	else

+	{

+		if(eventName == -1)

+		{

+			for(var event in Event_Listeners[sender])

+			{

+				RemoveEventListener(sender, event[0], listener, customArgs);

+			}

+		}

+		else

+		{

+			var emptyPrios = 0;

+			var eventListeners = GetEventListeners(sender, eventName);

+			for(var i = 0; i < GetLength(eventListeners); ++i)

+			{

+				if(GetType(eventListeners[i]) != C4V_Array)

+				{

+					++emptyPrios;

+					continue;

+				}

+				var listeners = eventListeners[i][1];

+				eventListeners[i][1] = [];

+				for(var eventListener in listeners)

+				{

+					if(!((listener == -1 || eventListener[0] == listener) && (customArgs == -1 || eventListener[1] == customArgs)))

+					{

+						eventListeners[i][1][GetLength(eventListeners[i][1])] = eventListener;

+					}

+				}

+				if(GetLength(eventListeners[i][1]) == 0)

+				{

+					++emptyPrios;

+				}

+			}

+			if(emptyPrios == GetLength(eventListeners))

+			{

+				ClearEventListener(sender, eventName);

+			}

+			else

+			{

+				ClearEmptyPrios(eventListeners);

+				SetEventListeners(sender, eventName, eventListeners);

+			}

+		}

+	}

+}

+

+global func ClearEventListener(sender, eventName)

+{

+	var eventListeners = Event_Listeners[sender];

+	Event_Listeners[sender] = [];

+	for(var i = 0; i < GetLength(eventListeners); ++i)

+	{

+		if(eventListeners[i][0] != eventName)

+		{

+			Event_Listeners[sender][GetLength(Event_Listeners[sender])] = eventListeners[i];

+		}

+	}

+	if(GetLength(Event_Listeners[sender]) == 0)

+	{

+		Event_Listeners[sender] = 0;

+	}

+}

+

+global func ClearEmptyPrios(&prios)

+{

+	var oldPrios = prios;

+	prios = [];

+

+	for(var prio in oldPrios)

+	{

+		if(GetType(prio) == C4V_Array)

+		{

+			if(GetLength(prio[1]) != 0)

+			{

+				prios[GetLength(prios)] = prio;

+			}

+		}

+	}

+}

+

+global func GetEventListeners(sender, eventName)

+{

+	if(GetType(Event_Listeners) == C4V_Array && GetType(Event_Listeners[sender]))

+	{

+		for(var event in Event_Listeners[sender])

+		{

+			if(event[0] == eventName)

+			{

+				return event[1];

+			}

+		}

+	}

+	return [];

+}

+

+global func SetEventListeners(sender, eventName, listeners)

+{

+	if(GetType(Event_Listeners) != C4V_Array)

+	{

+		Event_Listeners = CreateArray(sender);

+		Event_Listeners[sender] = [[eventName, listeners]];

+	}

+	else

+	{

+		if(GetType(Event_Listeners[sender]) == C4V_Array)

+		{

+			for(var i = 0; i < GetLength(Event_Listeners[sender]); ++i)

+			{

+				if(Event_Listeners[sender][i][0] == eventName)

+				{

+					Event_Listeners[sender][i][1] = listeners;

+					return;

+				}

+			}

+		}

+		else

+		{

+			Event_Listeners[sender] = [];

+		}

+		Event_Listeners[sender][GetLength(Event_Listeners[sender])] = [eventName, listeners];

+	}

+}

+

+global func PushEvent(array event)

+{

+	if(GetType(Event_Stack) != C4V_Array)

+	{

+		/*Event_Stack = [0, 0]; // otherwise there is a really stupid operator "=" left side: got "any" but expected "&" error at this line in Event():

+		 *													// Event_Stack[Event_StackPos][Event_ReturnValue] = CallListener(listener[0], listener[1], args, event);

+		 *		Event_StackPos = 0;

+		 *		PopEvent();*/

+		Event_Stack = [];

+		Event_StackPos = -1;

+	}

+	Event_Stack[++Event_StackPos] = event;

+}

+

+global func PopEvent()

+{

+	if(Event_StackPos >= 0)

+	{

+		var event = Event_Stack[Event_StackPos];

+		SetLength(Event_Stack, Event_StackPos--);

+		return event;

+	}

+}

+

+global func Accept()

+{

+	Event_Stack[Event_StackPos][Event_Accepted] = true;

+}

+

+global func Prevent()

+{

+	Event_Stack[Event_StackPos][Event_Prevented] = true;

+}

+

+global func Accepted(array event)

+{

+	if(event)

+	{

+		return event[Event_Accepted];

+	}

+	else

+	{

+		return Event_Stack[Event_StackPos][Event_Accepted];

+	}

+}

+

+global func Prevented(array event)

+{

+	if(event)

+	{

+		return event[Event_Prevented];

+	}

+	else

+	{

+		return Event_Stack[Event_StackPos][Event_Prevented];

+	}

+}

+

+global func ReturnValue(array event)

+{

+	if(event)

+	{

+		return event[Event_ReturnValue];

+	}

+	else

+	{

+		return Event_Stack[Event_StackPos][Event_ReturnValue];

+	}

+}

+

+global func Event(string eventName, array args)

+{

+	var sender = this;

+	var event = [sender, eventName, 0, false, false];

+	PushEvent(event);

+

+	if(GetType(sender) == C4V_C4Object)

+	{

+		sender = ObjectNumber(sender);

+	}

+

+	var allListeners = [GetEventListeners(sender, eventName)];

+	if(sender != 0)

+	{

+		allListeners[1] = GetEventListeners(0, eventName);

+	}

+

+	for(var listeners in allListeners)

+	{

+		for(var listenerPrio in listeners)

+		{

+			if(GetType(listenerPrio) == C4V_Array)

+			{

+				for(var listener in listenerPrio[1])

+				{

+					var ret = CallListener(listener[0], listener[1], args, event);

+					var e = Event_Stack[Event_StackPos];

+					e[Event_ReturnValue] = ret;

+					Event_Stack[Event_StackPos] = e;

+

+					if(Accepted())

+					{

+						break;

+					}

+				}

+			}

+		}

+	}

+

+	event = PopEvent();

+	return event;

+}

+

+global func CallListener(array listener, array customArgs, array args, array event)

+{

+	if(GetType(listener[0]) == C4V_Any)

+	{

+		return eval(Format("%s(%s, %s, %s)", listener[1], Serialize(event), Serialize(customArgs), Serialize(args)));

+	}

+	else if(GetType(listener[0]) == C4V_C4Object)

+	{

+		if(GetType(listener[1]) == C4V_String)

+		{

+			return eval(Format("%s->%s(%s, %s, %s)", Serialize(listener[0]), listener[1], Serialize(event), Serialize(customArgs), Serialize(args)));

+		}

+		else if(GetType(listener[1]) == C4V_Array)

+		{

+			return listener[0]->f(listener[1], [event, customArgs, args]);

+		}

+	}

+	else if(listener[0] == -1 && event[0] != 0)

+	{

+		if(GetType(listener[1]) == C4V_String)

+		{

+			return eval(Format("%s->%s(%s, %s, %s)", Serialize(event[0]), listener[1], Serialize(event), Serialize(customArgs), Serialize(args)));

+		}

+		else if(GetType(listener[1]) == C4V_Array)

+		{

+			return event[0]->f(listener[1], [event, customArgs, args]);

+		}

+	}

+	else if(GetType(listener[0]) == C4V_Array)

+	{

+		return f(listener, [event, customArgs, args]);

+	}

+}

+

+global func Event_Adapter(target, string function, passArgs)

+{

+	return [target, "Event_AdapterListener", [target, function, passArgs]];

+}

+

+global func Event_AdapterListener(array event, array customArgs, array args)

+{

+	if(customArgs[2] == -1)

+	{

+		args = [];

+	}

+	else if(GetType(customArgs[2]) == C4V_Array)

+	{

+		args = customArgs[2];

+	}

+

+	var argString = "";

+	for(var i = 0; i < GetLength(args) && i < 10; ++i)

+	{

+		if(i != 0)

+		{

+			argString = Format("%s, ", argString);

+		}

+

+		argString = Format("%s%s", argString, Serialize(args[i]));

+	}

+

+	if(GetType(customArgs[0]) == C4V_Any || customArgs[0] == -1)

+	{

+		return eval(Format("%s(%s)", customArgs[1], argString));

+	}

+	else if(GetType(customArgs[0]) == C4V_C4Object)

+	{

+		return eval(Format("%s->%s(%s)", Serialize(customArgs[0]), customArgs[1], argString));

+	}

+}

+

+global func GameCallEx(string function)

+{

+	var event = Event(Format("GameCallEx%s", function), CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(function, ...);

+	}

+}

diff --git a/System.c4g/ObjectGlobals.c b/System.c4g/ObjectGlobals.c
new file mode 100644
index 0000000..7d6fe7d
--- /dev/null
+++ b/System.c4g/ObjectGlobals.c
@@ -0,0 +1,26 @@
+#strict 2

+

+global func SellTo(int iByPlr)

+{

+	return GetID();

+}

+

+global func CalcValue(object inBase, int forPlayer)

+{

+	return CalcDefValue(inBase, forPlayer);

+}

+

+global func CalcDefValue(object inBase, int forPlayer)

+{

+	return GetDefValue(GetID());

+}

+

+global func CalcBuyValue(id ID, int value)

+{

+	return value;

+}

+

+global func CalcSellValue(object obj, int value)

+{

+	return value;

+}

diff --git a/System.c4g/Objects.c b/System.c4g/Objects.c
new file mode 100644
index 0000000..14e5133
--- /dev/null
+++ b/System.c4g/Objects.c
@@ -0,0 +1,1799 @@
+#strict 2

+#appendto *

+

+local l;

+

+func Initialize()

+{

+	var event = Event("Initialize", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Construction()

+{

+	var event = Event("Construction", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Destruction()

+{

+	var event = Event("Destruction", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContentsDestruction()

+{

+	var event = Event("ContentsDestruction", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Hit()

+{

+	var event = Event("Hit", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Hit2()

+{

+	var event = Event("Hit2", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Hit3()

+{

+	var event = Event("Hit3", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Grab()

+{

+	var event = Event("Grab", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Grabbed()

+{

+	var event = Event("Grabbed", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Get()

+{

+	var event = Event("Get", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Put()

+{

+	var event = Event("Put", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Collection()

+{

+	var event = Event("Collection", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Collection2()

+{

+	var event = Event("Collection2", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Ejection()

+{

+	var event = Event("Ejection", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Entrance()

+{

+	var event = Event("Entrance", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Departure()

+{

+	var event = Event("Departure", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Completion()

+{

+	var event = Event("Completion", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Purchase()

+{

+	var event = Event("Purchase", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Sale()

+{

+	var event = Event("Sale", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Damage()

+{

+	var event = Event("Damage", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Incineration()

+{

+	var event = Event("Incineration", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func IncinerationEx()

+{

+	var event = Event("IncinerationEx", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Death()

+{

+	var event = Event("Death", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ActivateEntrance()

+{

+	var event = Event("ActivateEntrance", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+/*func Activate()

+{

+	var event = Event("Activate", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}*/

+

+func LiftTop()

+{

+	var event = Event("LiftTop", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDig()

+{

+	var event = Event("ContainedDig", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDigDouble()

+{

+	var event = Event("ContainedDigDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDigReleased()

+{

+	var event = Event("ContainedDigReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDigSingle()

+{

+	var event = Event("ContainedDigSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDown()

+{

+	var event = Event("ContainedDown", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDownDouble()

+{

+	var event = Event("ContainedDownDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDownReleased()

+{

+	var event = Event("ContainedDownReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedDownSingle()

+{

+	var event = Event("ContainedDownSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedLeft()

+{

+	var event = Event("ContainedLeft", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedLeftDouble()

+{

+	var event = Event("ContainedLeftDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedLeftReleased()

+{

+	var event = Event("ContainedLeftReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedLeftSingle()

+{

+	var event = Event("ContainedLeftSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedRight()

+{

+	var event = Event("ContainedRight", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedRightDouble()

+{

+	var event = Event("ContainedRightDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedRightReleased()

+{

+	var event = Event("ContainedRightReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedRightSingle()

+{

+	var event = Event("ContainedRightSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedThrow()

+{

+	var event = Event("ContainedThrow", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedThrowDouble()

+{

+	var event = Event("ContainedThrowDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedThrowReleased()

+{

+	var event = Event("ContainedThrowReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedThrowSingle()

+{

+	var event = Event("ContainedThrowSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedUp()

+{

+	var event = Event("ContainedUp", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedUpDouble()

+{

+	var event = Event("ContainedUpDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedUpReleased()

+{

+	var event = Event("ContainedUpReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedUpSingle()

+{

+	var event = Event("ContainedUpSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlCommand()

+{

+	var event = Event("ControlCommand", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlContents()

+{

+	var event = Event("ControlContents", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDig()

+{

+	var event = Event("ControlDig", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDigDouble()

+{

+	var event = Event("ControlDigDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDigReleased()

+{

+	var event = Event("ControlDigReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDigSingle()

+{

+	var event = Event("ControlDigSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDown()

+{

+	var event = Event("ControlDown", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDownDouble()

+{

+	var event = Event("ControlDownDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDownReleased()

+{

+	var event = Event("ControlDownReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlDownSingle()

+{

+	var event = Event("ControlDownSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlLeft()

+{

+	var event = Event("ControlLeft", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlLeftDouble()

+{

+	var event = Event("ControlLeftDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlLeftReleased()

+{

+	var event = Event("ControlLeftReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlLeftSingle()

+{

+	var event = Event("ControlLeftSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlRight()

+{

+	var event = Event("ControlRight", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlRightDouble()

+{

+	var event = Event("ControlRightDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlRightReleased()

+{

+	var event = Event("ControlRightReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlRightSingle()

+{

+	var event = Event("ControlRightSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecial()

+{

+	var event = Event("ControlSpecial", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecial2()

+{

+	var event = Event("ControlSpecial2", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecial2Double()

+{

+	var event = Event("ControlSpecial2Double", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecial2Released()

+{

+	var event = Event("ControlSpecial2Released", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecial2Single()

+{

+	var event = Event("ControlSpecial2Single", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecialDouble()

+{

+	var event = Event("ControlSpecialDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecialReleased()

+{

+	var event = Event("ControlSpecialReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlSpecialSingle()

+{

+	var event = Event("ControlSpecialSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlThrow()

+{

+	var event = Event("ControlThrow", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlThrowDouble()

+{

+	var event = Event("ControlThrowDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlThrowReleased()

+{

+	var event = Event("ControlThrowReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlThrowSingle()

+{

+	var event = Event("ControlThrowSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlUp()

+{

+	var event = Event("ControlUp", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlUpDouble()

+{

+	var event = Event("ControlUpDouble", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlUpReleased()

+{

+	var event = Event("ControlUpReleased", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlUpSingle()

+{

+	var event = Event("ControlUpSingle", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlWheelDown()

+{

+	var event = Event("ControlWheelDown", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlWheelUp()

+{

+	var event = Event("ControlWheelUp", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlUpdate()

+{

+	var event = Event("ControlUpdate", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContainedUpdate()

+{

+	var event = Event("ContainedUpdate", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContactTop()

+{

+	var event = Event("ContactTop", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContactBottom()

+{

+	var event = Event("ContactBottom", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContactLeft()

+{

+	var event = Event("ContactLeft", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ContactRight()

+{

+	var event = Event("ContactRight", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlCommand()

+{

+	var event = Event("ControlCommand", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlCommandFinished()

+{

+	var event = Event("ControlCommandFinished", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func DeepBreath()

+{

+	var event = Event("DeepBreath", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CatchBlow()

+{

+	var event = Event("CatchBlow", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func QueryCatchBlow()

+{

+	var event = Event("QueryCatchBlow", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Stuck()

+{

+	var event = Event("Stuck", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectCollect()

+{

+	var event = Event("RejectCollect", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectContents()

+{

+	var event = Event("RejectContents", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func GrabLost()

+{

+	var event = Event("GrabLost", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func LineBreak()

+{

+	var event = Event("LineBreak", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func BuildNeedsMaterial()

+{

+	var event = Event("BuildNeedsMaterial", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlTransfer()

+{

+	var event = Event("ControlTransfer", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func UpdateTransferZone()

+{

+	var event = Event("UpdateTransferZone", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CalcValue()

+{

+	var event = Event("CalcValue", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CalcDefValue()

+{

+	var event = Event("CalcDefValue", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func SellTo()

+{

+	var event = Event("SellTo", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func InputCallback()

+{

+	var event = Event("InputCallback", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func MenuQueryCancel()

+{

+	var event = Event("MenuQueryCancel", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func IsFulfilled()

+{

+	var event = Event("IsFulfilled", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func IsFulfilledforPlr()

+{

+	var event = Event("IsFulfilledforPlr", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectEntrance()

+{

+	var event = Event("RejectEntrance", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectFight()

+{

+	var event = Event("RejectFight", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func AttachTargetLost()

+{

+	var event = Event("AttachTargetLost", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CrewSelection()

+{

+	var event = Event("CrewSelection", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func GetObject2Drop()

+{

+	var event = Event("GetObject2Drop", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnMenuSelection()

+{

+	var event = Event("OnMenuSelection", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnActionJump()

+{

+	var event = Event("OnActionJump", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CalcBuyValue()

+{

+	var event = Event("CalcBuyValue", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func CalcSellValue()

+{

+	var event = Event("CalcSellValue", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func MouseSelection()

+{

+	var event = Event("MouseSelection", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnOwnerChanged()

+{

+	var event = Event("OnOwnerChanged", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func Recruitment()

+{

+	var event = Event("Recruitment", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func FireMode()

+{

+	var event = Event("FireMode", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func GetFairCrewPhysical()

+{

+	var event = Event("GetFairCrewPhysical", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func DoMagicEnergy()

+{

+	var event = Event("DoMagicEnergy", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func GetCustomComponents()

+{

+	var event = Event("GetCustomComponents", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectHostilityChange()

+{

+	var event = Event("RejectHostilityChange", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func RejectTeamSwitch()

+{

+	var event = Event("RejectTeamSwitch", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnHostilityChange()

+{

+	var event = Event("OnHostilityChange", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnTeamSwitch()

+{

+	var event = Event("OnTeamSwitch", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func OnOwnerRemoved()

+{

+	var event = Event("OnOwnerRemoved", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+

+func ControlCommandAcquire()

+{

+	var event = Event("ControlCommandAcquire", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func ControlCommandConstruction()

+{

+	var event = Event("ControlCommandConstruction", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func FindObject()

+{

+	var event = Event("FindObject", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func FindObject2()

+{

+	var event = Event("FindObject2", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}

+

+func FindObjects()

+{

+	var event = Event("FindObjects", CreateFilledArray(...));

+	if(Prevented(event))

+	{

+		return ReturnValue(event);

+	}

+	else

+	{

+		return _inherited(...);

+	}

+}