Upload 2197 files

scripts/$PBOPREFIX$.txt

@@ -0,0 +1,6 @@
+//<'scripts.pbo' properties via Mikero's dos tools, dll version 9.36>
+product=dayz;
+prefix=scripts;
+version=105080;
+//PboType=Arma Addon;
+//</properties>

scripts/1_Core/DayZ/constants.c

@@ -0,0 +1,106 @@
+/**
+ * \defgroup Constants Constants
+ * \desc static script constants
+ * @{
+ */
+
+
+/**
+ * \defgroup InputDevice InputDevice
+ * \desc constants for input device - inputInterfaceDef.h
+ * @{
+ */
+const int INPUT_MODULE_TYPE_MASK	= 0x00700000;
+const int INPUT_KEY_MASK			= 0x000000ff;
+const int INPUT_ACTION_TYPE_MASK	= 0x00000f00;
+const int INPUT_AXIS				= 0x00010000;
+const int INPUT_POV					= 0x00020000;
+const int INPUT_COMBO_MASK			= 0xff000000;
+const int INPUT_COMBO_AXIS			= 0x00800000;
+const int INPUT_COMBO_AXIS_OFFSET	= 0x00000080;
+const int INPUT_COMBO_KEY_OFFSET	= 0x01000000;
+
+const int INPUT_DEVICE_KEYBOARD   	= 0x00000000;
+const int INPUT_DEVICE_MOUSE      	= 0x00100000; // mouse button
+const int INPUT_DEVICE_STICK		= 0x00200000;
+const int INPUT_DEVICE_XINPUT     	= 0x00300000; // XInput device
+const int INPUT_DEVICE_TRACKIR		= 0x00400000;
+const int INPUT_DEVICE_GAMEPAD  	= 0x00500000;
+const int INPUT_DEVICE_CHEAT		= 0x00600000;
+
+const int INPUT_ACTION_TYPE_NONE			= 0x00000000;
+const int INPUT_ACTION_TYPE_STATE			= 0x00000100;
+const int INPUT_ACTION_TYPE_DOWN_EVENT		= 0x00000200;
+const int INPUT_ACTION_TYPE_UP_EVENT		= 0x00000300;
+const int INPUT_ACTION_TYPE_SHORTCLICK_EVENT= 0x00000400;
+const int INPUT_ACTION_TYPE_HOLD_EVENT		= 0x00000500;
+		
+const int INPUT_ACTION_TYPE_COMBO			= 0x00002000;
+const int INPUT_ACTION_TYPE_SPECIALCOMBO	= 0x00004000;
+const int INPUT_ACTION_TYPE_DOUBLETAP		= 0x00008000;
+
+const int INPUT_DEVICE_MOUSE_AXIS 		= (INPUT_DEVICE_MOUSE | INPUT_AXIS);
+const int INPUT_DEVICE_STICK_AXIS		= (INPUT_DEVICE_STICK | INPUT_AXIS);
+const int INPUT_DEVICE_STICK_POV		= (INPUT_DEVICE_STICK | INPUT_POV);
+const int INPUT_DEVICE_GAMEPAD_AXIS		= (INPUT_DEVICE_GAMEPAD | INPUT_AXIS);
+
+/** @}*/
+
+/**
+ * \defgroup StringConstants String constants
+ * \desc String constants
+ * @{
+ */
+const string STRING_EMPTY = "";
+/** @}*/
+
+
+/**
+
+ * \defgroup Colors Colors
+ * @{
+ */
+const int COLOR_WHITE = 0xFFFFFFFF;
+const int COLOR_RED = 0xFFF22613;
+const int COLOR_GREEN = 0xFF2ECC71;
+const int COLOR_BLUE = 0xFF4B77BE;
+const int COLOR_YELLOW = 0xFFF7CA18;
+
+const int COLOR_RED_A = 0x1fF22613;
+const int COLOR_GREEN_A = 0x1f2ECC71;
+const int COLOR_BLUE_A = 0x1f4B77BE;
+const int COLOR_YELLOW_A = 0x1fF7CA18;
+
+/** @}*/
+	
+/**
+
+ * \defgroup Materials Materials
+ * @{
+ */
+
+/****************************************************************************
+ *	MATERIALS LIST
+ *	
+ *	Note: If you add new materials here, don't forget to add physics
+ *	parameters to them in physics/materials.xml
+ ***************************************************************************/
+const int MATERIAL_DEFAULT			= 0;
+const int MATERIAL_METAL			= 1;	//full steel
+const int MATERIAL_IRON				= 2;	//iron
+const int MATERIAL_GLASS			= 3;	//glass pane
+const int MATERIAL_PLASTIC			= 4;	//plastic object
+const int MATERIAL_LIQUID			= 5;	//liquids, water
+const int MATERIAL_SLIME			= 6;	//slime, oil etc
+const int MATERIAL_BETON			= 7;	//concrete
+const int MATERIAL_RUBBER			= 8;	//rubber, linoeum
+const int MATERIAL_FLESH			= 9;	//flesh, humanoids
+const int MATERIAL_GRASS			= 10;	//grass
+const int MATERIAL_WOOD				= 11;	//wood
+const int MATERIAL_SNOW				= 12;	//snow
+const int MATERIAL_SAND				= 13;	//soft sand
+const int MATERIAL_DIRT				= 14;	//super-soft dirt
+const int MATERIAL_GRAVEL			= 15;	//gravel
+const int MATERIAL_STONE			= 16;	//rocks, cliffs
+
+/** @}*/

scripts/1_Core/DayZ/defines.c

@@ -0,0 +1,139 @@
+// All defines in this file are added from C++ side
+// It simply exists for documentation purposes
+#ifdef DOXYGEN
+
+/**
+ * \defgroup Defines Defines
+ * \desc static defines
+ * @{
+ */
+
+/*!
+	\brief Define filled in with the current Major and Minor version (e.g. DAYZ_1_16)
+*/
+#define DAYZ_X_XX
+
+/*!
+	\brief Enabled when game is in Buldozer mode
+*/
+#define BULDOZER
+
+/*!
+	\brief Enabled when script is compiled for Workbench
+*/
+#define WORKBENCH
+
+/*!
+	\note Present for server builds
+*/
+#define NO_GUI
+
+/*!
+	\note Present for server builds
+*/
+#define NO_GUI_INGAME
+
+/*!
+	\note Work in progress feature flag to prevent cursor from being hijacked by the game. Original intention was only DEVELOPER_DIAG but the fix later introduced problems in retail.
+*/
+#define FEATURE_CURSOR
+
+
+
+/**
+ * \defgroup BuildDefines Build defines
+ * \desc Defines for different builds
+ * @{
+ */
+
+	/*!
+		\brief Define present in Diag builds
+	*/
+	#define DIAG
+	
+	/*!
+		\note A build is always either DEVELOPER or RELEASE, one is always active
+	*/
+	#define DEVELOPER
+	
+	/*!
+		\note includes Diag
+	*/
+	#define RELEASE
+	
+	/*!
+		\brief DIAG || DEVELOPER
+	*/
+	#define DIAG_DEVELOPER
+	
+	/*!
+		\brief Define present in Experimental builds
+	*/
+	#define BUILD_EXPERIMENTAL
+
+/** @}*/
+
+
+
+/**
+ * \defgroup ServerDefines Server defines
+ * \desc Defines for dedicated server code
+ * \note Only defined when CGame.IsDedicatedServer equals true
+ * \note The platforms mentioned are the client platform, for game platform use PLATFORM defines
+ * @{
+ */
+
+	/*!
+		\brief Define always present on dedicated servers
+		\note Should be preferred over using CGame.IsDedicatedServer when possible
+	*/
+	#define SERVER
+	
+	/*!
+		\warning This is defined for Linux servers as well, as it targets Windows clients
+		\note A server is always either FOR_WINDOWS, FOR_X1 or FOR_PS4
+	*/
+	#define SERVER_FOR_WINDOWS
+	
+	/*!
+		\note A server is always either FOR_WINDOWS, FOR_X1 or FOR_PS4
+	*/
+	#define SERVER_FOR_X1
+	
+	/*!
+		\note A server is always either FOR_WINDOWS, FOR_X1 or FOR_PS4
+	*/
+	#define SERVER_FOR_PS4
+	
+	/*!
+		\brief SERVER_FOR_X1 || SERVER_FOR_PS4
+	*/
+	#define SERVER_FOR_CONSOLE
+
+/** @}*/
+
+
+
+/**
+ * \defgroup PlatformDefines Platform defines
+ * \desc Defines for platform the build is built for
+ * @{
+ */
+
+	#define PLATFORM_LINUX
+
+	#define PLATFORM_WINDOWS
+	
+	#define PLATFORM_XBOX
+	
+	#define PLATFORM_PS4
+	
+	/*!
+		\brief PLATFORM_XBOX || PLATFORM_PS4
+	*/
+	#define PLATFORM_CONSOLE
+
+/** @}*/
+
+/** @}*/
+#endif

scripts/1_Core/DayZ/param.c

@@ -0,0 +1,357 @@
+/**
+ * \defgroup Tools Tools
+ * \desc Helpful functions & classes
+ * @{
+ */
+
+//-----------------------------------------------------------------------------
+/**
+\brief Base Param Class with no parameters. Used as general purpose parameter overloaded with Param1 to Param4 templates
+ */
+class Param: Managed
+{
+	bool Serialize(Serializer ctx)
+	{
+		return false;
+	}
+		
+	bool Deserializer(Serializer ctx)
+	{
+		return false;
+	}
+};
+
+/**
+ \brief Param Class Template with one parameter.
+ \n usage:
+ @code
+ Param paramA = new Param1<int>(55); 
+ Param paramB = new Param1<string>("Hello");
+ @endcode
+ */
+class Param1<Class T1> extends Param
+{
+	T1 param1;
+
+	void Param1(T1 p1)
+	{
+		param1 = p1;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1);
+	}
+};
+
+/**
+ \brief Param Class Template with two parameters.
+ \n usage:
+ @code
+ Param param = new Param2<float, string>(3.14, "Pi");
+ @endcode
+ */
+class Param2<Class T1, Class T2> extends Param
+{
+	T1 param1;
+	T2 param2;
+
+	void Param2(T1 p1, T2 p2)
+	{
+		param1 = p1;
+		param2 = p2;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1) && ctx.Write(param2);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1) && ctx.Read(param2);
+	}
+};
+
+/**
+ \brief Param Class Template with three parameters.
+ \n usage:
+ @code
+ Param param = new Param3<float, string, bool>(2.89, "Lala", true);
+ @endcode
+ */
+class Param3<Class T1, Class T2, Class T3> extends Param
+{
+	T1 param1;
+	T2 param2;
+	T3 param3;
+
+	void Param3(T1 p1, T2 p2, T3 p3)
+	{
+		param1 = p1;
+		param2 = p2;
+		param3 = p3;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3);
+	}
+};
+
+/**
+ \brief Param Class Template with four parameters.
+ \n usage:
+ @code
+ Param param = new Param4<int, bool, float, string>(100, false, 79.9, "Test");
+ @endcode
+ */
+class Param4<Class T1, Class T2, Class T3, Class T4> extends Param
+{
+	T1 param1;
+	T2 param2;
+	T3 param3;
+	T4 param4;
+
+	void Param4(T1 p1, T2 p2, T3 p3, T4 p4)
+	{
+		param1 = p1;
+		param2 = p2;
+		param3 = p3;
+		param4 = p4;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4);
+	}
+};
+
+/**
+ \brief Param Class Template with five parameters.
+ */
+class Param5<Class T1, Class T2, Class T3, Class T4, Class T5> extends Param
+{
+	T1 param1;
+	T2 param2;
+	T3 param3;
+	T4 param4;
+	T5 param5;
+
+	void Param5(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
+	{
+		param1 = p1;
+		param2 = p2;
+		param3 = p3;
+		param4 = p4;
+		param5 = p5;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5);
+	}
+};
+
+/**
+ \brief Param Class Template with six parameters.
+ */
+class Param6<Class T1, Class T2, Class T3, Class T4, Class T5, Class T6> extends Param
+{
+	T1 param1;
+	T2 param2;
+	T3 param3;
+	T4 param4;
+	T5 param5;
+	T6 param6;
+
+	void Param6(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
+	{
+		param1 = p1;
+		param2 = p2;
+		param3 = p3;
+		param4 = p4;
+		param5 = p5;
+		param6 = p6;
+	}
+		
+	override bool Serialize(Serializer ctx)
+	{
+		return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5) && ctx.Write(param6);
+	}
+		
+	override bool Deserializer(Serializer ctx)
+	{
+		return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5) && ctx.Read(param6);
+	}
+};
+
+/**
+ \brief Param Class Template with seven parameters.
+ */
+class Param7<Class T1, Class T2, Class T3, Class T4, Class T5, Class T6, Class T7>: Param
+{
+    T1 param1;
+    T2 param2;
+    T3 param3;
+    T4 param4;
+    T5 param5;
+    T6 param6;
+    T7 param7;
+
+    void Param7(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
+    {
+        param1 = p1;
+        param2 = p2;
+        param3 = p3;
+        param4 = p4;
+        param5 = p5;
+        param6 = p6;
+        param7 = p7;
+    }
+        
+    override bool Serialize(Serializer ctx)
+    {
+        return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5) && ctx.Write(param6) && ctx.Write(param7);
+    }
+        
+    override bool Deserializer(Serializer ctx)
+    {
+        return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5) && ctx.Read(param6) && ctx.Read(param7);
+    }
+};
+/**
+ \brief Param Class Template with eight parameters.
+ */
+class Param8<Class T1, Class T2, Class T3, Class T4, Class T5, Class T6, Class T7, Class T8>: Param
+{
+    T1 param1;
+    T2 param2;
+    T3 param3;
+    T4 param4;
+    T5 param5;
+    T6 param6;
+    T7 param7;
+    T8 param8;
+
+    void Param8(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
+    {
+        param1 = p1;
+        param2 = p2;
+        param3 = p3;
+        param4 = p4;
+        param5 = p5;
+        param6 = p6;
+        param7 = p7;
+        param8 = p8;
+    }
+        
+    override bool Serialize(Serializer ctx)
+    {
+        return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5) && ctx.Write(param6) && ctx.Write(param7) && ctx.Write(param8);
+    }
+        
+    override bool Deserializer(Serializer ctx)
+    {
+        return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5) && ctx.Read(param6) && ctx.Read(param7) && ctx.Read(param8);
+    }
+};
+/**
+ \brief Param Class Template with nine parameters.
+ */
+class Param9<Class T1, Class T2, Class T3, Class T4, Class T5, Class T6, Class T7, Class T8, Class T9>: Param
+{
+    T1 param1;
+    T2 param2;
+    T3 param3;
+    T4 param4;
+    T5 param5;
+    T6 param6;
+    T7 param7;
+    T8 param8;
+    T9 param9;
+
+    void Param9(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
+    {
+        param1 = p1;
+        param2 = p2;
+        param3 = p3;
+        param4 = p4;
+        param5 = p5;
+        param6 = p6;
+        param7 = p7;
+        param8 = p8;
+        param9 = p9;
+    }
+        
+    override bool Serialize(Serializer ctx)
+    {
+        return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5) && ctx.Write(param6) && ctx.Write(param7) && ctx.Write(param8) && ctx.Write(param9);
+    }
+        
+    override bool Deserializer(Serializer ctx)
+    {
+        return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5) && ctx.Read(param6) && ctx.Read(param7) && ctx.Read(param8) && ctx.Read(param9);
+    }
+};
+/**
+ \brief Param Class Template with ten parameters.
+ */
+class Param10<Class T1, Class T2, Class T3, Class T4, Class T5, Class T6, Class T7, Class T8, Class T9, Class T10>: Param
+{
+    T1 param1;
+    T2 param2;
+    T3 param3;
+    T4 param4;
+    T5 param5;
+    T6 param6;
+    T7 param7;
+    T8 param8;
+    T9 param9;
+	T10 param10;
+
+    void Param10(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10)
+    {
+        param1 = p1;
+        param2 = p2;
+        param3 = p3;
+        param4 = p4;
+        param5 = p5;
+        param6 = p6;
+        param7 = p7;
+        param8 = p8;
+        param9 = p9;
+        param10 = p10;
+    }
+        
+    override bool Serialize(Serializer ctx)
+    {
+        return ctx.Write(param1) && ctx.Write(param2) && ctx.Write(param3) && ctx.Write(param4) && ctx.Write(param5) && ctx.Write(param6) && ctx.Write(param7) && ctx.Write(param8) && ctx.Write(param9) && ctx.Write(param10);
+    }
+        
+    override bool Deserializer(Serializer ctx)
+    {
+        return ctx.Read(param1) && ctx.Read(param2) && ctx.Read(param3) && ctx.Read(param4) && ctx.Read(param5) && ctx.Read(param6) && ctx.Read(param7) && ctx.Read(param8) && ctx.Read(param9) && ctx.Read(param10);
+    }
+};
+/** @}*/

scripts/1_Core/DayZ/proto/DbgUI.c

@@ -0,0 +1,94 @@
+/** @addtogroup Debug
+@{*/
+
+/**
+ * \defgroup DebugUI Debug UI API
+	\brief Immediate mode debug UI API
+ * @{
+	Per frame usage example:
+	@code
+	bool m_ShowDbgUI = false;
+	int m_DbgListSelection = 0;
+	float m_DbgSliderValue = 0.0;
+	autoptr array<string> m_DbgOptions = {"jedna", "dva", "tri"};
+	
+	void OnUpdate(float timeslice)
+	{	
+		DbgUI.Begin("Test");
+		DbgUI.Check("Show DbgUI", m_ShowDbgUI);
+		if (m_ShowDbgUI)
+		{
+			DbgUI.Text("DbgUI Test");		
+	
+			string name = "";
+			DbgUI.InputText("name", name);		
+			
+			if (DbgUI.Button("Print name"))
+			{
+				Print(name);		
+			}
+			
+			DbgUI.List("test list", m_DbgListSelection, m_DbgOptions);
+			
+			DbgUI.Text("Choice = " + m_DbgListSelection.ToString());	
+			
+			DbgUI.Spacer(10);
+			DbgUI.SliderFloat("slider", m_DbgSliderValue, 0, 100);
+			DbgUI.Text("Slider value = " + ftoa(m_DbgSliderValue));	
+		}
+		DbgUI.End();
+	}
+	@endcode
+
+	For non-per frame usage example:
+	@code
+	int m_DbgEventCount = 0;
+	void OnEvent(EventType eventTypeId, Param params)
+	{
+		m_DbgEventCount++;
+
+		DbgUI.BeginCleanupScope();		
+		DbgUI.Begin("events", 300, 0);
+		DbgUI.Text("Events count = " + m_DbgEventCount.ToString());
+		DbgUI.End();
+		DbgUI.EndCleanupScope();
+	}
+	@endcode
+*/
+
+class DbgUI
+{
+	private void DbgUI() {}
+	private void ~DbgUI() {}
+	
+	static proto native void DoUnitTest(); ///< Creates all possible DbgUI widgets. Just for the testing purposes.
+	static proto native void Text(string label);
+	static proto native void ColoredText(int color, string label);
+	static proto void Check(string label, out bool checked);
+	static proto void Combo(string label, out int selection, TStringArray elems);
+	static proto void List(string label, out int selection, TStringArray elems);
+	static proto void SliderFloat(string label, out float value, float min, float max, int pxWidth = 150);
+	static proto native void Spacer(int height);
+	static proto native void Panel(string label, int width, int height, int color = 0xaa555555);
+	static proto native bool Button(string txt, int minWidth = 0);
+	static proto void InputText(string txt, out string value, int pxWidth = 150);
+	static proto void InputInt(string txt, out int value, int pxWidth = 150);
+	static proto void InputFloat(string txt, out float value, int pxWidth = 150);
+			
+	static proto native void PlotLive(string label, int sizeX, int sizeY, float val, int timeStep = 100, int historySize = 30, int color = 0xFFFFFFFF);
+	
+	static proto native void SameLine();
+	static proto native void SameSpot();
+	
+	static proto native void PushID_Int(int int_id);
+	static proto native void PushID_Str(string str_id);
+	static proto native void PopID();
+	
+	static proto void BeginCleanupScope();
+    static proto native void EndCleanupScope();
+	
+	static proto native void Begin(string windowTitle, float x = 0, float y = 0);
+    static proto native void End();
+};
+//@}
+//@}

scripts/1_Core/DayZ/proto/EnAudio.c

@@ -0,0 +1,9 @@
+typedef int[] AudioHandle;
+
+class AudioSystem
+{
+	proto native static AudioHandle BankLoad(string path);
+	proto native static AudioHandle ShaderLoad(string path);
+	proto native static AudioHandle SoundPlay(AudioHandle bank, AudioHandle shader);
+	proto native static void SoundDestroy(AudioHandle handle);
+};

scripts/1_Core/DayZ/proto/EnConvert.c

@@ -0,0 +1,653 @@
+class bool
+{
+	string ToString()
+	{
+		if (value) return "true";
+		else return "false";
+	}
+};
+
+class func
+{
+	//! For internal usage of VM 
+	private proto void SetInstance(Class inst);
+};
+
+enum EBool
+{
+	NO = 0,
+	YES = 1	
+}
+
+class int
+{
+	protected const int ZERO_PAD_SIZE = 8;
+	protected static string m_ZeroPad[ZERO_PAD_SIZE] = {"", "0", "00", "000", "0000", "00000", "000000", "0000000"};
+	
+	const int MAX = 2147483647;
+	const int MIN = -2147483648;
+	
+	proto string ToString();
+	
+	/**
+	\brief Converts ASCII code to string
+		\param ascii ASCII code for convert to \p string.
+		\return \p string - Converted \p int.
+		@code
+			int ascii_code = 77;
+			string str = ascii_code.AsciiToString();
+			Print(str);
+
+			>> str = 'M'
+		@endcode
+	*/
+	proto string AsciiToString();
+	
+	/**
+	\brief Integer to string with fixed length, padded with zeroes
+		\param num \p int integer to convert
+		\param len \p int fixed length
+		\return \p vector Converted s as vector
+		@code
+			int num = 123;
+			string s = num.ToStringLen(5);
+			Print(s);
+
+			>> s = '00123'
+		@endcode
+	*/
+	string ToStringLen(int len)
+	{
+		string str = value.ToString();
+
+		int l = len - str.Length();
+
+		if (l > 0 && l < ZERO_PAD_SIZE )
+			return m_ZeroPad[l] + str;
+
+		return str;
+	}
+	
+	/**
+	\brief Check whether integer falls into an inclusive range
+		\param min \p int low end of range
+		\param max \p int high end of range
+		\return \p bool True if this value is withing the set range
+		@code
+			int num = 123;
+			bool test = num.InRange( 100, 150 );
+			Print(test);
+
+			>> s = true
+		@endcode
+	*/
+	bool InRange( int min, int max, bool inclusive_min = true, bool inclusive_max = true )
+	{
+		if( ( !inclusive_min && value <= min ) || value < min )
+			return false;
+		
+		if( ( !inclusive_max && value >= max ) || value > max )
+			return false;
+		
+		return true;
+	}
+};
+
+class float
+{
+	const float MIN = FLT_MIN;
+	const float MAX = FLT_MAX;
+	const float LOWEST = -FLT_MAX;
+	
+	proto string ToString();
+};
+
+class vector
+{
+	static const vector Up = "0 1 0";
+	static const vector Aside = "1 0 0";
+	static const vector Forward = "0 0 1";
+	static const vector Zero = "0 0 0";
+	
+	/**
+	\brief Vector to  string
+		\param beautify If true verbose vector in more human readable form "<1, 1, 1>" instead of simple form "1 1 1"
+		\return \p string Converted vector as parsed string
+		@code
+			vector v = "1 0 1";
+			Print( v.ToString() );
+			Print( v.ToString(false) );
+
+			>> '<1, 0, 1>'
+			>> '1 0 1'
+		@endcode
+	*/
+	proto string ToString(bool beautify = true);
+	
+	/**
+	\brief Normalizes vector. Returns length
+		\return \p float Length of origin vector
+		@code
+			vector vec = "1 0 1";
+			float length = vec.Normalize();
+			Print( vec );
+			Print( length );
+
+			>> vec = <0.707107,0,0.707107>
+			>> length = 1.41421
+		@endcode
+	*/
+	proto float Normalize();
+
+	//! return normalized vector (keeps orginal vector untouched)
+	proto vector Normalized();
+	
+	/**
+	\brief Returns length of vector (magnitude)
+		\return \p float Length of vector
+		@code
+			vector vec = "1 0 1";
+			float length = vec.Length();
+			Print( length );
+
+			>> length = 1.41421
+		@endcode
+	*/
+	proto native float Length();
+
+	/**
+	\brief Returns squared length (magnitudeSqr)
+		\return \p float Length of vector
+		@code
+			vector vec = "1 1 0";
+			float length = vec.LengthSq();
+			Print( length );
+
+			>> length = 2
+		@endcode
+	*/
+	proto native float LengthSq();
+	
+	/**
+	\brief Returns the distance between tips of two 3D vectors.
+		\param v1 \p vector 3D Vector 1
+		\param v2 \p vector 3D Vector 2
+		\return \p float Distance
+		@code
+			float dist = vector.Distance( "1 2 3", "4 5 6" );
+			Print( dist );
+
+			>> dist = 5.19615
+		@endcode
+	*/
+	proto static native float Distance(vector v1, vector v2);
+	
+	/**
+	\brief Returns the square distance between tips of two 3D vectors.
+		\param v1 \p vector 3D Vector 1
+		\param v2 \p vector 3D Vector 2
+		\return \p float Squere distance
+		@code
+			float dist = vector.DistanceSq( "0 0 0", "0 5 0" );
+			Print( dist );
+
+			>> dist = 25
+		@endcode
+	*/
+	proto static native float DistanceSq(vector v1, vector v2);
+
+	/**
+	\brief Returns perpendicular vector. Perpendicular vector is computed as cross product between input vector and up vector (0, 1, 0).
+	    \return \p vector perpendicular vector
+		@code
+			vector vec = "1 0 0";
+			Print( vec.Perpend() );
+
+			>> <0,0,1>
+		@endcode
+	*/
+	vector Perpend()
+	{
+		return value * vector.Up;
+	}
+	
+	/**
+	\brief Returns direction vector from point p1 to point p2
+	    \param p1 \p vector point from
+		\param p2 \p vector point to
+		\return \p vector direction vector
+	*/
+	static vector Direction(vector p1, vector p2)
+	{
+		vector dir_vec;
+		
+		dir_vec[0] = p2[0] - p1[0];
+		dir_vec[1] = p2[1] - p1[1];
+		dir_vec[2] = p2[2] - p1[2];
+		
+		return dir_vec;
+	}
+	
+	/**
+	\brief Returns randomly generated unit vector
+	    \return \p randomly generated unit vector
+		@code
+			vector vec = vector.RandomDir();
+			Print(vec);
+			Print(vec.Length());
+
+			>> <-0.179424,0.966825,0.181816>
+			>> 1
+		@endcode
+	*/
+	static vector RandomDir()
+	{
+		return Vector(Math.RandomFloatInclusive(-1,1),Math.RandomFloatInclusive(-1,1),Math.RandomFloatInclusive(-1,1)).Normalized();
+	}
+
+	/**
+	\brief Returns randomly generated XZ unit vector with the Y(up) axis set to 0
+	    \return \p randomly generated XZ unit vector
+		@code
+			vector vec = vector.RandomDir();
+			Print(vec);
+			Print(vec.Length());
+
+			>> <0.631697,0,0.775216>
+			>> 1
+		@endcode
+	*/
+	static vector RandomDir2D()
+	{
+		return Vector(Math.RandomFloatInclusive(-1,1),0,Math.RandomFloatInclusive(-1,1)).Normalized();
+	}
+	
+	/**
+	\brief Returns Dot product of vector v1 and vector v2
+	    \param v1 \p vector input vector
+		\param v2 \p vector input vector
+		\return \p vector direction vector
+	*/
+	static float Dot(vector v1, vector v2)
+	{
+		return ((v1[0] * v2[0]) + (v1[1] * v2[1]) + (v1[2] * v2[2]));
+	}
+
+	/**
+	\brief Returns relative angles between -180 and 180, not 0 to 360
+		\return \p float Relative angles
+		@code
+			vector angles = "-45 190 160";
+			Print( angles.GetRelAngles() );
+	
+			>> <-45,-170,160>
+		@endcode
+	*/
+	vector GetRelAngles()
+	{
+		for(int i = 0; i < 3; i++) {
+			if(value[i] > 180)
+				value[i] = value[i] - 360;
+			if(value[i] < -180)
+				value[i] = value[i] + 360;
+		}
+		return value;
+	}
+	
+	/**
+	\brief Returns yaw of vector
+		\param vec \p vector Vector to convert yaw
+		\return \p float Yaw of vector
+		@code
+			vector v1 = "0 1 0";
+			vector v2 = "0.7 0.7 0";
+			Print( v1.ToYaw() );
+			Print( v2.ToYaw() );
+
+			>> 90
+			>> 45
+		@endcode
+	*/
+	proto float VectorToYaw();
+
+	/**
+	\brief Returns vector of yaw
+		\param yaw \p float Value of yaw
+		\return \p vector Yaw converted in vector
+		@code
+			Print( vector.Yaw2Vector(90) );
+			Print( vector.Yaw2Vector(45) );
+
+			>> <0,1,0>
+			>> <0.707107,0.707107,0>
+		@endcode
+	*/
+	proto native static vector YawToVector(float yaw);
+
+	/**
+	\brief Converts vector to spherical coordinates with radius = 1
+		\return \p vector spherical coordinates (yaw, pitch, roll in degrees)
+		@code
+			vector v1 = "1 0 1";
+			vector v2 = "1 1 1";
+			Print( v1.VectorToAngles() );
+			Print( v2.VectorToAngles() );
+
+			>> <45,-0,0>
+			>> <45,35.2644,0>
+		@endcode
+	*/
+	proto vector VectorToAngles();
+
+	/**
+	\brief Converts spherical coordinates (yaw, pitch, roll in degrees) to unit length vector
+		\return \p normalized direction vector
+		@code
+			vector v1 = "45 0 0";
+			vector v2 = "15 60 0";
+			Print( v1.AnglesToVector() );
+			Print( v2.AnglesToVector() );
+
+			>> <0.707107,0,0.707107>
+			>> <0.12941,0.866025,0.482963>
+		@endcode
+	*/
+	proto vector AnglesToVector();
+
+	/**
+	\brief Creates rotation matrix from angles
+		\param ang \p vector which contains angles
+	    \param[out] mat \p vector created rotation matrix
+		@code
+	        vector mat[3];
+			vector ang = "70 15 45";
+	    	ang.RotationMatrixFromAngles( mat );
+	    	Print( mat );
+
+			>> <0.330366,0.0885213,-0.939693>,<0.458809,0.854988,0.241845>,<0.824835,-0.511037,0.241845>
+		@endcode
+	*/
+	proto void RotationMatrixFromAngles(out vector mat[3]);
+	
+	/**
+	\brief Transforms position
+		\param mat \p vector[4] transformation matrix
+		\param vec \p vector position to transform
+		\return \p vector transformed position
+		@code
+			vector mat[4] = { "1 0 0 0", "0 1 0 0", "0 0 1 1", "3 1 2 1" }; // translation matrix
+			vector pos = "1 1 1";
+			Print( pos.Multiply4(mat) );
+
+			>> <4,2,3>
+		@endcode
+	*/
+	proto vector Multiply4(vector mat[4]);
+
+	/**
+	\brief Transforms vector
+		\param mat \p vector[3] transformation matrix
+		\param vec \p vector vector to transform
+		\return \p vector transformed vector
+		@code
+			vector mat[3] = { "2 0 0", "0 3 0", "0 0 1" }; // scale matrix
+			vector vec = "1 1 1";
+			Print( vec.Multiply3(mat) );
+
+			>> <2,3,1>
+		@endcode
+	*/
+	proto vector Multiply3(vector mat[3]);
+
+	/**
+	\brief Invert-transforms position
+		\param mat \p vector[4] transformation matrix
+		\param vec \p vector position to transform
+		\return \p vector transformed position
+		@code
+			vector mat[4] = { "1 0 0 0", "0 1 0 0", "0 0 1 1", "3 1 2 1" }; // translation matrix
+			vector pos = "1 1 1";
+			Print( pos.InvMultiply4(mat) );
+
+			>> <-2,0,-1>
+		@endcode
+	*/
+	proto vector InvMultiply4(vector mat[4]);
+
+	/**
+	\brief Invert-transforms vector
+		\param mat \p vector[3] transformation matrix
+		\param vec \p vector vector to transform
+		\return \p vector transformed vector
+		@code
+			vector mat[3] = { "1.5 2.5 0", "0.1 1.3 0", "0 0 1" }; // rotation matrix
+			vector vec = "1 1 1";
+			Print( vec.InvMultiply3(mat) );
+
+			>> <4,1.4,1>
+		@endcode
+	*/
+	proto vector InvMultiply3(vector mat[3]);
+	
+	/**
+	\brief Lerp between two vectors
+		@code
+			vector v1 = Vector(0,0,0);
+			vector v2 = Vector(5,6,1);
+			Print( vector.Lerp(v1, v2, 0.5) );
+		@endcode
+	*/
+	proto static native vector Lerp(vector v1, vector v2, float t);
+	
+	/**
+	\brief Rotate a vector around 0,0,0 by an angle in degrees
+		\param vec \p vector to rotate
+		\param axis \p axis to rotate around
+		\param cosAngle \p angle in degrees
+		\return \p vector transformed vector
+	*/
+	
+	static vector RotateAroundZeroDeg(vector vec, vector axis, float angle)
+	{
+		return (vec * Math.Cos(angle * Math.DEG2RAD)) + ((axis * vec) * Math.Sin(angle * Math.DEG2RAD)) + (axis * vector.Dot(axis, vec)) * (1 - Math.Cos(angle * Math.DEG2RAD));
+	}
+	
+	/**
+	\brief Rotate a vector around 0,0,0 by an angle in radians
+		\param vec \p vector to rotate
+		\param axis \p axis to rotate around
+		\param cosAngle \p angle in radians
+		\return \p vector transformed vector
+	*/
+	
+	static vector RotateAroundZeroRad(vector vec, vector axis, float angle)
+	{
+		return (vec * Math.Cos(angle)) + ((axis * vec) * Math.Sin(angle)) + (axis * vector.Dot(axis, vec)) * (1 - Math.Cos(angle));
+	}
+	
+	/**
+	\brief Rotate a vector around 0,0,0
+		\param pos \p vector to rotate
+		\param axis \p axis to rotate around
+		\param cosAngle \p cos of angle
+		\param sinAngle \p sin of angle
+		\return \p vector transformed vector
+	*/
+	
+	static vector RotateAroundZero(vector pos, vector axis, float cosAngle, float sinAngle)
+	{
+		return (pos * cosAngle) + ((axis * pos) * sinAngle) + (axis * vector.Dot(axis, pos)) * (1 - cosAngle);
+	}
+	
+	/**
+	\brief Rotate a vector around point
+		\param point \p point to rotate around
+		\param pos \p vector to rotate
+		\param axis \p axis to rotate around
+		\param cosAngle \p cos of angle
+		\param sinAngle \p sin of angle
+		\return \p vector transformed vector
+	*/
+	static vector RotateAroundPoint(vector point, vector pos, vector axis, float cosAngle, float sinAngle)
+	{
+		vector offsetPos = pos - point;
+		return RotateAroundZero(offsetPos, axis, cosAngle, sinAngle) + point;
+	}
+	
+	/**
+	\brief Convert static array of floats into a vector
+	    \param arr \p vector in array format
+		\return \p vector resulting vector
+	*/
+	static vector ArrayToVec(float arr[])
+	{
+		return Vector(arr[0], arr[1], arr[2]);
+	}
+};
+
+class typename
+{
+	/**
+	\brief Dynamic variant to 'new' keyword. It creates new instance of class
+		\returns \p volatile instance of class
+		@code
+			???
+		@endcode
+	*/
+	proto volatile Class Spawn();
+	
+	/**
+	\brief Get the name of the module the typename belongs to
+		\returns \p string Name of parent module (1_Core)
+	*/
+	proto owned string GetModule();
+	
+	//!Returns type name of variable as string
+	proto native owned string ToString();
+	
+	/**
+	\brief Returns true when type is the same as 'baseType', or inherited one.
+		\param baseType typename
+		\returns \p bool true when type is the same as 'baseType', or inherited one.
+		@code
+			???
+		@endcode
+	*/
+	proto native bool IsInherited(typename baseType);
+	
+	proto native int GetVariableCount();
+	proto native owned string GetVariableName(int vIdx);
+	proto native typename GetVariableType(int vIdx);
+	proto bool GetVariableValue(Class var, int vIdx, out void val);
+	
+	/**
+	\brief Return string name of enum value
+	@code
+		DialogPriority prio = DialogPriority.WARNING;
+		Print( typename.EnumToString(DialogPriority, prio) );
+	@endcode
+	*/
+	static string EnumToString(typename e, int enumValue)
+	{
+		int cnt = e.GetVariableCount();
+		int val;
+
+		for (int i = 0; i < cnt; i++)
+		{
+			if (e.GetVariableType(i) == int && e.GetVariableValue(null, i, val) && val == enumValue)
+			{
+				return e.GetVariableName(i);
+			}
+		}
+				
+		return "unknown";
+	}
+	
+	/**
+	\brief Return enum value from string name
+	@code
+		Print( typename.StringToEnum(DialogPriority, "WARNING") );
+	@endcode
+	*/
+	static int StringToEnum(typename e, string enumName)
+	{
+	    int count = e.GetVariableCount();
+	    int value;
+	   
+	    for (int i = 0; i < count; i++)
+	    {
+	        if (e.GetVariableType(i) == int && e.GetVariableValue(null, i, value) && e.GetVariableName(i) == enumName)
+	        {
+	            return value;
+	        }
+	    }
+		
+	    return -1;
+	}
+};
+
+class EnumTools
+{
+	private void EnumTools();
+	private void ~EnumTools();
+	
+	/**
+	\brief Return string name of enum value
+	@code
+		DialogPriority prio = DialogPriority.WARNING;
+		Print( EnumTools.EnumToString(DialogPriority, prio) );
+	@endcode
+	*/
+	static string EnumToString(typename e, int enumValue)
+	{
+		return typename.EnumToString(e, enumValue);
+	}
+	
+	/**
+	\brief Return enum value from string name
+	@code
+		Print( EnumTools.StringToEnum(DialogPriority, "WARNING") );
+	@endcode
+	*/
+	static int StringToEnum(typename e, string enumName)
+	{
+		return typename.StringToEnum(e, enumName);
+	}
+	
+	/**
+	\brief Return amount of values in enum
+	@code
+		Print( EnumTools.GetEnumSize(DialogPriority) );
+	@endcode
+	*/
+	static int GetEnumSize(typename e)
+	{
+		return e.GetVariableCount();
+	}
+	
+	/**
+	\brief Return the nth value in the enum
+	@code
+		Print( EnumTools.GetEnumValue(DialogPriority, 1) );
+	@endcode
+	*/
+	static int GetEnumValue(typename e, int idx)
+	{
+		int value;
+		e.GetVariableValue(null, idx, value);		
+		return value;
+	}
+	
+	/**
+	\brief Return amount of values in enum
+	@code
+		Print( EnumTools.GetLastEnumValue(DialogPriority) );
+	@endcode
+	*/
+	static int GetLastEnumValue(typename e)
+	{
+		int lastValue;
+		e.GetVariableValue(null, e.GetVariableCount() - 1, lastValue);		
+		return lastValue;
+	}
+}

scripts/1_Core/DayZ/proto/EnDebug.c

@@ -0,0 +1,341 @@
+/**
+ * \defgroup Debug Debug utilities
+ * @{
+ */
+
+/**
+\brief Prints current call stack (stack trace)
+	\return \p void
+	@code
+		DumpStack();
+
+	@endcode
+
+	\verbatim
+	Output:
+		-- Stack trace --
+	   SaveFile() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler.c : 51
+	   SaveConfigToFile() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 114
+	   SaveParameterArray() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 133
+	   SetParameterArray() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 231
+	   PresetAdd() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile\ModuleLocalProfileUI.h : 46
+	   OnKeyPress() Scripts/mission/missionGameplay.c : 215
+	   OnKeyPress() Scripts/DayZGame.c : 334
+	   -----------------
+	\endverbatim
+*/
+proto void DumpStack();
+
+/**
+\brief Prints current call stack (stack trace) to given output
+	\return \p void
+	@code
+    string tmp;
+		DumpStackString(tmp);
+    Print(tmp);
+
+	@endcode
+
+	\verbatim
+	Output:
+	  SaveFile() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler.c : 51
+	  SaveConfigToFile() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 114
+	  SaveParameterArray() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 133
+	  SetParameterArray() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile.c : 231
+	  PresetAdd() Scripts\Entities\Modules\ModuleBase\ModuleFileHandler\ModuleLocalProfile\ModuleLocalProfileUI.h : 46
+	  OnKeyPress() Scripts/mission/missionGameplay.c : 215
+	  OnKeyPress() Scripts/DayZGame.c : 334
+	\endverbatim
+*/
+proto void DumpStackString(out string stack);
+
+//! Triggers breakpoint in C++ in run time(when app is running in debug enviroment)
+proto void DebugBreak(bool condition = true, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+
+//! Triggers breakpoint in C++ in compile time(when app is running in debug enviroment)
+void CompileBreak();
+
+//! Prints content of variable to console/log. Should be used for critical messages so it will appear in debug log
+proto void DPrint(string var);
+
+enum ErrorExSeverity
+{
+	INFO,
+	WARNING,
+	ERROR,
+}
+
+/**
+\brief Error message, prefixed by method name, above 'INFO' will show a messagebox
+	\note Format: [%className%::%methodName%] :: [%severity%] :: %errString%
+	\param \p string Error message to use
+	@code
+	class ErrorExTest
+	{
+		void ThrowWarning()
+		{
+			// [ErrorExTest::ThrowWarning] :: [WARNING] :: This is a warning.
+			ErrorEx("This is a warning.", ErrorExSeverity.WARNING);		
+		}
+	}
+	@endcode
+*/
+proto void ErrorEx(string err, ErrorExSeverity severity = ErrorExSeverity.ERROR);
+proto void ErrorExString(string err, out string str, ErrorExSeverity severity = ErrorExSeverity.ERROR);
+
+//! Messagebox with error message
+proto native void Error2(string title, string err);
+
+//! Messagebox with error message
+void Error(string err)
+{
+	Error2("", err);
+}
+
+//!Prints content of variable to console/log
+proto void Print(void var);
+
+//!Prints content of variable to RPT file (performance warning - each write means fflush! use with care)
+proto void PrintToRPT(void var);
+	
+/**
+\brief Prints formated text to console/log
+	@code
+		string c = "Peter";
+		PrintFormat("Hello %1, how are you?", c); // prints "Hello 'Peter', how are you?"
+	@endcode
+*/	
+proto void PrintFormat(string fmt, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+
+	//------------------------------------------
+/**
+ * \defgroup DebugShape Debug Shape API definition
+ * @{
+ */
+enum ShapeType
+{
+	BBOX,			//<	Just box
+	LINE,			//<	One or more lines
+	SPHERE,		//<	Sphere represented by triangle mesh
+	CYLINDER,	//<	Cylinder represented by triangle mesh
+	DIAMOND,	//< Eight faced pyramid. Defined by bound-box, where middle part is  equal to horizontal extents of box and top/bottom apogees lies on top/bottom side of box.
+	PYRAMID	//< Four sided pyramid. Defined by bound-box, where base is equal to bottom side of box.
+};
+
+enum ShapeFlags
+{
+	NOZBUFFER,	//< Do not compare z-buffer when render
+	NOZWRITE,		//< Do not update z-buffer when render
+	WIREFRAME,	//< Render just wire-frame outline. No solid faces
+	TRANSP,			//< Is translucent
+	DOUBLESIDE,	//< Double-sided (do not cull back-faces)
+	ONCE,				//< Rendered just once and then it's automatically destroyed. Do not keep pointer to these!!
+	NOOUTLINE,	//< Render just solid faces. No wire-frame outline.
+	BACKFACE,		//< Render just back faces
+	NOCULL,			//< Do not cull shapes by view frustum
+	VISIBLE,		//< Make it visible. Set by default
+	ADDITIVE		//< Additive blending (works with ShapeFlags.TRANSP)
+};
+
+enum CollisionFlags
+{
+	FIRSTCONTACT,	//<In many cases only collided=true/false is enough
+	NEARESTCONTACT	//<We want only one, the nearest contact
+	ONLYSTATIC		//<Only static objects
+	ONLYDYNAMIC		//<Only dynamic objects
+	ONLYWATER		//<Only water components (legacy support for "walk on geometry")
+	ALLOBJECTS		//<Valid when CF_FIRST_CONTACT, we get first contact for each object
+}
+		
+/*!
+Instance of created debug visualizer
+*/
+class Shape
+{
+	//!don't call destructor directly. Use Destroy() instead
+	proto private void ~Shape();
+
+	proto native void GetMatrix(out vector mat[4]);
+	proto native void SetMatrix(vector mat[4]);
+	proto native void SetDirection(vector direction);
+	proto native void SetPosition(vector position);
+	proto native void SetColor(int color);
+	proto native void SetFlags(ShapeFlags flags);
+	proto native void Destroy();
+
+	proto static native Shape Create(ShapeType type, int color, ShapeFlags flags, vector p1, vector p2);
+	proto static native Shape CreateLines(int color, ShapeFlags flags, vector p[], int num);
+	proto static native Shape CreateTris(int color, ShapeFlags flags, vector p[], int num);
+	proto static native Shape CreateSphere(int color, ShapeFlags flags, vector origin, float radius);
+	proto static native Shape CreateFrustum(float horizontalAngle, float verticalAngle, float length, int color, ShapeFlags flags);
+	proto static native Shape CreateCylinder(int color, ShapeFlags flags, vector origin, float radius, float length);
+
+	static Shape CreateArrow(vector from, vector to, float size, int color, ShapeFlags flags)
+	{
+		vector dir = to - from;
+		dir.Normalize();
+		vector dir1 = dir * size;
+		size = size * 0.5;
+	
+		vector dir2 = dir.Perpend() * size;
+	
+		vector pts[5];
+		pts[0] = from;
+		pts[1] = to;
+		pts[2] = to - dir1 - dir2;
+		pts[3] = to - dir1 + dir2;
+		pts[4] = to;
+	
+		return CreateLines(color, flags, pts, 5);
+	}
+
+	static Shape CreateBridgeArrow(vector from, vector to, float size, int color, ShapeFlags flags)
+	{
+		vector dir = to - from;
+		dir.Normalize();
+	
+		vector dir1 = Vector(0, 0, -size);
+		size = size * 0.5;
+	
+		vector dir2 = dir.Perpend() * size;
+	
+		vector pts[7];
+		pts[0] = from;
+		pts[1] = from + "0 0 1";
+		pts[2] = to + "0 0 1";
+		pts[3] = to;
+		pts[4] = to - dir1 - dir2;
+		pts[5] = to - dir1 + dir2;
+		pts[6] = to;
+	
+		return CreateLines(color, flags, pts, 7);
+	}
+
+	static void CreateMatrix(vector mat[4])
+	{
+		vector org = mat[3];
+		int flags = ShapeFlags.NOZWRITE|ShapeFlags.DOUBLESIDE|ShapeFlags.TRANSP|ShapeFlags.ONCE;
+		Create(ShapeType.LINE, 0xffff0000, flags, org, mat[0] * 0.5 + org);
+		Create(ShapeType.LINE, 0xff00ff00, flags, org, mat[1] * 0.5 + org);
+		Create(ShapeType.LINE, 0xff0000ff, flags, org, mat[2] * 0.5 + org);
+	}
+};
+
+//@}
+
+
+//------------------------------------------
+/**
+ * \defgroup DiagMenu Diag menu API definition
+ * @{
+ */
+class DiagMenu
+{
+	//! Checks if DiagMenu is initialized
+	static proto bool IsInitialized();
+	
+	//! To be used before registering scripted diags
+	static proto void InitScriptDiags();
+	//! To be used when scripted diags should not be present
+	static proto void ClearScriptDiags();
+	
+	/**
+	\brief Register a new menu
+		\param id \p int The unique ID of the menu in the range [0,512]
+		\param name \p string The name of the menu
+		\param parent \p int The index of the parent of the menu
+	*/
+	static proto void RegisterMenu(int id, string name, int parent);
+	
+	/**
+	\brief Register a new item
+		\param id \p int The unique ID of the item in the range [0,512]
+		\param shortcut \p string The keyboard shortcut of the item
+		\param name \p string The name of the item
+		\param parent \p int The index of the parent of the item
+		\param values \p string The values of the item separated by commas, internally this will be an int starting at 0 for the first item
+		\param callback \p func Callback to call when the value is changed (OPTIONAL) (Also read BindCallback)
+	*/
+	static proto void RegisterItem(int id, string shortcut, string name, int parent, string values, func callback = null);
+	
+	/**
+	\brief Register a new bool item
+	\note This is just a RegisterItem with value="true,false" or when reversed value="false,true"
+		\param id \p int The unique ID of the item in the range [0,512]
+		\param shortcut \p string The keyboard shortcut of the item
+		\param name \p string The name of the item
+		\param parent \p string The index of the parent of the item
+		\param values \p string The values of the item, separated by commas
+		\param reverse \p bool Whether to reverse the bool (OPTIONAL)
+		\param callback \p func Callback to call when the value is changed (OPTIONAL) (Also read BindCallback)
+	*/
+	static proto void RegisterBool(int id, string shortcut, string name, int parent, bool reverse = false, func callback = null);
+
+	/**
+	\brief Register a new range item
+		\param id \p int The unique ID of the item in the range [0,512]
+		\param shortcut \p string The keyboard shortcut of the item
+		\param name \p string The name of the item
+		\param parent \p int The index of the parent of the item
+		\param values \p string Range specification in format "min,max,startValue,step"
+		\param callback \p func Callback to call when the value is changed (OPTIONAL) (Also read BindCallback)
+	*/
+	static proto void RegisterRange(int id, string shortcut, string name, int parent, string valuenames, func callback = null);
+	
+	//! Unregister the item at given id
+	static proto void Unregister(int id);
+	
+	//! Check if the item at given id has been registered
+	static proto bool IsRegistered(int id);
+	
+	/**
+	*\brief Bind a callback to the given id
+	*	\note Only one callback can be registered, so when attempting to registering multiple, only the last one will be present
+	*	\note The callbacks are required to have one of following signatures
+	*		- All Register... support:
+	*			o static void Callback();
+	*		- RegisterItem & RegisterBool:
+	*			o static void Callback(int value);
+	*			o static void Callback(int value, int id);
+	*			o static void Callback(bool value);
+	*			o static void Callback(bool value, int id);
+	*		- RegisterRange:
+	*			o static void Callback(float value);
+	*			o static void Callback(float value, int id);
+	*			o static void Callback(int value);
+	*			o static void Callback(int value, int id);
+	*	\note Keep in mind that bool and int are interchangeable, so 'bool value' is possible for RegisterRange too
+	*/
+	static proto bool BindCallback(int id, func callback);
+	//! Unbind the callback from the given id
+	static proto void UnbindCallback(int id);
+	
+	//! Get value as bool from the given script id
+	static proto bool GetBool(int id, bool reverse = false);
+	//! Get value as int from the given script id
+	static proto int GetValue(int id);
+	//! Set value at the given script id
+	static proto void SetValue(int id, int value);
+	
+	//! Get range value at the given script id 
+	static proto float GetRangeValue(int id);
+	//! Set range value at the given script id
+	static proto void SetRangeValue(int id, float value);
+	
+	//! Get value at the given engine id
+	static proto int GetEngineValue(int id);
+	//! Set value at the given engine id
+	static proto void SetEngineValue(int id, int value);
+	
+	//! Get range value at the given engine id
+	static proto float GetEngineRangeValue(int id);
+	//! Set range value at the given engine id
+	static proto void SetEngineRangeValue(int id, float value);
+	
+	//! Check if a menu with supplied name already exists
+	static proto bool MenuExists(string name);	
+};
+
+//@}
+
+//@}

scripts/1_Core/DayZ/proto/EnEntity.c

@@ -0,0 +1,870 @@
+typedef int[] BaseContainer;		
+typedef int[] IEntitySource;
+typedef int[] WidgetSource;
+	
+class BaseContainer	
+{
+	proto native owned string GetClassName();
+	proto native owned string GetName();
+	proto native int VarIndex(string varName);
+	proto native bool IsVariableSet(int varIndex);
+	proto bool IsType(int varIndex, typename type);
+	proto bool Get(int varIndex, out void val);
+};
+
+class IEntitySource: BaseContainer
+{
+	proto native IEntitySource GetChildren();
+	proto native IEntitySource GetSibling();
+	proto native IEntitySource GetParent();
+};
+
+class WidgetSource: BaseContainer
+{
+	proto native WidgetSource GetChildren();
+	proto native WidgetSource GetSibling();
+	proto native WidgetSource GetParent();
+};
+
+/**
+ * \defgroup EntityAPI Entity system
+ * @{
+ */
+
+/**
+ * \defgroup EntityAttributes Entity editor attribute system
+ * @{
+ */
+
+		
+		
+//@}
+	
+ //!Entity events for event-mask, or throwing event from code
+enum EntityEvent
+{
+	//! entity was touched by other entity
+	TOUCH,
+
+	/*!
+	entity is visible, so part of the rendering
+	other		WorldClass
+	extra		frame index
+	result	false should be rendered, true shoudn't be rendered
+	*/
+	VISIBLE, 
+	
+	/*!
+	entity is not visible, will not be part of rendering
+	other		WorldClass
+	extra		frame index
+	*/
+	NOTVISIBLE, 
+
+	/*!
+	new frame event, called each frame
+	other		WorldClass
+	extra		frame index
+	*/
+	FRAME,
+
+	/*!
+	event at the end of each frame or when entity is moved during the frame
+	other		WorldClass
+	*/
+	POSTFRAME,
+
+	/*!
+	event called after the world is created, including all entities
+	other		WorldClass
+	*/
+	INIT,      	
+
+//Only with MeshObject
+//ANIMEND	- End of AF_ONCE animation, extra = slot number 0...11
+//ANIMBLEND - Animation blended from previous one, extra = slot number 0...11
+
+
+//SOUNDEND	- playing of SFL_ONCE sound has ended
+// extra		= pointer to a sound handle
+
+//USER
+
+	JOINTBREAK,
+	SIMULATE,
+	POSTSIMULATE,
+	PHYSICSMOVE,
+	CONTACT,
+	EXTRA,
+	ANIMEVENT,
+	SOUNDEVENT,
+	PHYSICSSTEADY,
+	USER,
+	
+	//! Object entered Trigger
+	ENTER,
+	//! Object left Trigger
+	LEAVE,
+	
+	//!Mask of all events
+	ALL
+};
+
+//!Entity flags
+enum EntityFlags
+{
+/*!
+Entity is visible. Is rendered if there is some attached object
+and event EntityEvent.VISIBLE is invoked, when event mask is set.
+*/
+	VISIBLE,
+
+
+	SOLID,	///<Is collidable by various trace methods
+	TRIGGER,	///<Is not collidable, but invokes touch events.
+	TOUCHTRIGGERS,	///<Interacts with triggers
+	SYNCHRONIZATION_DIRTY,	///<Entity wants to synchronize (network)
+
+	FEATURE,	///<Scene rendering hint for dominant objects that are not culled by standard way
+/*!
+Used by tracing methods. When tracing with TraceFlags.PASSTRANSLUCENT,
+then this entity is ignored. Used for glass for example.
+*/
+	TRANSLUCENT,
+
+//!Used by tracing methods. Traceable only with flag TraceFlags.WATER
+	WATER,
+
+/*!
+Tells that this entity has to be actively updated by engine, its
+EntityEvent.FRAME has to be called etc.
+*/
+	ACTIVE,
+
+/*!
+Tells that this entity will represent mostly static object, so
+we can use more precise but slower methods for scene-tree linking.
+Also it tells to scene tree that he can count with this entity as
+tree-split hint.
+*/
+	STATIC,
+
+//!Flags for custom usage and filterings.
+	USER1,
+	USER2,
+	USER3,
+	USER4,
+	USER5,
+	USER6
+};
+
+/*!
+Internal ancestor of all Entity implementations.
+*/
+class IEntity: Managed
+{
+//DO NOT INSERT ANYTHING BELOW - order of event methods matters!
+/** \name Event methods
+ Event method stubs. Reimplement these in inherited entities to receive event calls			
+*/
+//@{
+	event protected void EOnTouch(IEntity other, int extra) //!EntityEvent.TOUCH
+	{
+	}
+	event protected void EOnInit(IEntity other, int extra) //!EntityEvent.INIT
+	{
+	}
+	event protected void EOnExtra(IEntity other, int extra)	//!EntityEvent.EXTRA
+	{
+	}
+	event protected void EOnNotVisible(IEntity other, int extra) //!EntityEvent.NOTVISIBLE
+	{
+	}
+	event protected void EOnFrame(IEntity other, float timeSlice) //!EntityEvent.FRAME
+	{
+	}
+	event protected int  EOnVisible(IEntity other, int extra) //!EntityEvent.VISIBLE
+	{
+	}
+	event protected void EOnPostFrame(IEntity other, int extra) //!EntityEvent.POSTFRAME
+	{
+	}
+	event protected void EOnWorldProcess(IEntity other, int extra) //!EntityEvent.WORLDPROCESS
+	{
+	}
+	event protected void EOnAnimEvent(IEntity other, AnimEvent extra) //!EntityEvent.ANIMEVENT
+	{
+	}
+	event protected void EOnSoundEvent(IEntity other, SoundEvent extra) //!EntityEvent.SOUNDEVENT
+	{
+	}
+	event protected void EOnSimulate(IEntity other, float dt) //!EntityEvent.SIMULATE
+	{
+	}
+	event protected void EOnPostSimulate(IEntity other, float timeSlice)	//!EntityEvent.POSTSIMULATE
+	{
+	}
+	event protected void EOnJointBreak(IEntity other, int extra) //!EntityEvent.JOINTBREAK
+	{
+	}
+	event protected void EOnPhysicsMove(IEntity other, int extra) //!EntityEvent.PHYSICSMOVE
+	{
+	}
+	event protected void EOnContact(IEntity other, Contact extra) //!EntityEvent.CONTACT
+	{
+	}
+	protected void EOnUser0(IEntity other, int extra) //!EntityEvent.EV_USER+0
+	{
+	}
+	protected void EOnUser1(IEntity other, int extra) //!EntityEvent.EV_USER+1
+	{
+	}
+	event protected void EOnEnter(IEntity other, int extra) //!EntityEvent.ENTER
+	{
+	}
+	event protected void EOnLeave(IEntity other, int extra) //!EntityEvent.LEAVE
+	{
+	}
+	protected void EOnUser4(IEntity other, int extra) //!EntityEvent.EV_USER+4
+	{
+	}
+	protected void EOnDummy020(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy021(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy022(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy023(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy024(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy025(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy026(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy027(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy028(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy029(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy030(IEntity other, int extra)	//!Placeholder
+	{
+	}
+	protected void EOnDummy031(IEntity other, int extra)	//!Placeholder
+	{
+	}
+//@}
+//DO NOT INSERT ANYTHING ABOVE - order of event methods matters!
+
+	/** \name Transformation methods
+		Setting and getting of entity transformation
+	*/
+	//@{
+
+	/**
+	\brief Returns transformation of Entity. It returns only so much vectors as array is big
+		\param mat \p vector[1...4] matrix to be get
+		@code
+			Man player = g_Game.GetPlayer();
+	
+			vector mat[4];
+			player.GetTransform(mat);
+			Print( mat );
+	
+			>> <0.989879,-0,0.141916>,<0,1,0>,<-0.141916,0,0.989879>,<2545.08,15.6754,2867.49>
+		@endcode
+	*/
+	proto external void GetTransform(out vector mat[]);
+
+	/**
+	\brief Returns render transformation of Entity. Must pass in vector array size of 4
+		\param mat \p vector[4] matrix to be get
+		@code
+			Man player = g_Game.GetPlayer();
+	
+			vector mat[4];
+			player.GetRenderTransform(mat);
+			Print( mat );
+	
+			>> <0.989879,-0,0.141916>,<0,1,0>,<-0.141916,0,0.989879>,<2545.08,15.6754,2867.49>
+		@endcode
+	*/
+	proto external void GetRenderTransform(out vector mat[]);
+
+	/**
+	\brief Returns local transformation of Entity. It returns only so much vectors as array is big
+		\param mat \p vector[1...4] matrix to be get
+		@code
+			Man player = g_Game.GetPlayer();
+	
+			vector mat[4];
+			player.GetTransform(mat);
+			Print( mat );
+	
+			>> <0.989879,-0,0.141916>,<0,1,0>,<-0.141916,0,0.989879>,<2545.08,15.6754,2867.49>
+		@endcode
+	*/
+	proto external void GetLocalTransform(out vector mat[]);
+
+	/**
+	\brief Returns one row of Entity transformation matrix
+		\param axis \p int matrix axis. Can be 0..3
+		\return \p vector axis row of Entity matrix
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetTransformAxis(0) );
+			Print( player.GetTransformAxis(1) );
+			Print( player.GetTransformAxis(2) );
+			Print( player.GetTransformAxis(3) );
+	
+			>> <-0.386781,0,0.922171>
+			>> <0,1,0>
+			>> <-0.922171,0,-0.386782>
+			>> <2551.34,15.6439,2856.72>
+		@endcode
+	*/
+	proto native external vector GetTransformAxis(int axis);
+
+	/**
+	\brief Sets entity transformation
+		\param mat \p vector[4] matrix to be set
+		@code
+			vector mat[4];
+			Math3D.MatrixIdentity( mat )
+	
+			Man player = g_Game.GetPlayer();
+			player.SetTransform( mat );
+	
+			vector outmat[4];
+			player.GetTransform(outmat );
+			Print( outmat );
+	
+			>> <1,0,0>,<0,1,0>,<0,0,1>,<0,0,0>
+		@endcode
+	*/
+	proto native external void SetTransform(vector mat[4]);
+
+	/**
+	\brief Returns origin of Entity
+		\return \p vector entity origin
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetOrigin() );
+	
+			>> <2577.02,15.6837,2924.27>
+		@endcode
+	*/
+	proto native external vector GetOrigin();
+	
+	/**
+	\brief Returns local position of Entity
+		\return \p vector entity local position
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetOrigin() );
+	
+			>> <2577.02,15.6837,2924.27>
+		@endcode
+	*/
+	proto external vector GetLocalPosition();
+	
+	/**
+	\brief Returns orientation of Entity in world space (Yaw, Pitch, Roll)
+		\return \p vector entity orientation
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetYawPitchRoll() );
+	
+			>> <180,-76.5987,180>
+		@endcode
+	*/
+	proto native external vector GetYawPitchRoll();
+
+	/**
+	\brief Same as GetYawPitchRoll, but returns rotation vector around X, Y and Z axis.
+	*/
+	proto native external vector GetAngles();
+
+	/**
+	\brief Returns local orientation when it's in hierarchy (Yaw, Pitch, Roll)
+		\return \p vector local orientation
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetLocalYawPitchRoll() );
+	
+			>> <180,-57.2585,180>
+		@endcode
+	*/
+	proto native external vector GetLocalYawPitchRoll();
+
+	/**
+	\brief Same as GetLocalYawPitchRoll, but returns rotation vector around X, Y and Z axis.
+	*/
+	proto native external vector GetLocalAngles();
+
+	/**
+	\brief Sets angles for entity (Yaw, Pitch, Roll)
+		\param angles \p vector angles to be set
+		@code
+			Man player = g_Game.GetPlayer();
+			player.SetYawPitchRoll("180 50 180" );
+			Print( player.GetYawPitchRoll() );
+	
+			>> <-180,50,-180>
+		@endcode
+	*/
+	proto native external void SetYawPitchRoll(vector angles);
+
+	/**
+	\brief Same as SetYawPitchRoll, but sets rotation around X, Y and Z axis.
+	*/
+	proto native external void SetAngles(vector angles);
+	
+	/**
+	\brief Sets origin for entity
+		\param orig \p vector origin to be set
+		@code
+			Man player = g_Game.GetPlayer();
+			player.SetOrigin("2550 10 2900" );
+			Print( player.GetOrigin() );
+	
+			>> <2550,10,2900>
+		@endcode
+	*/
+	proto native external void SetOrigin(vector orig);
+
+	proto native external float GetScale();
+	proto native external void SetScale(float scale);
+	/**
+	\brief Transforms local vector to world space
+	    \param vec \p vector local space vector to transform
+		\return \p vector world space vector
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.VectorToParent("1 2 3") );
+
+			>> <2.89791,2,1.26575>
+		@endcode
+	*/
+	proto native external vector VectorToParent(vector vec);
+
+	/**
+	\brief Transforms local position to world space
+		\param coord \p vector local position to transform
+		\return \p vector position in world space
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.CoordToParent("1 2 3") );
+
+			>> <2549,17.6478,2857>
+		@endcode
+	*/
+	proto native external vector CoordToParent(vector coord);
+
+	/**
+	\brief Transforms world space vector to local space
+		\param vec \p vector world space vector to transform
+		\return \p vector local space vector
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.VectorToLocal("2 1 5") );
+
+			>> <-0.166849,1,5.38258>
+		@endcode
+	*/
+	proto native external vector VectorToLocal(vector vec);
+
+	/**
+	\brief Transforms world space position to local space
+		\param coord \p vector world space position to transform
+		\return \p vector position in local space
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.CoordToLocal("500 10 155") );
+
+			>> <15254,-54.2004,8745.53>
+		@endcode
+	*/
+	proto native external vector CoordToLocal(vector coord);
+
+	//@}
+
+
+	/** \name Name/ID methods		
+	*/
+	//@{
+
+	/**
+	\brief Return unique entity ID
+		\return \p int unique entity ID
+		@code
+			ItemBase apple = g_Game.CreateObject( "FruitApple", String2Vector("0 10 0"), false );
+			Print( apple.GetID() );
+
+			>> 0
+		@endcode
+	*/
+	proto native int GetID();
+
+	/**
+	\brief Set unique entity ID
+		\param id \p int unique entity ID to be set
+		@code
+			ItemBase apple = g_Game.CreateObject( "Fruit_Apple", String2Vector("0 10 0"), false );
+			apple.SetID(101);
+			Print( apple.GetID() );
+
+			>> 101
+		@endcode
+	*/
+	proto native void SetID(int id);
+	
+	proto native void SetName(string name);
+	proto native external owned string GetName();
+	//@}
+	
+
+	/** \name Hierarchy methods
+		Scene hierarchy management
+	*/
+	//@{
+
+	/**
+	\brief Adds child entity to this entity.
+		\note Make sure the parent is not ToDelete
+		\param child \p IEntity Pointer to entity which become our child
+		\param pivot \p int Pivot is pivot index, or -1 for center of parent.
+		\param positionOnly \p bool When set to true, the orientation will still be in WS.
+		\return \p bool True when entity has been attached. False otherwise.
+	*/
+	proto native external bool AddChild(notnull IEntity child, int pivot, bool positionOnly = false);
+	
+	/**
+	\brief Removes child entity from hierarchy.
+		\note Make sure the child is not ToDelete
+		\param child \p IEntity Pointer to child entity we want to remove.
+		\param keepTransform \p bool When set to true, Entity is kept on her world position. Otherwise it's local transform is used as world-space one.
+		\return \p bool True if it was removed, false when this entity is not our child.
+	*/
+	proto native external bool RemoveChild(notnull IEntity child, bool keepTransform = false);
+	
+	//! Returns if the hierarchy component was created with positionOnly
+	proto native bool IsHierarchyPositionOnly();
+
+	//! Returns the hierarchy component pivot
+	proto native int GetHierarchyPivot();
+
+	//! Returns pointer to parent Entity in hierarchy
+	proto native IEntity GetParent();
+	//! Returns pointer to first child Entity in hierarchy
+	proto native IEntity GetChildren();
+	//! Returns pointer to next child Entity on the same hierarchy
+	proto native IEntity GetSibling();
+	//@}
+
+	/**
+	\brief Returns local bounding box of model on Entity
+		\param[out] mins \p vector minimum point of bounding box
+		\param[out] maxs \p vector maximum point of bounding box
+		@code
+			Man player = g_Game.GetPlayer();
+	
+			vector mins, maxs;
+			player.GetBounds(mins, maxs );
+	
+			Print( mins );
+			Print( maxs );
+	
+			>> <0,0,0>
+			>> <0,0,0>
+		@endcode
+	*/
+	proto external void GetBounds(out vector mins, out vector maxs);
+	
+	/**
+	\brief Returns quantized world-bound-box of Entity
+		\param[out] mins \p vector minimum point of bounding box
+		\param[out] maxs \p vector maximum point of bounding box
+		@code
+			Man player = g_Game.GetPlayer();
+	
+			vector mins, maxs;
+			player.GetWorldBounds( mins, maxs );
+	
+			Print( mins );
+			Print( maxs );
+	
+			>> <2547.2,15.5478,2852.85>
+			>> <2548.8,17.5478,2855.05>
+		@endcode
+	*/
+	proto external void GetWorldBounds(out vector mins, out vector maxs);
+	
+	/** \name Simulation/handling properties
+	Flags that affects simulation and entity handling behavior
+	*/
+	//@{
+	/**
+	\brief Returns Entity flags
+		\return \p EntityFlags entity flags
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetFlags() );
+	
+			>> 1610612745
+		@endcode
+	*/
+	proto native external EntityFlags GetFlags();
+	
+	/**
+	\brief Test if one or more of specified flags are set
+		\return \p bool True if is set, false otherwise.
+		@code
+			Man player = g_Game.GetPlayer();
+			player.SetFlags(EntityFlags.VISIBLE);
+			Print( player.IsFlagSet(EntityFlags.VISIBLE) );
+	
+			>> true
+		@endcode
+	*/
+	proto native external bool IsFlagSet(EntityFlags flags);
+
+	/**
+	\brief Sets Entity flags. It's OR operation, not rewrite. Returns previous flags
+		\param flags \p int flags to be set
+		\param recursively flags will be recursively applied to children of hierarchy too
+		\return \p int previous flags
+		@code
+			Man player = g_Game.GetPlayer();
+			player.SetFlags(EntityFlags.VISIBLE|EntityFlags.SOLID );
+			Print( player.GetFlags() );
+	
+			>> 1610612747
+		@endcode
+	*/
+	proto native external EntityFlags SetFlags(EntityFlags flags, bool recursively);
+
+	/**
+	\brief Clear Entity flags. Returns cleared flags
+		\param flags \p int flags to be set
+		\param recursively flags will be recursively applied to children of hierarchy too
+		\return \p int cleared flags
+		@code
+			Man player = g_Game.GetPlayer();
+			player.ClearFlags(EntityFlags.VISIBLE|EntityFlags.SOLID );
+			Print( player.GetFlags() );
+	
+			>> 1610612744
+		@endcode
+	*/
+	proto native external EntityFlags ClearFlags(EntityFlags flags, bool recursively);
+
+
+	/**
+	\brief Returns current event mask
+		\return \p int current event mask
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetEventMask() );
+	
+			>> 0
+		@endcode
+	*/
+	proto native external EntityEvent GetEventMask();
+
+	/**
+	\brief Sets event mask
+		\param e combined mask of one or more members of EntityEvent enum
+		@code
+			Man player = g_Game.GetPlayer();
+			Print( player.GetEventMask() );
+			player.SetEventMask( EntityEvent.VISIBLE );
+			Print( player.GetEventMask() );
+	
+			>> 0
+			>> 128
+		@endcode
+	*/
+	proto native external EntityEvent SetEventMask(EntityEvent e );
+
+	/**
+	\brief Clears event mask
+		\param e \p int event mask
+		\return \p int event mask
+		@code
+			Man player = g_Game.GetPlayer();
+			player.SetEventMask(EntityEvent.VISIBLE );
+			Print( player.GetEventMask() );
+			player.ClearEventMask(EntityEvent.ALL );
+			Print( player.GetEventMask() );
+	
+			>> 128
+			>> 0
+		@endcode
+	*/
+	proto native external EntityEvent ClearEventMask(EntityEvent e);
+	
+	//!Dynamic event invokation. Parameters are the same as in IEntity::EOnXXXX() methods
+	proto external volatile void SendEvent(notnull IEntity actor, EntityEvent e, void extra);
+
+//@}
+
+/** \name Visual component methods
+ Manipulation with visual component - model, particle effect etc			
+*/
+//@{
+
+	/**
+	\brief Sets the visual object to this entity. Reference is added and released upon entity destruction
+	\param object handle to object got by GetObject()
+	\param options String, dependant on object type.
+	//Only supported one for XOB objects:
+	//$remap 'original material name' 'new material'; [$remap 'another original material name' 'anothernew material']
+	*/
+	proto native external void SetObject(vobject object, string options);
+	
+	/**
+	\brief Returns visual object set to this Entity. No reference is added
+	*/
+	proto native vobject GetVObject();
+
+	//!Updates animation (either xob, or particle, whatever)
+	proto native external int Animate(float speed, int loop);
+	//!Updates animation (either xob, or particle, whatever)
+	proto native external int AnimateEx(float speed, int loop, out vector lin, out vector ang);
+
+	//!Sets visibility mask for cameras, where Entity will be rendered
+	proto native external int SetCameraMask(int mask);	
+//@}
+
+	/**
+	\brief When called, the Entity is excluded from consequent TraceMove/TraceLine
+	*/
+	proto native external void FilterNextTrace();
+
+	/*!
+	Updates entity state/position. Should be called when you want to manually commit position changes etc
+	before trace methods etc. Entity is updated automatically at the end and the beginning of simulation step,
+	when it has EntityFlags.TFL_ACTIVE flag set.
+	\returns mask with flags
+	//	EntityFlags.UPDATE - hierarchy has been updated
+	//	EntityFlags.UPDATE_MDL - model hierarchy has been updated
+	*/
+	proto native external int Update();
+		
+#ifdef COMPONENT_SYSTEM		
+	//! Constructor
+	protected void IEntity(IEntitySource src, IEntity parent);	
+#endif		
+};
+
+#ifdef ENF_DONE
+// Set fixed LOD. -1 for non-fixed LOD
+proto native void SetFixedLOD(IEntity ent, int lod);
+//Sets the texture that can be referenced from material as $renderview
+//and connects it with camera cam_index. Size iz recommended size of
+//rendertarget (0 is default)
+proto native void SetRenderView(IEntity ent, int cam_index, int width, int height);
+proto void GetRenderView(IEntity ent, out int cam_index, out int width, out int height);
+#endif
+
+
+/**
+ * \defgroup EntityAttributes Entity editor attribute system
+ * @{
+ */
+
+class ParamEnum: Managed
+{
+	string m_Key;
+	string m_Value;
+	string m_Desc;
+	
+	void ParamEnum(string key, string value, string desc = "")
+	{
+		m_Key = key;
+		m_Value = value;
+		m_Desc = desc;
+	}
+}
+
+class ParamEnumArray: array<ref ParamEnum>
+{
+	static ParamEnumArray FromEnum(typename e)
+	{
+		ParamEnumArray params = new ParamEnumArray();	
+		int cnt = e.GetVariableCount();
+		int val;
+
+		for (int i = 0; i < cnt; i++)
+		{
+			if (e.GetVariableType(i) == int && e.GetVariableValue(NULL, i, val))
+			{
+				params.Insert(new ParamEnum(e.GetVariableName(i), val.ToString()));
+			}
+		}
+				
+		return params;
+	}	
+}
+
+// -------------------------------------------------------------------------
+class Attribute
+{
+	string m_DefValue;
+	string m_UiWidget; ///< can be "editbox", "combobox", "spinbox", "slider", "font", "fileeditbox", "colorPicker", "flags", "resourceNamePicker"
+	string m_RangeScale; ///< defined as "MIN_VALUE MAX_VALUE STEP" eg. "1 100 0.5"
+	string m_Desc;
+	ref ParamEnumArray m_Enums; ///< Only ints and floats are currently supported. Array can be defined this way: { ParamEnum("Choice 1", "1"), ParamEnum("Choicen 2", "2") }
+	
+	void Attribute(string defvalue, string uiwidget, string desc = "", string rangescale = "", ParamEnumArray enums = NULL)
+	{
+		m_DefValue = defvalue;
+		m_UiWidget = uiwidget;
+		m_RangeScale = rangescale;
+		m_Desc = desc;
+		m_Enums = enums;
+	}
+}
+
+class EditorAttribute
+{
+	string m_Style; ///< can be "box", "sphere", "cylinder", "pyramid", "diamond" or custom style name
+	string m_Category; ///< folder structure eg. StaticEntities/Walls
+	string m_Description; ///< class purpose description
+	vector m_SizeMin; ///< min vector of a bounding box
+	vector m_SizeMax; ///< max vector of a bounding box
+	string m_Color;
+	string m_Color2;
+	bool m_Visible;
+	bool m_Insertable;
+	bool m_DynamicBox;
+	
+	void EditorAttribute(string style, string category, string description, vector sizeMin, vector sizeMax, string color, string color2 = "0 0 0 0", bool visible = true, bool insertable = true, bool dynamicBox = false)
+	{
+		m_Style = style;
+		m_Category = category;
+		m_Description = description;
+		m_SizeMin = sizeMin;
+		m_SizeMax = sizeMax;
+		m_Color = color;
+		m_Color2 = color2;
+		m_Visible = visible;
+		m_Insertable = insertable;
+		m_DynamicBox = dynamicBox;
+	}
+}
+//@}
+
+//@}

scripts/1_Core/DayZ/proto/EnMath.c

@@ -0,0 +1,704 @@
+/**
+ * \defgroup Math Math library
+ * @{
+ */
+
+class Math
+{
+	private void Math() {}
+	private void ~Math() {}
+	
+	static const float EULER = 2.7182818284590452353;
+	static const float PI = 3.14159265358979;
+	static const float PI2 = 6.28318530717958;
+	static const float PI_HALF = 1.570796326794;
+
+	static const float RAD2DEG = 57.2957795130823208768;
+	static const float DEG2RAD = 0.01745329251994329577;
+
+	//! returns the number of bits set in a bitmask i
+	proto static int GetNumberOfSetBits(int i);
+	
+	//! returns the the index of n-th bit set in a bit mask counting from the right, for instance, in a mask ..0110 1000 , the 0th set bit(right-most bit set to 1) is at 3th position(starting at 0), 1st bit is at 5th position, 2nd bit is at 6th position etc..
+	proto static int GetNthBitSet(int value, int n);
+	
+	/**
+	\brief Returns a random \p int number between and min [inclusive] and max [exclusive].
+		\param min \p int Range starts [inclusive]
+		\param max \p int Range ends [exclusive]
+		\return \p int - Random number in range
+		@code
+			Print( Math.RandomInt(0, 1) );	// only 0
+			Print( Math.RandomInt(0, 2) );	// 0 or 1
+
+			>> 0
+			>> 1
+		@endcode
+	*/
+	proto static int RandomInt(int min, int max);
+	
+	/**
+	\brief Returns a random \p int number between and min [inclusive] and max [inclusive].
+		\param min \p int Range starts [inclusive]
+		\param max \p int Range ends [inclusive]
+		\return \p int - Random number in range
+		@code
+			Print( Math.RandomIntInclusive(0, 1) );	// 0 or 1
+			Print( Math.RandomIntInclusive(0, 2) );	// 0, 1, 2
+
+			>> 1
+			>> 2
+		@endcode
+	*/
+	
+	static int RandomIntInclusive(int min, int max)
+	{
+		return Math.RandomInt(min, max+1);
+	}
+	
+	/**
+	\brief Returns a random \p bool .
+		\return \p bool - Random bool either 0 or 1
+		@code
+			Print( Math.RandomBool() );
+			Print( Math.RandomBool() );
+			Print( Math.RandomBool() );
+	
+			>> true
+			>> true
+			>> false
+		@endcode
+	*/
+	
+	static bool RandomBool()
+	{
+		return RandomIntInclusive(0,1);
+	}
+	
+	/**
+	\brief Returns a random \p float number between and min[inclusive] and max[exclusive].
+		\param min \p float Range starts [inclusive]
+		\param max \p float Range ends [exclusive]
+		\return \p float - Random number in range
+		@code
+			Print( Math.RandomFloat(0,1) );
+			Print( Math.RandomFloat(0,2) );
+
+			>> 0.597561
+			>> 1.936456
+		@endcode
+	*/
+	proto static float RandomFloat(float min, float max);
+
+	/**
+	\brief Returns a random \p float number between and min [inclusive] and max [inclusive].
+		\param min \p float Range starts [inclusive]
+		\param max \p float Range ends [inclusive]
+		\return \p float - Random number in range
+		@code
+			Print( Math.RandomFloatInclusive(0, 1) );	// 0.0 .. 1.0
+			Print( Math.RandomFloatInclusive(1, 2) );	// 1.0 .. 2.0
+
+			>> 0.3
+			>> 2.0
+		@endcode
+	*/
+	static float RandomFloatInclusive(float min, float max)
+	{
+		int max_range = Math.Pow(2, 30); //max range
+		int random_int = Math.RandomInt(0, max_range);
+		float rand_float = (float)random_int / (float)max_range;
+		float range = max - min;
+
+		return min + (rand_float * range); //rand float
+	}
+
+	/**
+	\brief Returns a random \p float number between and min [inclusive] and max [inclusive].
+		\return \p float - Random number in range 0.0 .. 1.0
+		@code
+			Print( Math.RandomFloat01() );	// 0.0 .. 1.0
+
+			>> 0.3
+			>> 1.0
+		@endcode
+	*/
+	static float RandomFloat01()
+	{
+		return RandomFloatInclusive(0, 1);
+	}
+	
+	/**
+	\brief Sets the seed for the random number generator.
+		\param seed \p int New seed for the random number generator, -1 will use time
+		\return \p int - Returns new seed
+		@code
+			Print( Math.Randomize(5) );
+
+			>> 5
+		@endcode
+	*/
+	proto static int Randomize(int seed);
+	
+	/**
+	\brief Normalizes the angle (0...360)
+		\param ang \p float Angle for normalizing
+		\return \p float - Normalized angle
+		@code
+			Print( Math.NormalizeAngle(390) );
+			Print( Math.NormalizeAngle(-90) );
+
+			>> 30
+			>> 270
+		@endcode
+	*/
+	proto static float NormalizeAngle(float ang);
+
+	/**
+	\brief Return relative difference between angles
+		\param angle1 \p float 
+		\param angle2 \p float
+		\return \p float Difference between angles (angle1 - angle2)
+		@code
+			Print( Math.DiffAngle(-45, 45) );
+			Print( Math.DiffAngle(90, 80) );
+
+			>> -90
+			>> 10
+		@endcode
+	*/
+	proto static float DiffAngle(float angle1, float angle2);
+	
+	/**
+	\brief Return power of v ^ power
+		\param v \p float Value
+		\param power \p float Power
+		\return \p float - The result of raising v to the given power
+		@code
+			Print( Math.Pow(2, 4) ); // (2*2*2*2)=16
+
+			>> 16
+		@endcode
+	*/
+	proto static float Pow(float v, float power);
+
+	/**
+	\brief Returns the floating-point remainder of x/y rounded towards zero
+		\param x \p float Value of the quotient numerator
+		\param y \p float Value of the quotient denominator
+		\return \p float - The remainder of dividing the arguments
+		@code
+			Print( Math.ModFloat(5.3, 2) );
+			Print( Math.ModFloat(18.5, 4.2) );
+
+			>> 1.3
+			>> 1.7
+		@endcode
+	*/
+	proto static float ModFloat(float x, float y);
+
+	/**
+	\brief Returns the floating-point remainder of x/y rounded to nearest
+		\param x \p float Value of the quotient numerator
+		\param y \p float Value of the quotient denominator
+		\return \p float - The remainder of dividing the arguments
+		@code
+			Print( Math.RemainderFloat(5.3, 2) );
+			Print( Math.RemainderFloat(18.5, 4.2) );
+
+			>> -0.7
+			>> 1.7
+		@endcode
+	*/
+	proto static float RemainderFloat(float x, float y);
+	
+	/**
+	\brief Returns absolute value
+		\param f \p float Value
+		\return \p float - Absolute value
+		@code
+			Print( Math.AbsFloat(-12.5) );
+
+			>> 12.5
+		@endcode
+	*/
+	proto static float AbsFloat(float f);
+
+	/**
+	\brief Returns absolute value
+		\param i \p int Value
+		\return \p int - Absolute value
+		@code
+			Print( Math.AbsInt(-12) );
+
+			>> 12
+		@endcode
+	*/
+	proto static int AbsInt(int i);
+
+	/**
+	\brief Returns sign of given value
+		\param f \p float Value
+		\return \p float - Sign of given value
+		@code
+			Print( Math.SignFloat(-12.0) );
+			Print( Math.SignFloat(0.0) );
+			Print( Math.SignFloat(12.0) );
+
+			>> -1.0
+			>> 0
+			>> 1.0
+		@endcode
+	*/
+	proto static float SignFloat(float f);
+
+	/**
+	\brief Returns sign of given value
+		\param i \p int Value
+		\return \p int - Sign of given value
+		@code
+			Print( Math.SignFloat(-12) );
+			Print( Math.SignFloat(0) );
+			Print( Math.SignFloat(12) );
+
+			>> -1
+			>> 0
+			>> 1
+		@endcode
+	*/
+	proto static int SignInt(int i);
+	
+	/**
+	\brief Returns squared value
+		\param f \p float Value
+		\return \p float - Squared value
+		@code
+			Print( Math.SqrFloat(12.5) );
+
+			>> 156.25
+		@endcode
+	*/
+	proto static float SqrFloat(float f);
+
+	/**
+	\brief Returns squared value
+		\param i \p int Value
+		\return \p int - Squared value
+		@code
+			Print( Math.SqrInt(12) );
+
+			>> 144
+		@endcode
+	*/
+	proto static int SqrInt(int i);
+	
+	/**
+	\brief Returns square root
+		\param val \p float Value
+		\return \p float - Square of value
+		@code
+			Print( Math.Sqrt(25));
+
+			>> 5
+		@endcode
+	*/
+	proto static float Sqrt(float val);
+	
+	/**
+	\brief Returns the binary (base-2) logarithm of x.
+		\param x \p float Value whose logarithm is calculated.
+		\return \p float The binary logarithm of x: log2x.
+				\n If x is negative, it causes a domain error:
+				\n If x is zero, it may cause a pole error (depending on the library implementation).
+		@code
+			Print( Math.Log2(1.0) ); 
+	
+			>> 0.0
+		@endcode
+	*/
+	proto static float Log2(float x);
+
+	/**
+	\brief Returns sinus of angle in radians
+		\param angle \p float Angle in radians
+		\return \p float - Sinus of angle
+		@code
+			Print( Math.Sin(0.785398) ); // (45)
+
+			>> 0.707107
+		@endcode
+	*/
+	proto static float Sin(float angle);
+
+	/**
+	\brief Returns cosinus of angle in radians
+		\param angle \p float Angle in radians
+		\return \p float - Cosinus of angle
+		@code
+			Print( Math.Cos(0.785398) ); // (45)
+
+			>> 0.707107
+		@endcode
+	*/
+	proto static float Cos(float angle);
+
+	/**
+	\brief Returns tangent of angle in radians
+		\param angle \p float Angle in radians
+		\return \p float - Tangens of angle
+		@code
+			Print( Math.Tan(0.785398) ); // (45)
+
+			>> 1
+		@endcode
+	*/
+	proto static float Tan(float angle);
+
+	/**
+	\brief Returns angle in radians from sinus
+		\param s \p float Sinus
+		\return \p float - Angle in radians
+		@code
+			Print( Math.Asin(0.707107) ); // (sinus 45)
+
+			>> 0.785398
+		@endcode
+	*/
+	proto static float Asin(float s);
+
+	/**
+	\brief Returns angle in radians from cosinus
+		\param c \p float Cosinus
+		\return \p float - Angle in radians
+		@code
+			Print( Math.Acos(0.707107) ); // (cosinus 45)
+
+			>> 0.785398
+		@endcode
+	*/
+	proto static float Acos(float c);
+	
+	/**
+	\brief Returns angle in radians from tangent
+		\param x \p float Tangent
+		\return \p float - Angle in radians
+	*/
+	proto static float Atan(float x);
+
+	/**
+	\brief Returns angle in radians from tangent
+		\param y \p float Tangent
+		\param x \p float Tangent
+		\return \p float - Angle in radians
+		@code
+			Print ( Math.Atan2(1, 1) );
+
+			>> 0.785398
+		@endcode
+	*/
+	proto static float Atan2(float y, float x);
+
+	/**
+	\brief Returns mathematical round of value
+		\param f \p float Value
+		\return \p float - closest whole number to 'f'
+		@code
+			Print( Math.Round(5.3) );
+			Print( Math.Round(5.8) );
+
+			>> 5
+			>> 6
+		@endcode
+	*/
+	proto static float Round(float f);
+		
+	/**
+	\brief Returns floor of value
+		\param f \p float Value
+		\return \p float - Floor of value
+		@code
+			Print( Math.Floor(5.3) );
+			Print( Math.Floor(5.8) );
+
+			>> 5
+			>> 5
+		@endcode
+	*/
+	proto static float Floor(float f);
+
+	/**
+	\brief Returns ceil of value
+		\param f \p float Value
+		\return \p float - Ceil of value
+		@code
+			Print( Math.Ceil(5.3) );
+			Print( Math.Ceil(5.8) );
+
+			>> 6
+			>> 6
+		@endcode
+	*/
+	proto static float Ceil(float f);
+	
+	/**
+	\brief Returns wrap number to specified interval [min, max[
+		\param f \p float Value
+		\param min \p float Minimum
+		\param max \p float Maximum
+		\return \p float - number in specified interval [min, max[
+		@code
+			Print( Math.WrapFloat(9.0, 1.0, 9.0) );
+
+			>> 1.0
+		@endcode
+	*/
+	proto static float WrapFloat(float f, float min, float max);
+	
+	/**
+	\brief Returns wrap number to specified interval [min, max]
+		\param f \p float Value
+		\param min \p float Minimum
+		\param max \p float Maximum
+		\return \p float - number in specified interval [min, max]
+		@code
+			Print( Math.WrapFloatInclusive(9.0, 1.0, 9.0) );
+
+			>> 9.0
+		@endcode
+	*/
+	proto static float WrapFloatInclusive(float f, float min, float max);
+	
+	/**
+	\brief Returns wrap number to specified interval [0, max[
+		\param f \p float Value
+		\param max \p float Maximum
+		\return \p float - number in specified interval [0, max[
+		@code
+			Print( Math.WrapFloat0X(9.0, 9.0) );
+
+			>> 0.0
+		@endcode
+	*/
+	proto static float WrapFloat0X(float f, float max);
+	
+	/**
+	\brief Returns wrap number to specified interval [0, max]
+		\param f \p float Value
+		\param max \p float Maximum
+		\return \p float - number in specified interval [0, max]
+		@code
+			Print( Math.WrapFloat0X(9.0, 9.0) );
+
+			>> 9.0
+		@endcode
+	*/
+	proto static float WrapFloat0XInclusive(float f, float max);
+	
+	/**
+	\brief Returns wrap number to specified interval [min, max[
+		\param i \p int Value
+		\param min \p float Minimum
+		\param max \p int Maximum
+		\return \p int - number in specified interval [min, max[
+		@code
+			Print( Math.WrapInt(9, 1, 9) );
+
+			>> 1
+		@endcode
+	*/
+	proto static int WrapInt(int i, int min, int max);
+	
+	/**
+	\brief Returns wrap number to specified interval [0, max[
+		\param i \p int Value
+		\param max \p int Maximum
+		\return \p int - number in specified interval [0, max[
+		@code
+			Print( Math.WrapInt0X(9, 9) );
+
+			>> 0
+		@endcode
+	*/
+	proto static int WrapInt0X(int i, int max);
+
+	/**
+	\brief Clamps 'value' to 'min' if it is lower than 'min', or to 'max' if it is higher than 'max'
+		\param value \p float Value
+		\param min \p float Minimum value
+		\param max \p float Maximum value
+		\return \p float - Clamped value
+		@code
+			Print( Math.Clamp(-0.1, 0, 1) );
+			Print( Math.Clamp(2, 0, 1) );
+			Print( Math.Clamp(0.5, 0, 1) );
+	
+			>> 0
+			>> 1
+			>> 0.5
+		@endcode
+	*/
+	proto static float Clamp(float value, float min, float max);
+		
+	/**
+	\brief Returns smaller of two given values
+		\param x \p float Value
+		\param y \p float Value
+		\return \p float  - min value
+		@code
+			Print( Math.Min(5.3, 2.8) );
+
+			>> 2.8
+		@endcode
+	*/
+	proto static float Min(float x, float y);
+	
+	/**
+	\brief Returns bigger of two given values
+		\param x \p float Value
+		\param y \p float Value
+		\return \p float  - max value
+		@code
+			Print( Math.Max(5.3, 2.8) );
+
+			>> 5.3
+		@endcode
+	*/
+	proto static float Max(float x, float y);	
+	
+	/**
+	\brief Returns if value is between min and max (inclusive)
+		\param v \p float Value
+		\param min \p float Minimum value
+		\param max \p float Maximum value
+		\return \p bool  - if value is within range [min,max]
+		@code
+			Print( Math.IsInRange(6.9, 3.6, 9.3) );
+
+			>> true
+		@endcode
+	*/
+	proto static bool IsInRange(float v, float min, float max);
+	
+	/**
+	\brief Returns if value is between min and max (inclusive)
+		\param v \p int Value
+		\param min \p int Minimum value
+		\param max \p int Maximum value
+		\return \p bool  - if value is within range [min,max]
+		@code
+			Print( Math.IsInRangeInt(6, 3, 9) );
+
+			>> true
+		@endcode
+	*/
+	proto static bool IsInRangeInt(int v, int min, int max);
+	
+	/**
+	\brief Linearly interpolates between 'a' and 'b' given 'time'.
+		\param a \p float Start
+		\param b \p float End
+		\param time \p float Time [value needs to be between 0..1 for correct results, no auto clamp applied]
+		\return \p float - The interpolated result between the two float values. 
+		@code
+			Print( Math.Lerp(3, 7, 0.5) );
+	
+			>> 5
+		@endcode
+	*/ 
+	proto static float Lerp(float a, float b, float time);
+
+	/**
+	\brief Calculates the linear value that produces the interpolant value within the range [a, b], it's an inverse of Lerp.
+		\param a \p float Start
+		\param b \p float End
+		\param value \p float value
+		\return \p float - the time given the position between 'a' and 'b' given 'value', there is no clamp on 'value', to stay between [0..1] use 'value' between 'a' and 'b'
+		@code
+			Print( Math.InverseLerp(3, 7, 5) );
+	
+			>> 0.5
+		@endcode
+	*/
+	proto static float InverseLerp(float a, float b, float value);
+	
+	/**
+	\brief Returns area of a right triangle
+		\param s \p float Length of adjacent leg
+		\param a \p float Angle of corner bordering adjacent which is not the right corner (in radians)
+		\return \p float - Area
+	*/
+	proto static float AreaOfRightTriangle(float s, float a);
+	
+	/**
+	\brief Returns hypotenus of a right triangle
+		\param s \p float Length of adjacent leg
+		\param a \p float Angle of corner bordering adjacent which is not the right corner (in radians)
+		\return \p float - hypotenus
+	*/
+	proto static float HypotenuseOfRightTriangle(float s, float a);
+	
+	/**
+	\brief Returns if point is inside circle
+		\param c \p vector Center of circle ([0] and [2] will be used, as a circle is 2D)
+		\param r \p float Radius of circle
+		\param p \p vector Point ([0] and [2] will be used, as a circle is 2D)
+		\return \p bool - True when point is in circle
+	*/
+	proto static bool IsPointInCircle(vector c, float r, vector p);
+	
+	/**
+	\brief Returns if point is inside rectangle
+		\param mi \p vector Minimums of rectangle ([0] and [2] will be used, as a rectangle is 2D)
+		\param ma \p vector Maximums of rectangle ([0] and [2] will be used, as a rectangle is 2D)
+		\param p \p vector Point ([0] and [2] will be used, as a rectangle is 2D)
+		\return \p bool - True when point is in rectangle
+	*/
+	proto static bool IsPointInRectangle(vector mi, vector ma, vector p);
+	
+	//--------------------------------------------------------------------------
+	//-------------------------------- filters ---------------------------------
+	//--------------------------------------------------------------------------
+
+	/**
+	\brief Does the CD smoothing function - easy in | easy out / S shaped smoothing 
+		\param val \p actual value 
+		\param target \p value we are reaching for -> Target
+		\param velocity \p float[1] - array of ONE member - some kind of memory and actual accel/decel rate, need to be zeroed when filter is about to be reset
+		\param smoothTime \p smoothing parameter, 0.1 .. 0.4 are resonable values, 0.1 is sharp, 0.4 is very smooth
+		\param maxVelocity \p maximal value change when multiplied by dt
+		\param dt \p delta time 
+
+		\return \p float smoothed/filtered value 
+
+		@code
+			val = EnfMath.SmoothCD(val, varTarget, valVelocity, 0.3, 1000, dt);
+		@endcode
+	*/
+
+	proto static float SmoothCD(float val, float target, inout float velocity[], float smoothTime, float maxVelocity, float dt);
+	
+	//! occurences values above '12' will cause Factorial to overflow int.
+	static float Poisson(float mean, int occurences)
+	{
+		return Pow(mean, occurences) * Pow(EULER,-mean) / Factorial(occurences);
+	}
+	
+	//! values above '12' will cause int overflow
+	static int Factorial(int val)
+	{
+		if (val > 12)
+		{
+			ErrorEx("Values above '12' cause int overflow! Returning '1'");
+			return 1;
+		}
+		
+		int res = 1;
+		while (val > 1)
+		{
+			res *= val--;
+		}
+		return res;
+	}
+};
+
+//@}

scripts/1_Core/DayZ/proto/EnMath3D.c

@@ -0,0 +1,474 @@
+/**
+ * \defgroup Math3DAPI Math3D library
+ * @{
+ */
+
+/**
+\brief Vector constructor from components
+    \param x \p float x component
+	\param y \p float y component
+	\param z \p float z component
+	\return \p vector resulting vector
+	@code
+		Print( Vector(1, 2, 3) );
+
+		>> <1,2,3>
+	@endcode
+*/
+proto native vector Vector(float x, float y, float z);
+
+enum ECurveType
+{
+	CatmullRom,
+	NaturalCubic,
+	UniformCubic
+};
+
+class Math3D
+{
+	private void Math3D() {}
+	private void ~Math3D() {}
+	
+	//-----------------------------------------------------------------
+	proto static vector ClipLine(vector start, vector end, vector norm, float d);
+
+	/**
+	\brief Tests whether ray is intersecting sphere.
+		\param raybase \p vector Start of ray
+		\param raycos \p vector End of ray
+		\param center \p vector Center of sphere
+		\param radius \p float Radius of sphere
+		\return \p float -1 when not intersecting, else the fraction of ray
+	*/
+	proto static float IntersectRaySphere(vector raybase, vector raycos, vector center, float radius);
+	
+	/**
+	\brief Tests whether ray is intersecting axis aligned box.
+		\param start \p vector Start of ray
+		\param end \p vector End of ray
+		\param mins \p vector Minimums of bound box
+		\param maxs \p vector Maximums of bound box
+		\return \p float -1 when not intersecting, else the fraction of ray
+	*/
+	proto static float IntersectRayBox(vector start, vector end, vector mins, vector maxs);
+	
+	/**
+	\brief Tests whether sphere is intersecting axis aligned box.
+		\param origin \p vector Origin of sphere
+		\param radius \p float Radius of sphere
+		\param mins \p vector Minimums of bound box
+		\param maxs \p vector Maximums of bound box
+		\return \p bool True when intersects
+	*/
+	proto static bool IntersectSphereBox(vector origin, float radius, vector mins, vector maxs);
+	
+	/**
+	\brief Tests whether sphere is intersecting cone.
+		\param origin \p vector Origin of sphere
+		\param radius \p float Radius of sphere
+		\param conepos \p vector Position of top of cone
+		\param axis \p vector Orientation of cone in direction from top to bottom
+		\param angle \p float Angle of cone in radians
+		\return \p bool True when sphere is intersecting cone
+	*/
+	proto static bool IntersectSphereCone(vector origin, float radius, vector conepos, vector axis, float angle);
+	
+	/**
+	\brief Tests whether sphere is fully inside cone.
+		\param origin \p vector Origin of sphere
+		\param radius \p float Radius of sphere
+		\param conepos \p vector Position of top of cone
+		\param axis \p vector Orientation of cone in direction from top to bottom
+		\param angle \p float Angle of cone in radians
+		\return \p bool True when sphere is fully inside cone
+	*/
+	proto static bool IntersectWholeSphereCone(vector origin, float radius, vector conepos, vector axis, float angle);
+	
+	/**
+	\brief Tests whether cylinder is intersecting oriented box.
+		\param mins \p vector Minimums of bound box
+		\param maxs \p vector Maximums of bound box
+		\param obbMat \p vector Transform of box
+		\param cylMat \p vector Transform of cylinder
+		\param cylinderRadius \p float Radius of cylinder
+		\param cylinderHeight \p float Height of cylinder
+		\return \p bool True when cylinder is intersecting oriented box
+	*/
+	proto static bool IntersectCylinderOBB(vector mins, vector maxs, vector obbMat[4], vector cylMat[4], float cylinderRadius, float cylinderHeight);
+	
+	/**
+	\brief Tests whether ray is intersecting cylinder.
+		\param rayStart \p vector Start of ray
+		\param rayEnd \p vector End of ray
+		\param center \p vector Center of cylinder
+		\param radius \p float Radius of cylinder
+		\param height \p float Height of cylinder
+		\return \p bool True when ray is intersecting cylinder
+	*/
+	proto static bool IntersectRayCylinder(vector rayStart, vector rayEnd, vector center, float radius, float height);
+	
+	/**
+	\brief Creates rotation matrix from angles
+		\param ang \p vector which contains angles
+		\param[out] mat \p vector created rotation matrix
+		@code
+			vector mat[3];
+			YawPitchRollMatrix( "70 15 45", mat );
+			Print( mat );
+
+			>> <0.330366,0.0885213,-0.939693>,<0.458809,0.854988,0.241845>,<0.824835,-0.511037,0.241845>
+		@endcode
+	*/
+	proto static void YawPitchRollMatrix(vector ang, out vector mat[3]);
+
+	/**
+	\brief Creates rotation matrix from direction and up vector
+		\param dir \p vector direction vector
+		\param up \p vector up vector
+		\param[out] mat \p vector[4] created rotation matrix
+		@code
+			vector mat[4];
+			vector dir = "1 0 1";
+			vector up = "0 1 0";
+			DirectionAndUpMatrix( dir, up, mat );
+			Print( mat );
+
+			>> <0.707107,0,-0.707107>,<0,1,0>,<0.707107,0,0.707107>,<0,0,0>
+		@endcode
+	*/
+	proto static void DirectionAndUpMatrix(vector dir, vector up, out vector mat[4]);
+
+	/**
+	\brief Transforms matrix
+		\param mat0 \p vector[4] first matrix
+		\param mat1 \p vector[4] second matrix
+		\param[out] res \p vector[4] result of first and second matrix multiplication
+		@code
+			vector mat0[4] = { "2 0 0 0", "0 3 0 0", "0 1 0 0", "0 0 0 1" }; // scale matrix
+			vector mat1[4] = { "1 0 0 0", "0 1 0 0", "0 1 0 0", "2 4 1 3" }; // translation matrix
+			vector res[4];
+			Math3D.MatrixMultiply4(mat0, mat1, res)
+			Print( res );
+
+			>> <2,0,0>,<0,3,0>,<0,3,0>,<4,13,0>
+		@endcode
+	*/
+	proto static void MatrixMultiply4(vector mat0[4], vector mat1[4], out vector res[4]);
+
+	/**
+	\brief Transforms rotation matrix
+		\param mat0 \p vector[3] first matrix
+		\param mat1 \p vector[3] second matrix
+		\param[out] res \p vector[3] result of first and second matrix multiplication
+		@code
+			vector mat0[3] = { "1.5 2.5 0", "0.1 1.3 0", "0 0 1" }; // rotation matrix
+			vector mat1[3] = { "1 0.4 0", "0 1 0", "0 1.3 2.7" }; // rotation matrix
+			vector res[3];
+			Math3D.MatrixMultiply3(mat0, mat1, res)
+			Print( res );
+
+			>> <1.54,3.02,0>,<0.1,1.3,0>,<0.13,1.69,2.7>
+		@endcode
+	*/
+	proto static void MatrixMultiply3(vector mat0[3], vector mat1[3], out vector res[3]);
+
+	/**
+	\brief Invert-transforms matrix
+		\param mat0 \p vector[4] first matrix
+		\param mat1 \p vector[4] second matrix
+		\param[out] res \p vector[4] inverse result of first and second matrix multiplication
+		@code
+			vector mat0[4] = { "2 0 0", "0 3 0", "0 0 1", "0 0 0" }; // scale matrix
+			vector mat1[4] = { "1 0 0", "0 1 0", "0 0 1", "2 4 1" }; // translation matrix
+			vector res[4];
+			Math3D.MatrixInvMultiply4(mat0, mat1, res)
+			Print( res );
+
+			>> <2,0,0>,<0,3,1>,<0,3,1>,<4,12,4>
+		@endcode
+	*/
+	proto static void MatrixInvMultiply4(vector mat0[4], vector mat1[4], out vector res[4]);
+
+	/**
+	\brief Invert-transforms rotation matrix
+		\param mat0 \p vector[3] first matrix
+		\param mat1 \p vector[3] second matrix
+		\param[out] res \p vector[3] result of first and second matrix multiplication
+		@code
+			vector mat0[3] = { "1.5 2.5 0", "0.1 1.3 0", "0 0 1" }; // rotation matrix
+			vector mat1[3] = { "1 0.4 0", "0 1 0", "0 1.3 2.7" }; // rotation matrix
+			vector res[3];
+			Math3D.MatrixInvMultiply3(mat0, mat1, res)
+			Print( res );
+
+			>> <2.5,0.62,0>,<2.5,1.3,0>,<3.25,1.69,2.7>
+		@endcode
+	*/
+	proto static void MatrixInvMultiply3(vector mat0[3], vector mat1[3], out vector res[3]);
+
+	/**
+	\brief Orthogonalizes matrix
+	    \param[it] mat \p matrix which should be orthogonalized
+	*/
+	proto static void MatrixOrthogonalize4(vector mat[4]);
+	
+	/**
+	\brief Orthogonalizes matrix
+	    \param[it] mat \p matrix which should be orthogonalized
+	*/
+	proto static void MatrixOrthogonalize3(vector mat[3]);
+	
+	/**
+	\brief Creates identity matrix
+	    \param[out] mat \p created identity matrix
+		@code
+	        vector mat[4];
+	    	Math3D.MatrixIdentity4( mat );
+	    	Print( mat );
+
+			>> <1,0,0>,<0,1,0>,<0,0,1>,<0,0,0>
+		@endcode
+	*/
+	
+	static void MatrixIdentity4(out vector mat[4])
+	{
+		mat[0] = "1 0 0";
+		mat[1] = "0 1 0";
+		mat[2] = "0 0 1";
+		mat[3] = vector.Zero;
+	}
+	
+	/**
+	\brief Creates identity matrix
+	    \param[out] mat \p created identity matrix
+		@code
+	        vector mat[3];
+	    	Math3D.MatrixIdentity3( mat );
+	    	Print( mat );
+
+			>> <1,0,0>,<0,1,0>,<0,0,1>
+		@endcode
+	*/
+	static void MatrixIdentity3(out vector mat[3])
+	{
+		mat[0] = "1 0 0";
+		mat[1] = "0 1 0";
+		mat[2] = "0 0 1";
+	}
+
+	/**
+	\brief Creates scale matrix
+	    \param scale \p scale coeficient
+	    \param[out] mat \p created scale matrix
+		@code
+	        vector mat[3];
+	    	Math3D.ScaleMatrix( 2.5, mat );
+	    	Print( mat );
+
+			>> <2.5,0,0>,<0,2.5,0>,<0,0,2.5>
+		@endcode
+	*/
+	static void ScaleMatrix(float scale, out vector mat[3])
+	{
+		vector v0, v1, v2;
+		v0[0] = scale;
+		v1[1] = scale;
+		v2[2] = scale;
+		mat[0] = v0;
+		mat[1] = v1;
+		mat[2] = v2;
+	}
+
+	/**
+	\brief Creates identity quaternion
+		\param[out] q \p float[4] created identity quaternion
+		@code
+			float q[4];
+			Math3D.QuatIdentity( q );
+			Print( q );
+
+			>> {0,0,0,1}
+		@endcode
+	*/
+	static void QuatIdentity(out float q[4])
+	{
+		q[0] = 0;
+		q[1] = 0;
+		q[2] = 0;
+		q[3] = 1;
+	}
+
+	/**
+	\brief Copies quaternion
+	    \param s \p float[4] quaternion to copy
+		\param[out] d \p float[4] created quaternion copy
+		@code
+			float s[4] = { 2, 3, 4, 1 };
+			float d[4];
+			Math3D.QuatCopy( s, d );
+			Print( d );
+
+			>> {2,3,4,1}
+		@endcode
+	*/
+	static void QuatCopy(float s[4], out float d[4])
+	{
+		d[0] = s[0];
+		d[1] = s[1];
+		d[2] = s[2];
+		d[3] = s[3];
+	}
+
+	/**
+	\brief Converts rotation matrix to quaternion
+	    \param mat \p vector[3] rotation matrix
+		\param[out] d \p float[4] created quaternion copy
+		@code
+			vector mat[3];
+			vector rot = "70 15 45";
+			rot.RotationMatrixFromAngles( mat );
+			float d[4];
+			Math3D.MatrixToQuat( mat, d );
+			Print( d );
+
+			>> {0.241626,0.566299,-0.118838,0.778973}
+		@endcode
+	*/
+	proto static void MatrixToQuat(vector mat[3], out float d[4]);
+
+	
+	//! Converts quaternion to rotation matrix
+	proto static void QuatToMatrix(float q[4], out vector mat[3]);
+
+	/**
+	\brief Returns angles of rotation matrix
+		\param mat \p vector[3] rotation matrix
+		\return \p vector roll, pitch, yaw angles
+		@code
+			vector mat[3];
+			Math3D.RollPitchYawMatrix( "70 15 45", mat );
+			vector ang = Math3D.MatrixToAngles( mat );
+			Print( ang );
+
+			>> <70,15,-45>
+		@endcode
+	*/
+	proto static vector MatrixToAngles(vector mat[3]);
+	
+	/**
+	\brief Linear interpolation between q1 and q2 with weight 'frac' (0...1)
+	    \param[out] qout \p float[4] result quaternion
+		\param q1 \p float[4] first quaternion
+		\param q2 \p float[4] second quaternion
+		\param frac \p float interpolation weight
+		@code
+			float q1[4] = { 1, 1, 1, 1 };
+			float q2[4] = { 2, 2, 2, 1 };
+			float qout[4];
+			Math3D.QuatLerp( qout, q1, q2, 0.5 );
+			Print( qout );
+
+			>> {1.5,1.5,1.5,1}
+		@endcode
+	*/
+	proto static void QuatLerp(out float qout[4], float q1[4], float q2[4], float frac);
+
+	/**
+	\brief Multiplies quaternions
+	    \param[out] qout \p float[4] result quaternion
+		\param q1 \p float[4] first quaternion
+		\param q2 \p float[4] second quaternion
+		@code
+			float q1[4] = { 1, 2, 3, 1 };
+			float q2[4] = { 2, 2, 2, 1 };
+			float qout[4];
+			Math3D.QuatMultiply( qout, q1, q2 );
+			Print( qout );
+
+			>> {2,4,6,1}
+		@endcode
+	*/
+	proto static void QuatMultiply(out float qout[4], float q1[4], float q2[4]);
+
+	//! Returns Angles vector from quaternion
+	proto static vector QuatToAngles(float q[4]);
+	
+	/**
+	\brief Returns 1, when bounding boxes intersects
+	    \param mins1 \p vector minimum point of first bounding box
+		\param maxs1 \p vector maximum point of first bounding box
+		\param mins2 \p vector minimum point of second bounding box
+		\param maxs2 \p vector maximum point of second bounding box
+		\return \p int 1 if boundig boxes intersects, otherwise 0
+		@code
+			vector mins1 = "1 1 1";
+			vector maxs1 = "3 3 3";
+			vector mins2 = "2 2 2";
+			vector maxs2 = "4 4 4";
+			Print( Math3D.CheckBoundBox(mins1, maxs1, mins2, maxs2) );
+
+			>> 1
+		@endcode
+	*/
+	proto static int CheckBoundBox(vector mins1, vector maxs1, vector mins2, vector maxs2);
+	
+	/**
+	\brief Returns randon normalized direction
+	    \return \p vector 
+		@code
+			Print( Math3D.GetRandomDir() );
+
+			>>vector ret =  0x0000000007c1a1c0 {<0.422565,0,-0.906333>}
+		@endcode
+	*/
+	static vector GetRandomDir()
+	{
+		float x = Math.RandomFloatInclusive(-1, 1);
+		float y = Math.RandomFloatInclusive(-1, 1);
+		float z = Math.RandomFloatInclusive(-1, 1);
+			
+		return Vector(x, y, z).Normalized();
+	}
+	
+	
+	/**
+	\brief Computes curve
+		\return \p vector 
+		@code
+			auto points = new array<vector>();
+			points.Insert( Vector( 0, 0, 0) );
+	    	points.Insert( Vector( 5, 0, 0) );
+	    	points.Insert( Vector( 8, 3, 0) );
+	    	points.Insert( Vector( 6, 1, 0) );
+		
+			float t = 0.5;
+			vector result = Math3D.Curve(ECurveType.CatmullRom, t, points);
+		@endcode
+	*/
+	proto static native vector Curve(ECurveType type, float param, notnull array<vector> points);
+	
+	
+	/**
+	\brief Point on line beg .. end nearest to pos
+		\return \p vector
+	*/
+	proto static vector NearestPoint(vector beg, vector end, vector pos);
+	
+	/**
+	\brief Angle that a target is from the direction of an origin
+		\return \p float Angle in radians
+	*/
+	proto static float AngleFromPosition(vector origin, vector originDir, vector target);
+	
+	/**
+	\brief Calculates the points of a right 2D cone in 3D space
+		\param origin \p vector Origin of cone
+		\param length \p float Length of the cone
+		\param halfAngle \p float Half of the angle of the cone in radians
+		\param angleOffset \p float Angle offset of the cone in radians (handy for rotating it along with something in the world)
+		\param[out] leftPoint \p vector Left point of the cone
+		\param[out] rightPoint \p vector Right point of the cone
+	*/
+	proto static void ConePoints(vector origin, float length, float halfAngle, float angleOffset, out vector leftPoint, out vector rightPoint);
+};
+//@}

scripts/1_Core/DayZ/proto/EnPhysics.c

@@ -0,0 +1,327 @@
+/**
+ * \defgroup Physics Physics system
+ * @{
+ */
+
+typedef int[] dGeom;
+typedef int[] dJoint;
+typedef int[] dBlock;
+
+proto native int dGetNumDynamicBodies(notnull IEntity worldEnt);
+proto native IEntity dGetDynamicBody(notnull IEntity worldEnt, int index);
+proto native void dSetInteractionLayer(notnull IEntity worldEntity, int mask1, int mask2, bool enable);
+proto native bool dGetInteractionLayer(notnull IEntity worldEntity, int mask1, int mask2);
+
+//!Gets global gravity
+proto native vector dGetGravity(notnull IEntity worldEntity);
+//!Changes global gravity
+proto native void dSetGravity(notnull IEntity worldEntity, vector g);
+//!Changes fixed time-slice. Default is 1/40, thus simulation runs on 40fps. With smaller values, there is more precise simulation
+proto native void dSetTimeSlice(notnull IEntity worldEntity, float timeSlice);
+
+/**
+ * \defgroup RigidBody RigidBody API
+ * @{
+ */
+
+//proto native int dMaterialClone(string target, string source, int material_index)
+//proto native int dMaterialGetType(string source)
+//proto native int dMaterialSetType(string source, int material_index)
+
+class PhysicsGeomDef: Managed
+{
+	string	Name;
+	dGeom		Geometry;
+	vector	Frame[4] = {Vector(1, 0, 0), Vector(0, 1, 0), Vector(0, 0, 1), Vector(0, 0, 0)};
+	int			ParentNode = -1;
+	string	MaterialName;
+	int			LayerMask; //<Bit mask of layers we are in
+
+	
+	void PhysicsGeomDef(string name, dGeom geom, string materialName, int layerMask)
+	{
+		Name = name;
+		Geometry = geom;
+		MaterialName = materialName;
+		LayerMask = layerMask;	
+	}	
+};
+
+/*!
+Creates RigidBody from custom made geometries. The geometries are deleted when rigid body is destroyed
+\param geoms array of custom made geometries
+@code
+	autoptr PhysicsGeomDef geoms[] = {PhysicsGeomDef("", dGeomCreateBox(size), "material/default", 0xffffffff)};
+	dBodyCreateStaticEx(this, geoms);
+@endcode
+*/
+proto bool dBodyCreateStaticEx(notnull IEntity ent, PhysicsGeomDef geoms[]);
+proto bool dBodyCreateGhostEx(notnull IEntity ent, PhysicsGeomDef geoms[]);
+
+/*!
+Creates RigidBody from custom made geometries. The geometries are deleted when rigid body is destroyed
+\param centerOfMass Offset from object-pivot to center of mass
+\param mass Body mass
+\param geoms array of custom made geometries
+@code
+	autoptr PhysicsGeomDef geoms[] = {PhysicsGeomDef("", dGeomCreateBox(size), "material/default", 0xffffffff)};
+	dBodyCreateDynamicEx(this, center, 1.0, geoms);
+@endcode
+*/
+proto bool dBodyCreateDynamicEx(notnull IEntity ent, vector centerOfMass, float mass, PhysicsGeomDef geoms[]);
+
+//!Destroys attached physics body
+proto native void dBodyDestroy(notnull IEntity ent);
+
+//!Has the entity attached physics body?
+proto native bool dBodyIsSet(notnull IEntity ent);
+
+proto native void dBodySetInteractionLayer(notnull IEntity ent, int mask);
+proto native int dBodyGetInteractionLayer(notnull IEntity ent);
+proto native void dBodySetGeomInteractionLayer(notnull IEntity ent, int index, int mask);
+proto native int dBodyGetGeomInteractionLayer(notnull IEntity ent, int index);
+
+//! state of a rigidbody
+enum ActiveState
+{
+	ACTIVE,
+	INACTIVE,
+	ALWAYS_ACTIVE
+};
+	
+proto native void dBodyActive(notnull IEntity ent, ActiveState activeState);
+proto native void dBodyDynamic(notnull IEntity ent, bool dynamic);
+proto native bool dBodyIsDynamic(notnull IEntity ent);
+
+proto native bool dBodyIsActive(notnull IEntity ent);
+proto native bool dBodyEnableGravity(notnull IEntity ent, bool enable);
+proto native void dBodySetDamping(notnull IEntity ent, float linearDamping, float angularDamping);
+proto native void dBodySetSleepingTreshold(notnull IEntity body, float linearTreshold, float angularTreshold);
+
+proto native bool dBodyIsSolid(notnull IEntity ent);
+proto native void dBodySetSolid(notnull IEntity ent, bool solid);
+
+/*!
+If both maxMotion and shapeCastRadius is >=0 then the continuous collision detection is enabled.
+If you want to disable it, use -1
+\param maxMotion max motion threshold when sphere-cast is performed, to find time of impact. It should be
+little bit less than size of the geometry to catch the situation when tunelling can happen
+\param sphereCastRadius The radius of the largest possible sphere, that is completelly inside the body geometry.
+*/
+proto native void dBodyEnableCCD(notnull IEntity body, float maxMotion, float sphereCastRadius);
+/*!
+Sets scale factor for all impulses/velocities/forces. Default is <1,1,1>. Zero any axis if you want to do 2D physics
+*/
+proto native void dBodySetLinearFactor(notnull IEntity body, vector linearFactor);
+
+//!returns center of mass offset
+proto native vector dBodyGetCenterOfMass(notnull IEntity body);
+
+/**
+\brief Returns linear velocity
+	\param ent \p IEntity entity which origin will be set
+	\param mat \p vector[4] matrix to be set
+	\return \p vector linear velocity
+	@code
+		Man player = g_Game.GetPlayer();
+		Print( GetVelocity(player) );
+
+		>> <0,0,0>
+	@endcode
+*/
+proto native vector GetVelocity(notnull IEntity ent);
+
+/**
+\brief Sets linear velocity (for Rigid bodies)
+	\param ent \p entity which velocity will be set
+	\param vel \p velocity vector to be set
+*/
+proto native void SetVelocity(notnull IEntity ent, vector vel);
+
+/**
+\brief Disables collisions between two entities
+*/
+proto native dBlock dBodyCollisionBlock(notnull IEntity ent1, notnull IEntity ent2);
+proto native void dBodyRemoveBlock(notnull IEntity worldEntity, dBlock block);
+
+proto native void dBodySetInertiaTensorV(notnull IEntity body, vector v);
+proto native void dBodySetInertiaTensorM(notnull IEntity body, vector m[3]);
+
+proto native float dBodyGetMass(notnull IEntity ent);
+proto native void dBodySetMass(notnull IEntity body, float mass);
+
+proto native void dBodyApplyTorqueImpulse(notnull IEntity ent, vector torqueImpulse);
+proto native vector dBodyGetInvInertiaDiagLocal(notnull IEntity ent);
+proto native float dBodyComputeImpulseDenominator(notnull IEntity ent, vector position, vector normal);
+proto native float dBodyComputeAngularImpulseDenominator(notnull IEntity ent, vector axis);
+proto native vector dBodyGetLocalInertia(notnull IEntity ent);
+
+proto void dBodyGetInvInertiaTensorWorld(notnull IEntity body, out vector inertiaTensorWS[3]);
+
+/**
+\brief Applies impuls on a pos position in world coordinates
+*/
+proto void dBodyApplyImpulseAt(notnull IEntity body, vector impulse, vector pos);
+
+/**
+\brief Applies impuls on a rigidbody (origin)
+*/
+proto void dBodyApplyImpulse(notnull IEntity body, vector impulse);
+
+/**
+\brief Applies constant force on a rigidbody (origin)
+*/
+proto void dBodyApplyForce(notnull IEntity body, vector force);
+
+/**
+\brief Applies constant force on a position
+*/
+proto void dBodyApplyForceAt(notnull IEntity body, vector pos, vector force);
+
+proto native void dBodyApplyTorque(notnull IEntity body, vector torque);
+
+/**
+\brief Gets angular velocity for a rigidbody
+*/
+proto vector dBodyGetAngularVelocity(notnull IEntity body);
+
+/**
+\brief Changed an angular velocity
+	\param body \p Rigid body
+	\param angvel \p Angular velocity, rotation around x, y and z axis (not yaw/pitch/roll)
+*/
+proto void dBodySetAngularVelocity(notnull IEntity body, vector angvel);
+
+/**
+\brief Sets target transformation. If timeslice == dt (simulation step delta time), it will happen in next step, otherwise in time = timeslice
+*/
+proto native void dBodySetTargetMatrix(notnull IEntity body, vector matrix[4], float timeslice);
+proto native float dBodyGetKineticEnergy(notnull IEntity body);
+
+proto native vector dBodyGetVelocityAt(notnull IEntity body, vector globalpos);
+//@}
+
+/**
+ * \defgroup Geometry Geometry API definition
+ * @{
+ */
+
+//! Creates box geometry
+proto native dGeom dGeomCreateBox(vector size);
+
+//! Creates sphere geometry
+proto native dGeom dGeomCreateSphere(float radius);
+
+//! Creates capsule geometry
+proto native dGeom dGeomCreateCapsule(float radius, vector extent);
+
+//! Creates cylinder geometry
+proto native dGeom dGeomCreateCylinder(float radius, vector extent);
+
+//! Destroys geometry
+proto native void dGeomDestroy(dGeom geom);
+
+//proto native int dBodyAddGeom(notnull IEntity body, dGeom geom, vector frame[4], string material, int interactionLayer);
+// find a geometry by its name and returns its index or -1 if the geometry wasn't found
+proto native int dBodyGetGeom(notnull IEntity ent, string name);
+// returns number of geometries of the entity
+proto native int dBodyGetNumGeoms(notnull IEntity ent);
+//@}
+
+/**
+ * \defgroup Constraints Constraints API definition
+ * @{
+ */
+
+proto native dJoint dJointCreateHinge(notnull IEntity ent1, notnull IEntity ent2, vector point1, vector axis1, vector point2, vector axis2, bool block, float breakThreshold);
+proto native dJoint dJointCreateHinge2(notnull IEntity ent1, notnull IEntity ent2, vector matrix1[4], vector matrix2[4], bool block, float breakThreshold);
+proto native dJoint dJointCreateSlider(notnull IEntity ent1, notnull IEntity ent2, vector matrix1[4], vector matrix2[4], bool block, float breakThreshold);
+proto native dJoint dJointCreateBallSocket(notnull IEntity ent1, notnull IEntity ent2, vector point1, vector point2, bool block, float breakThreshold);
+proto native dJoint dJointCreateFixed(notnull IEntity ent1, notnull IEntity ent2, vector point1, vector point2, bool block, float breakThreshold);
+proto native dJoint dJointCreateConeTwist(notnull IEntity ent1, notnull IEntity ent2, vector matrix1[4], vector matrix2[4], bool block, float breakThreshold);
+proto native dJoint dJointCreate6DOF(notnull IEntity ent1, notnull IEntity ent2, vector matrix1[4], vector matrix2[4], bool block, float breakThreshold);
+proto native dJoint dJointCreate6DOFSpring(notnull IEntity ent1, notnull IEntity ent2, vector matrix1[4], vector matrix2[4], bool block, float breakThreshold);
+proto native void dJointDestroy(dJoint joint);
+
+//only hinge joint
+proto native void dJointHingeSetLimits(dJoint joint, float low, float high, float softness, float biasFactor, float relaxationFactor);
+proto native void dJointHingeSetAxis(dJoint joint, vector axis);
+proto native void dJointHingeSetMotorTargetAngle(dJoint joint, float angle, float dt, float maxImpulse);
+
+//only cone-twist joint
+proto native void dJointConeTwistSetAngularOnly(dJoint joint, bool angularOnly);
+// setLimit(), a few notes:
+// _softness:
+//		0->1, recommend ~0.8->1.
+//		describes % of limits where movement is free.
+//		beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached.
+// _biasFactor:
+//		0->1?, recommend 0.3 +/-0.3 or so.
+//		strength with which constraint resists zeroth order (angular, not angular velocity) limit violation.
+// __relaxationFactor:
+//		0->1, recommend to stay near 1.
+//		the lower the value, the less the constraint will fight velocities which violate the angular limits.
+proto native void dJointConeTwistSetLimit(dJoint joint, int limitIndex, float limitValue);
+proto native void dJointConeTwistSetLimits(dJoint joint, float _swingSpan1, float _swingSpan2, float _twistSpan, float _softness, float _biasFactor, float _relaxationFactor);
+
+//only 6DOF & 6DOFSpring.
+/*!
+    - free means upper < lower,
+    - locked means upper == lower
+    - limited means upper > lower
+    - axis: first 3 are linear, next 3 are angular
+*/
+proto native void	dJoint6DOFSetLinearLimits(dJoint joint, vector linearLower, vector linearUpper);
+proto native void	dJoint6DOFSetAngularLimits(dJoint joint, vector angularLower, vector angularUpper);
+proto native void dJoint6DOFSetLimit(dJoint joint, int axis, float lo, float hi);
+
+//when stiffness == -1 && damping == -1, spring is disabled
+proto native void dJoint6DOFSpringSetSpring(dJoint joint, int axis, float stiffness, float damping);
+
+//only slider joint
+proto native void dJointSliderSetLinearLimits(dJoint joint, float lowerLimit, float upperLimit);
+proto native void dJointSliderSetAngularLimits(dJoint joint, float lowerLimit, float upperLimit);
+proto native void dJointSliderSetDirLinear(dJoint joint, float softness, float restitution, float damping);
+proto native void dJointSliderSetDirAngular(dJoint joint, float softness, float restitution, float damping);
+proto native void dJointSliderSetLimLinear(dJoint joint, float softness, float restitution, float damping);
+proto native void dJointSliderSetLimAngular(dJoint joint, float softness, float restitution, float damping);
+proto native void dJointSliderSetOrthoLinear(dJoint joint, float softness, float restitution, float damping);
+proto native void dJointSliderSetOrthoAngular(dJoint joint, float softness, float restitution, float damping);
+//if force == 0, motor is off
+proto native void dJointSliderSetLinearMotor(dJoint joint, float velocity, float force);
+proto native void dJointSliderSetAngularMotor(dJoint joint, float velocity, float force);
+proto native float dJointSliderGetLinearPos(dJoint joint);
+proto native float dJointSliderGetAngularPos(dJoint joint);
+//@}
+
+//-----------------------------------------------------------------
+typedef int[] dMaterial;
+
+class Contact
+{
+	private void Contact() {}
+	private void ~Contact() {}
+	
+	dMaterial	Material1;
+	dMaterial	Material2;
+	int			MaterialIndex1;
+	int			MaterialIndex2;
+	int			Index1;
+	int			Index2;
+
+	float		PenetrationDepth;
+
+	float		Impulse;
+	float		RelativeNormalVelocityBefore;
+	float		RelativeNormalVelocityAfter;
+
+	vector		Normal;
+	vector		Position;
+	vector		RelativeVelocityBefore;
+	vector		RelativeVelocityAfter;
+
+	proto native vector GetNormalImpulse();
+	proto native float GetRelativeVelocityBefore(vector vel);
+	proto native float GetRelativeVelocityAfter(vector vel);
+};
+//@}

scripts/1_Core/DayZ/proto/EnProfiler.c

@@ -0,0 +1,762 @@
+/**
+ * \defgroup Profiler Enforce Script profiling API
+ *	\warning Only available on developer and diag builds
+ * @{
+ */
+
+//! Flags that influences the behaviour of the EnProfiler API, applied through ...Flags functions
+enum EnProfilerFlags
+{
+	//! No flags
+	NONE,
+	//! When present, will reset [PD] on sorting, otherwise will accumulate on top of it
+	RESET,
+	//! Whether to profile child modules
+	RECURSIVE,
+	//! All flags enabled
+	ALL
+};
+
+//! Current base scripted modules 
+enum EnProfilerModule
+{
+	//! 1_Core
+	CORE,
+	//! 2_GameLib
+	GAMELIB,
+	//! 3_Game
+	GAME,
+	//! 4_World
+	WORLD,
+	//! 5_Mission
+	MISSION,
+	//! init.c
+	MISSION_CUSTOM,
+	//! Can be returned from some methods
+	ERROR,
+};
+
+/**
+*\brief There are 3 states which can be toggled that governs whether script profiling is enabled or not
+*	\note The reason for this is because when it is enabled in debug menu, or through this API without 'immediate', it will only be enabled the next frame
+*/
+enum EnProfilerEnabledFlags
+{
+	//! No flags, has value 0, so will count as false in conditions
+	NONE,
+	//! Script profiling UI is enabled in WIN+ALT debug menu, when this is true, it will override SCRP
+	DIAG,
+	//! It has been set to being always enabled through EnProfiler (SCRipt Profiler)
+	SCRP,
+	//! Whether profiling is currently truly happening (SCRipt Context)
+	SCRC,
+};
+
+typedef Param2<float, typename> EnProfilerTimeClassPair;
+typedef Param2<int, typename> EnProfilerCountClassPair;
+
+typedef Param2<float, string> EnProfilerTimeFuncPair;
+typedef Param2<int, string> EnProfilerCountFuncPair;
+
+/**
+*\brief Set of methods for accessing script profiling data
+*	\note To enable profiling on game launch, use parameter "-profile"
+*	\note Any mention of "[DM]" in this context will mean the WIN+ALT debug menu
+*	\note Any mention of "[CI]" in this context will mean Class Instances count
+*	\note Any mention of "[SR]" in this context will mean a Session Reset (See ResetSession for more information)
+*	\note Any mention of "[SD]" in this context will mean a Sorted Data, which is the data which supplies Get...Per... functions (the ones that give an array)
+*	\note Any mention of "[PD]" in this context will mean a Profiling Data, which is the time, count and allocation information which is stored on the class/func itself
+*	\warning [PD] is only calculated AFTER a function call is finished, there is no continuous timer running
+*	\note 'proto' methods are not tracked, but will contribute to a script methods total time
+*/
+class EnProfiler
+{
+	/**
+	\brief Enable the gathering of script profiling data
+	\note DEFAULT: disabled (unless launched with "-profile", then it is default enabled)
+	\note This is separate from the one in [DM], so toggling it in [DM] will not affect this, and toggling it here will not affect [DM]
+	\note It will ignore the call if trying to set the current state, except when "immediate" is used
+		\param enable \p bool Whether to enable or disable, if it was previously not enabled, it will cause [SR]
+			\note Disabling does not cause [SR], so all data will stay intact
+		\param immediate \p bool When true will instantly start/stop profiling, otherwise it will apply it at the end of the frame (to have one stable point in time)
+			\warning Keep in mind that when using immediate, it will not be the data of the entire frame, which can skew data if not kept in mind		
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+	
+	@code
+		// Simple enable, will start profiling the next frame
+		// Will cause [SR] if !IsEnabledP() before this call
+		EnProfiler.Enable(true);
+
+		// Immediate enable, will start profiling immediately
+		// Will cause [SR] if !IsEnabledP() before this call
+		EnProfiler.Enable(true, true);
+
+		// Immediate disable, will stop profiling immediately
+		// Disabling will never cause [SR], preserving data
+		EnProfiler.Enable(false, true);
+
+		// Simple disable, will not profile the next frame (but still finish profiling the current one)
+		// Disabling will never cause [SR], preserving data
+		EnProfiler.Enable(false);
+	@endcode
+	*/
+	static proto void Enable(bool enable, bool immediate = false, bool sessionReset = true);
+	
+	/**
+	\brief Return if script profiling is enabled
+	\note Helper methods below
+		\return \p int Flags regarding the current state
+
+	@code
+		int isScriptProfilingEnabled = EnProfiler.IsEnabled();
+	@endcode
+	*/
+	static proto int IsEnabled();
+	
+	/**
+	\brief Return if script profiling is enabled through [DM]
+		\return \p bool Whether script profiling is enabled through [DM]
+	
+	@code
+		bool isScriptProfilingDiagEnabled = EnProfiler.IsEnabledD();
+	@endcode
+	*/
+	static bool IsEnabledD()
+	{
+		return (IsEnabled() & EnProfilerEnabledFlags.DIAG);
+	}
+	
+	/**
+	\brief Return if script profiling is enabled through EnProfiler
+	\note When using "-profile" launch parameter, it will enable it through EnProfiler, so this will return true
+		\return \p bool Whether script profiling is enabled through script profiler
+	
+	@code
+		bool isScriptProfilingToggleEnabled = EnProfiler.IsEnabledP();
+	@endcode
+	*/
+	static bool IsEnabledP()
+	{
+		return (IsEnabled() & EnProfilerEnabledFlags.SCRP);
+	}
+	
+	/**
+	\brief Return if script profiling is actually turned on inside of the script context
+	\note When using "-profile" launch parameter, it will enable it through EnProfiler, so this will return true
+		\return \p bool Whether script is being profiled as of this moment
+	
+	@code
+		bool isScriptProfilingEnabled = EnProfiler.IsEnabledC();
+	@endcode
+	*/
+	static bool IsEnabledC()
+	{
+		return (IsEnabled() & EnProfilerEnabledFlags.SCRC);
+	}
+	
+	/**
+	\brief The internal sorting that happens at the end of the frame (so it is NOT necessary to call this manually) to supply Get...Per... functions 
+	\note This will clear the previous [SD] and sort the [PD] currently available at this moment
+	\note Flags apply to this
+	\warning Keep in mind that EnProfilerFlags.RESET will clear all [PD] after this is called
+	
+	@code
+		// Sorting all the currently available [PD], populating [SD]
+		EnProfiler.SortData();
+
+		// If flag EnProfilerFlags.RESET is enabled, then this will return 0 now even if it has been called, as [PD] has been cleared
+		// This goes for any Get...Of... function (Except for [CI], the counter persists)
+		EnProfiler.GetTimeOfFunc("Sleep", EnProfilerTests, true);
+	@endcode
+	*/
+	static proto void SortData();
+	
+	/**
+	\brief Perform [SR], clearing SessionFrame, ProfiledSessionFrames, [SD] and [PD] (except for [CI])
+	\note Can also be triggered by a variety of other functions in this API
+	\note When triggered by the other functions, it will call with fullReset = false
+		\param fullReset \p bool Whether to clear [PD] of all modules, when false it will only clear the [PD] according to current settings
+	
+	@code
+		// Considering the settings: SetFlags(EnProfilerFlags.NONE) and SetModule(EnProfilerModule.GAME)
+		// The following call will only clear [PD] of 3_Game
+		EnProfiler.ResetSession();
+
+		// Considering the settings: SetFlags(EnProfilerFlags.RECURSIVE) and SetModule(EnProfilerModule.WORLD)
+		// The following call will clear [PD] of 3_Game, 4_World, 5_Mission and their children
+		EnProfiler.ResetSession();
+
+		// The following call resets [PD] across all modules
+		EnProfiler.ResetSession(true);
+	@endcode
+	*/
+	static proto void ResetSession(bool fullReset = false);
+	
+	
+	
+	/** \name EnProfilerFlags
+		Set of functions to configure the currently active EnProfilerFlags
+	*/
+	//@{
+	
+	/**
+	\brief Override the currently used set of EnProfilerFlags across the API
+	\note DEFAULT: EnProfilerFlags.ALL
+		\param flags \p int The combination of desired EnProfilerFlags to override the currently used set
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+		\return \p int The currently used set of EnProfilerFlags after the function call
+	
+	@code
+		// No RESET flag, [PD] will be accumulated across frames
+		// No RECURSIVE flag, only the curently profiled module will be sorted
+		EnProfiler.SetFlags(EnProfilerFlags.NONE);
+
+		// RESET flag, [PD] will be reset after sorting
+		// No RECURSIVE flag, only the curently profiled module will be sorted
+		EnProfiler.SetFlags(EnProfilerFlags.RESET);
+
+		// RESET flag, [PD] will be reset after sorting
+		// RECURSIVE flag, all modules will be sorted
+		EnProfiler.SetFlags(EnProfilerFlags.ALL);
+	@endcode
+	*/
+	static proto int SetFlags(int flags, bool sessionReset = true);
+	
+	/**
+	\brief Get the currently used flags across the API
+		\return \p int The currently used set of EnProfilerFlags
+	
+	@code
+		int flags = EnProfiler.GetFlags();
+
+		if (flags & EnProfilerFlags.RECURSIVE)
+		{
+			Print("Currently profiling all modules.");
+		}
+	@endcode
+	*/
+	static proto int GetFlags();
+	
+	/**
+	\brief Check if the flags are set
+	\note Is effectively the same as the code displayed in GetFlags example, but without the bitwise operation
+		\param flags \p int The combination of EnProfilerFlags to check if present
+		\return \p bool If the flags are set
+	
+	@code
+		if (EnProfiler.IsFlagsSet(EnProfilerFlags.ALL))
+		{
+			Print("Currently all flags are enabled.");
+		}
+
+		if (EnProfiler.IsFlagsSet(EnProfilerFlags.RECURSIVE))
+		{
+			Print("Currently profiling all modules.");
+		}
+	@endcode
+	*/
+	static proto bool IsFlagsSet(int flags);
+	
+	/**
+	\brief Add flags to the currently used set of EnProfilerFlags across the API
+	\note Simply a helper method to quickly add EnProfilerFlags
+		\param flags \p int The combination of desired EnProfilerFlags to be added to the currently used set
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+		\return \p int The currently used set of EnProfilerFlags after the function call
+	
+	@code
+		// In the case where the current set of EnProfilerFlags is EnProfilerFlags.RESET
+		EnProfiler.AddFlags(EnProfilerFlags.RECURSIVE);
+		// The resulting set of flags now will be EnProfilerFlags.RESET | EnProfilerFlags.RECURSIVE
+		// As the above is pretty much the same as the following
+		// EnProfiler.SetFlags(EnProfiler.GetFlags() | EnProfilerFlags.RECURSIVE);
+		// But a much cleaner and faster alternative (bitwise operations in script is ~10x slower than C++)
+	@endcode
+	*/
+	static proto int AddFlags(int flags, bool sessionReset = true);
+	
+	/**
+	\brief Remove flags from the currently used set of EnProfilerFlags across the API
+	\note Simply a helper method to quickly remove EnProfilerFlags
+		\param flags \p int The combination of desired EnProfilerFlags to be added to the currently used set
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+		\return \p int The currently used set of EnProfilerFlags after the function call
+	
+	@code
+		// In the case where the current set of EnProfilerFlags is EnProfilerFlags.RESET
+		EnProfiler.RemoveFlags(EnProfilerFlags.RESET);
+		// The resulting set of flags now will be EnProfilerFlags.NONE
+		// As the above is pretty much the same as the following
+		// EnProfiler.SetFlags(EnProfiler.GetFlags() & ~EnProfilerFlags.RECURSIVE);
+		// But a much cleaner and faster alternative (bitwise operations in script is ~10x slower than C++)
+	@endcode
+	*/
+	static proto int RemoveFlags(int flags, bool sessionReset = true);
+	
+	/**
+	\brief Remove all flags from the currently used set of EnProfilerFlags across the API
+	\note Simply a helper method to quickly remove all EnProfilerFlags
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+		\return \p int The currently used set of EnProfilerFlags after the function call
+	
+	@code
+		// In the case where the current set of EnProfilerFlags is EnProfilerFlags.RESET
+		EnProfiler.ClearFlags();
+		// The resulting set of flags now will be EnProfilerFlags.NONE
+		// As the above is pretty much the same as the following
+		// EnProfiler.SetFlags(EnProfilerFlags.NONE);
+		// But a much cleaner and implicit alternative
+	@endcode
+	*/
+	static proto int ClearFlags(bool sessionReset = true);
+	
+	//@}
+	
+	
+	
+	/** \name EnProfilerModule
+		Set of functions to configure the currently profiled EnProfilerModule
+	*/
+	//@{
+	
+	/**
+	\brief Set the module to be profiled
+	\note DEFAULT: EnProfilerModule.CORE
+	\note When session reset is enabled, it will only reset the module which it is currently being set to, previous module data will be untouched
+		\param module \p EnProfilerModule The module to profile
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+	
+	@code
+		EnProfiler.SetModule(EnProfilerModule.WORLD);
+	@endcode
+	*/
+	static proto void SetModule(EnProfilerModule module, bool sessionReset = true);
+	
+	/**
+	\brief Get the currently profiled module
+		\return \p EnProfilerModule The currently profiled module
+	
+	@code
+		EnProfilerModule module = EnProfiler.GetModule();
+	@endcode
+	*/
+	static proto EnProfilerModule GetModule();
+	
+	/**
+	\brief Helper to convert EnProfilerModule to string
+		\param module \p EnProfilerModule The module to get the name of
+		\return \p string The name of the module
+	
+	@code
+		string moduleName = EnProfiler.ModuleToName(EnProfilerModule.GAME);
+	@endcode
+	*/
+	static proto owned string ModuleToName(EnProfilerModule module);
+	
+	/**
+	\brief Convert string to EnProfilerModule
+		\param moduleName \p string The name of the module
+		\param module \p EnProfilerModule The enum value of the module or EnProfilerModule.ERROR if not found
+		\return \p bool Whether the module was found 
+	
+	@code
+		// Get the name of the module of the current class
+		string nameOfCurrentModule = Type().GetModule();
+		EnProfilerModule module;
+
+		// Convert it to the enum value
+		if (EnProfiler.NameToModule(nameOfCurrentModule, module))
+		{
+			EnProfiler.SetModule(module);
+		}
+		else
+		{
+			ErrorEx(string.Format("Could not find EnProfilerModule: %1", nameOfCurrentModule));
+		}
+	@endcode
+	*/
+	static proto bool NameToModule(string moduleName, out EnProfilerModule module);
+	
+	//@}
+	
+	
+	
+	/**
+	\brief Set the interval for the [SD] to update
+	\note DEFAULT: 0
+	\note [DM] has the following values: {0, 5, 10, 20, 30, 50, 60, 120, 144}; When an interval not part of this list is set, [DM] will be set to "CUSTOM_INTERVAL"
+	\note Does not affect the gathering of [PD], this will happen continuously as the profiling is enabled
+	\note This also delays the [SR] caused by EnProfilerFlags.RESET
+		\param interval \p int Amount of frames to wait before [SD] is updated
+		\param sessionReset \p bool When set to false, no [SR] will trigger, regardless of situation
+	
+	@code
+		// This will make it so that [SD] is updated every 60 frames
+		EnProfiler.SetInterval(60);
+	@endcode
+	*/
+	static proto void SetInterval(int interval, bool sessionReset = true);
+	
+	/**
+	\brief Get the currently set interval
+		\return \p int The currently set interval
+	
+	@code
+		int currentInterval = EnProfiler.GetInterval();
+	@endcode
+	*/
+	static proto int GetInterval();
+	
+	
+	
+	/**
+	\brief Set the resolution of the fetched Time data
+	\note DEFAULT: 100000
+	\note [DM] has the following values: {100000, 1000000, 1, 10, 100, 1000, 10000}; These are the only values available, otherwise it will round up to one in the list
+	\note Does not affect any data itself, only the fetching and displaying of it (therefore, no [SR] is ever triggered by this method)
+		\param resolution \p int The nth resolution of a second
+	
+	@code
+		// Have all time being reported in 1 second
+		EnProfiler.SetTimeResolution(1);
+
+		// Have all time being reported in 1000th of a second (ms)
+		EnProfiler.SetTimeResolution(1000);
+	@endcode
+	*/
+	static proto void SetTimeResolution(int resolution);
+	
+	/**
+	\brief Get the currently set time resolution
+		\return \p int The currently set resolution
+	
+	@code
+		int currentTimeResolution = EnProfiler.GetTimeResolution();
+	@endcode
+	*/
+	static proto int GetTimeResolution();
+	
+	
+	
+	/**
+	\brief Enable/disable returning calculated averages
+	\note DEFAULT: false
+	\note When EnProfilerFlags.RESET flag is not present, it will divide by the session frame
+	\note When an interval is set, it will divide by the interval
+	\note Does not affect any data itself, only the fetching and displaying of it (therefore, no [SR] is ever triggered by this method)
+	\note [CI] will never be an average, it will always be the current count of the instance (allocations will be the value of how many times an instance is created)
+		\param enable \p bool Whether to enable or disable
+	
+	@code
+		// For example, take the situation where we only reset every 60 frames
+		EnProfiler.AddFlags(EnProfilerFlags.RESET);
+		EnProfiler.SetInterval(60);
+		EnProfiler.EnableAverage(true);
+
+		// And a method is called once per frame, gathering the count of that function will be 1
+		// Or if a method is called twice per frame, gathering the count of that function will be 2
+		// Or if a method is 3 times every 3 frames, gathering the count of that function will be 1
+		// ...
+		// So you get the average amount of times the method is called per frame, out of the sample of 60 frames
+	@endcode
+	*/
+	static proto void EnableAverage(bool enable);
+	
+	/**
+	\brief Check if returning of average data is enabled
+		\return \p bool Whether returning of average data is enabled
+	
+	@code
+		bool isDataAverage = EnProfiler.IsAverage();
+	@endcode
+	*/
+	static proto bool IsAverage();
+	
+	
+	
+	/**
+	\brief Print out [SD] to script log
+	
+	@code
+		EnProfiler.Dump();
+	@endcode
+	*/
+	static proto void Dump();
+	
+	
+	
+	/** \name Frame data
+		Set of functions to obtain information about frame counts
+	*/
+	//@{
+	
+	/**
+	\brief Get the total amount of frames passed
+		\return \p int The total amount of frames passed
+	
+	@code
+		int gameFrame = EnProfiler.GetGameFrame();
+	@endcode
+	*/
+	static proto int GetGameFrame();
+	
+	/**
+	\brief Get the total amount of frames in this profiling session
+	\note This will only differ from GetProfiledSessionFrames when there is an Interval set
+		\return \p int The total amount of frames in this profiling session
+	
+	@code
+		int sessionFrame = EnProfiler.GetSessionFrame();
+	@endcode
+	*/
+	static proto int GetSessionFrame();
+	
+	/**
+	\brief Get the total amount of frames across all profiling session
+	\note This will only differ from GetProfiledFrames when there was an Interval set at some point
+		\return \p int The total amount of frames across all profiling session
+	
+	@code
+		int totalFrames = EnProfiler.GetTotalFrames();
+	@endcode
+	*/
+	static proto int GetTotalFrames();
+	
+	/**
+	\brief Get the total amount of frames profiled in this profiling session
+	\note This will only differ from GetSessionFrame when there is an Interval set
+		\return \p int The total amount of frames profiled in this profiling session
+	
+	@code
+		int profiledSessionFrames = EnProfiler.GetProfiledSessionFrames();
+	@endcode
+	*/
+	static proto int GetProfiledSessionFrames();
+	
+	/**
+	\brief Get the total amount of frames profiled across all profiling session
+	\note This will only differ from GetTotalFrames when there was an Interval set at some point
+		\return \p int The total amount of frames profiled across all profiling session
+	
+	@code
+		int totalProfiledFrames = EnProfiler.GetProfiledFrames();
+	@endcode
+	*/
+	static proto int GetProfiledFrames();
+	
+	//@}
+	
+
+	
+	/** \name Sorted data
+		Set of functions to obtain [SD]
+		\warning Data is appended to the array, it will not clear any previous data already existing in the array
+		\note Read SortData as well for more information regarding [SD]
+	*/
+	//@{
+	
+	/**
+	\brief Obtain [SD] for Time Per Class
+		\param outArr \p array<ref EnProfilerTimeClassPair> Array sorted by time consumed by a class
+		\param count \p int The maximum amount of entries wanted
+	
+	@code
+		// In this example the array will be filled with the 20 most time intensive classes
+		// If there are less than 20 classes which consumed time, it will output that number of classes instead
+		array<ref EnProfilerTimeClassPair> timePerClass = {};
+		EnProfiler.GetTimePerClass(timePerClass, 20);
+
+		// In this example the array will be filled with all classes sorted by time
+		array<ref EnProfilerTimeClassPair> timePerClass2 = {};
+		EnProfiler.GetTimePerClass(timePerClass2);
+	@endcode
+	*/
+	static proto void GetTimePerClass(notnull out array<ref EnProfilerTimeClassPair> outArr, int count = int.MAX);
+	
+	/**
+	\brief Obtain [SD] for Allocations Per Class
+		\param outArr \p array<ref EnProfilerCountClassPair> Array sorted by number of allocations of a class
+		\param count \p int The maximum amount of entries wanted
+	
+	@code
+		array<ref EnProfilerCountClassPair> allocPerClass = {};
+		EnProfiler.GetAllocationsPerClass(allocPerClass, 20);
+	@endcode
+	*/
+	static proto void GetAllocationsPerClass(notnull out array<ref EnProfilerCountClassPair> outArr, int count = int.MAX);
+	
+	/**
+	\brief Obtain [SD] for Instances Per Class
+		\param outArr \p array<ref EnProfilerCountClassPair> Array sorted by number of instances of a class
+		\param count \p int The maximum amount of entries wanted
+	
+	@code
+		array<ref EnProfilerCountClassPair> instancesPerClass = {};
+		EnProfiler.GetInstancesPerClass(instancesPerClass, 20);
+	@endcode
+	*/
+	static proto void GetInstancesPerClass(notnull out array<ref EnProfilerCountClassPair> outArr, int count = int.MAX);
+	
+	/**
+	\brief Obtain [SD] for Time Per Function
+		\param outArr \p array<ref EnProfilerTimeFuncPair> Array sorted by time consumed by a function
+		\param count \p int The maximum amount of entries wanted
+	
+	@code
+		array<ref EnProfilerTimeFuncPair> timePerFunc = {};
+		EnProfiler.GetTimePerFunc(timePerFunc, 20);
+	@endcode
+	*/
+	static proto void GetTimePerFunc(notnull out array<ref EnProfilerTimeFuncPair> outArr, int count = int.MAX);
+	
+	/**
+	\brief Obtain [SD] for Count Per Function
+		\param outArr \p array<ref EnProfilerCountFuncPair> Array sorted by amount of times a function was called
+		\param count \p int The maximum amount of entries wanted
+	
+	@code
+		array<ref EnProfilerCountFuncPair> countPerFunc = {};
+		EnProfiler.GetCountPerFunc(countPerFunc, 20);
+	@endcode
+	*/
+	static proto void GetCountPerFunc(notnull out array<ref EnProfilerCountFuncPair> outArr, int count = int.MAX);
+	
+	//@}
+	
+	
+	
+	/** \name Specific data
+		Set of functions to obtain specific data
+	*/
+	//@{
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the time a specific class consumed
+		\param clss \p typename Typename of desired class
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p float Time consumed by the specified class
+	
+	@code
+		// Consider the class
+		EPTHelperClass clss = new EPTHelperClass();
+
+		// Some functions being called here...
+	
+		// Gathering of data can be done through
+		float timeOfClass = EnProfiler.GetTimeOfClass(clss.Type(), true);
+
+		// Or when you have no variable/reference
+		float timeOfClass2 = EnProfiler.GetTimeOfClass(StaticGetType(EPTHelperClass), true);
+	@endcode
+	*/
+	static proto float GetTimeOfClass(typename clss, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the allocations of a specific class
+		\param clss \p typename Typename of desired class
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p int Allocations of the specified class
+	
+	@code
+		int allocationsOfClass = EnProfiler.GetAllocationsOfClass(StaticGetType(EPTHelperClass), true);
+	@endcode
+	*/
+	static proto int GetAllocationsOfClass(typename clss, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the [CI] of a specific class
+		\param clss \p typename Typename of desired class
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p int [CI] of the specified class
+	
+	@code
+		int instancesOfClass = EnProfiler.GetInstancesOfClass(StaticGetType(EPTHelperClass), true);
+	@endcode
+	*/
+	static proto int GetInstancesOfClass(typename clss, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the time consumed by a specific function
+		\param funct \p string Function name
+		\param clss \p typename Typename of class the function belongs to
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p float Time consumed by the specified function or -1 when function was not found
+	
+	@code
+		float timeOfFunc = EnProfiler.GetTimeOfFunc("StringFormat", StaticGetType(EnProfilerTests), true);
+	@endcode
+	*/
+	static proto float GetTimeOfFunc(string funct, typename clss, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the time consumed by a specific global function
+		\param funct \p string Function name
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p float Time consumed by the specified function or -1 when function was not found
+	
+	@code
+		float timeOfFunc = EnProfiler.GetTimeOfFuncG("ErrorEx", true);
+	@endcode
+	*/
+	static proto float GetTimeOfFuncG(string funct, bool immediate, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the amount of times a specific function was called
+		\param funct \p string Function name
+		\param clss \p typename Typename of class the function belongs to
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p int Amount of calls to the specified function or -1 when function was not found
+	
+	@code
+		int callCountOfFunc = EnProfiler.GetCountOfFunc("StringFormat", StaticGetType(EnProfilerTests), true);
+	@endcode
+	*/
+	static proto int GetCountOfFunc(string funct, typename clss, bool immediate = false);
+	
+	/**
+	\brief Obtain [SD] or [PD] regarding the amount of times a specific function was called
+		\param funct \p string Function name
+		\param immediate \p bool When true, it will pull from [SD], when false it will pull from [PD]
+		\return \p int Amount of calls to the specified function or -1 when function was not found
+	
+	@code
+		int callCountOfFunc = EnProfiler.GetCountOfFuncG("ErrorEx", true);
+	@endcode
+	*/
+	static proto int GetCountOfFuncG(string funct, bool immediate = false);
+	
+	//@}
+	
+	
+	
+	/** \name Misc
+		Set of helper functions
+	*/
+	//@{
+	
+	/**
+	\brief Helper method to ascertain the profiler will record [PD] right after this call
+		\return \p bool Whether it was enabled before or not
+	
+	@code
+		bool wasEnabled = EnProfiler.RequestImmediateData();
+	@endcode
+	*/
+	static bool RequestImmediateData()
+	{
+		// I only care if it is actually profiling right now, so C
+		bool wasEnabled = IsEnabledC();
+		
+		if (!wasEnabled)
+		{
+			// I want the data, and I want it now, so immediate
+			Enable(true, true);
+		}
+		
+		return wasEnabled;
+	}
+	
+	//@}
+};
+
+ //@}

scripts/1_Core/DayZ/proto/EnScript.c

@@ -0,0 +1,1003 @@
+/**
+ * \defgroup Enforce Enforce script essentials
+ * \note \p float ftime; The deltaTime since last frame
+ * \note \p float FLT_MAX; The maximum value for float
+ * \note \p float FLT_MIN; The minimum value for float
+ * @{
+ */
+
+ //! Super root of all classes in Enforce script
+class Class
+{
+	/**
+	\brief Returns true when instance is of the type, or inherited one.
+	\param type Class type
+	\returns \p bool true when 'clType' is the same as 'type', or inherited one.
+	@code
+		if (inst && inst.IsInherited(Widget))
+		{
+			Print("inst is inherited from Widget class!");		
+		}
+	@endcode
+	*/
+	proto native external bool IsInherited(typename type);
+	
+	/**
+	\brief Returns name of class-type
+		\param inst Class
+		\returns \p string class-type
+		@code
+			Man player = g_Game.GetPlayer();
+			string className = player.ClassName();
+			Print(className);
+
+			>> className = 'Man'
+		@endcode
+	*/
+	proto native owned external string ClassName();
+	
+	string GetDebugName() { return ClassName(); }
+	
+	/**
+	\brief Returns typename of object's class
+		\returns \p typename class-type
+		@code
+			Man player = g_Game.GetPlayer();
+			typename type = player.Type();
+			Print(type.ToString());
+
+			>> 'Man'
+		@endcode
+	*/
+	proto native external typename Type();
+	
+	/**
+	\brief Returns typename of object's reference
+		\returns \p typename class-type
+		@code
+			EntityAI e;
+			Print(e.StaticType());
+
+			>> 'EntityAI'
+		@endcode
+	*/	
+	proto external static typename StaticType();
+	
+	/**
+	\brief Returns typename of class even without a variable or instance
+		\returns \p typename class-type
+		@code
+			typename eAITypename = StaticGetType(EntityAI);
+		@endcode
+	*/
+	static typename StaticGetType(typename t)
+	{
+		return t;
+	}
+	
+	proto external string ToString();
+	
+	/**
+	\brief Try to safely down-cast base class to child class.
+		\returns down-casted 'from' pointer when cast is successfull (classes are related), or null if casting is invalid
+		@code
+			// assume that Man inheites from Object
+			Object obj = g_Game.GetPlayer();
+			Man player = Man.Cast(obj);
+			
+			if (player)
+			{
+				// horay!
+			}
+		@endcode
+	*/		
+	proto static Class Cast(Class from);
+	
+	/**
+	\brief Try to safely down-cast base class to child class.
+		\returns \p bool true when 'from' is not null and cast successfull, false when casting is not valid or 'from' is null
+		@code
+			// assume that Man inheites from Object
+			Object obj = g_Game.GetPlayer();
+			Man player;
+			
+			if (Class.CastTo(player, obj))
+			{
+				// horay!
+			}
+		@endcode
+	*/	
+	proto static bool CastTo(out Class to, Class from);
+	
+	//! This function is for internal script usage
+	private proto static bool SafeCastType(Class type, out Class to, Class from);
+};
+
+ //! TODO doc
+class Managed
+{
+};
+
+//! TODO doc
+class NonSerialized
+{
+};
+
+//! script representation for C++ RTTI types
+typedef int[] TypeID;
+
+//! Module containing compiled scripts.
+class ScriptModule
+{
+	private void ~ScriptModule();
+
+	/*!dynamic call of function
+	when inst == NULL, it's global function call, otherwise it's method of class
+	returns true, when success
+	The call creates new thread, so it's legal to use sleep/wait
+  */
+	proto volatile int Call(Class inst, string function, void parm);
+
+	/*!dynamic call of function
+	when inst == NULL, it's global function call, otherwise it's method of class
+	returns true, when success
+	The call do not create new thread!!!!
+  */
+	proto volatile int CallFunction(Class inst, string function, out void returnVal, void parm);
+	proto volatile int CallFunctionParams(Class inst, string function, out void returnVal, Class parms);
+	proto native void Release();
+	
+	/**
+	\brief Do load script and create ScriptModule for it
+		\param parentModule Module
+		\param scriptFile Script path
+		\param listing ??
+		\returns \p ScriptModule Loaded scripted module
+		@code
+			???
+		@endcode
+	*/
+	static proto native ScriptModule LoadScript(ScriptModule parentModule, string scriptFile, bool listing);
+};
+
+//main script module (contains script.c and this file)
+//ScriptModule g_Script;
+
+class EnScript
+{
+	private void EnScript() {}
+	private void ~EnScript() {}
+	
+	/**
+	\brief Dynamic read of variable value by its name
+		\param inst When inst == NULL, it's for global variable, otherwise it's class member
+		\param index Is index when variable is array
+		\param[out] result Variable must be of the same type!
+		\returns \p int true when success
+		@code
+			float count = 0;
+
+			bool success = EnScript.GetClassVar(myClass, "m_Counter", 0, count);
+			Print(count);
+			Print(success);
+
+			>> count = 5
+			>> success = 1
+		@endcode
+	*/
+	static proto int GetClassVar(Class inst, string varname,int index, out void result);
+
+	/**
+	\brief Dynamic write to variable by its name
+		\param inst when inst == NULL, it's for global variable, otherwise it's class member
+		\param varname
+		\param index Is index when variable is array
+		\param input Input variable must be of the same type!
+		\returns \p int Returns true(1) when success
+		@code
+			Print(myClass.m_Counter);
+
+			>> m_Counter = 0
+
+			bool success = EnScript.SetClassVar(myClass, "m_Counter", 0, 5.0);
+
+			Print(myClass.m_Counter);
+			Print(success);
+
+			>> m_Counter = 5
+			>> success = 1
+		@endcode
+	*/
+	static proto int SetClassVar(Class inst, string varname, int index, void input);
+	
+	/**
+	\brief Sets variable value by value in string
+		\param[out] var
+		\param value
+		\returns int
+		@code
+			???
+		@endcode
+	*/
+	static proto int SetVar(out void var, string value);
+
+	/**
+	\brief Debug tool for watching certain variable. Invokes debugger whenever is variable used
+		\param var Certain variable for watching
+		\param flags = 1 means it will break even when not modified
+		\return \p void
+	*/
+	static proto void Watch(void var, int flags);
+};
+
+
+
+/**
+\brief Sorts static array of integers(ascendically) / floats(ascendically) / strings(alphabetically)
+	\param param_array \p array Array to sort
+	\param num \p int How many items will be sorted in array
+	\return \p void
+	@code
+		string	arrStr[3] = {"Dog", "Car", "Apple"};
+		Sort(arrStr, 2)
+		for ( int x = 0; x < 3; x++ )
+		{
+			Print( arrStr[x] );
+		}
+
+		>> 'Car'
+		>> 'Dog'
+		>> 'Apple'
+	@endcode
+*/
+proto void Sort(void param_array[], int num);
+proto void reversearray(void param_array);
+proto void copyarray(void destArray, void srcArray);
+
+/**
+\brief Parses one token from input string. Result is put into token string, and type of token is returned. Input string is left-truncated by the resulting token length.
+	\param[in,out] input \p string String for parse\ Output is without founded token
+	\param[out] token \p string Founded string token
+	\return \p int Type of token
+	\verbatim
+Token types:
+ 0 - error, no token
+ 1 - defined token (special characters etc. . / * )
+ 2 - quoted string. Quotes are removed -> TODO
+ 3 - alphabetic string
+ 4 - number
+ 5 - end of line -> TODO
+	\endverbatim
+	@code
+		string input = "Hello*World";
+		string token1;
+		string token2;
+
+		int result1 = ParseStringEx(input, token1);
+		int result2 = ParseStringEx(input, token2);
+
+		Print( String( "Token1 = '" + token1 + "' Type = " + result1.ToString() ) );
+		Print( String( "Token2 = '" + token2 + "' Type = " + result2.ToString() ) );
+		Print( input );
+
+		>> 'Toke1 = 'Hello' Type = 3'
+		>> 'Toke1 = '*' Type = 1'
+	@endcode
+*/
+proto int ParseStringEx(inout string input, string token);
+
+/**
+\brief Parses string into array of tokens returns number of tokens
+	\param input \p string String for parse
+	\param[out] tokens \p array[] Parsed string in array
+	\return \p int Number of tokens
+	@code
+		string token[2];
+		int result = ParseString("Hello World", token);
+
+		for( int i = 0; i < 2; i++ )
+		{
+			Print(token[i]);
+		}
+
+		>> 'Hello'
+		>> 'World'
+	@endcode
+*/
+proto int ParseString(string input, out string tokens[]);
+
+/**
+\brief Kills thread.
+	\param owner Can be NULL for global threads.
+	\param name Name of the first function on stack
+	\return \p int ???
+	@code
+		???
+	@endcode
+*/
+proto native int KillThread(Class owner, string name);
+
+/**
+Yiels execution to other threads and then it continues. Obsolete...
+*/
+proto volatile void Idle();
+
+/**
+\brief Debug function. Returns current function on stack of the thread
+	\param owner Can be NULL for global threads
+	\param name Name of the first function on stack
+	\param backtrace ???
+	\param linenumber ???
+	\return \p string ???
+	@code
+		???
+	@endcode
+*/
+proto owned string ThreadFunction(Class owner, string name, int backtrace, out int linenumber);
+
+//!Helper for passing string expression to functions with void parameter. Example: Print(String("Hello " + var));
+string String(string s)
+{
+	return s;
+}
+
+//!Helper for printing out string expression. Example: PrintString("Hello " + var);
+void PrintString(string s)
+{
+	Print(s);
+}
+
+class array<Class T>
+{
+	/*!
+	O(1) complexity.
+	\return Number of elements of the array
+	*/
+	proto native int Count();
+	/*!
+	Destroyes all elements of the array and sets the Count to 0.
+	The underlying memory of the array is not freed.
+	*/
+	proto native void Clear();
+	/*!
+	Sets n-th element to given value.
+	*/
+	proto void Set(int n, T value);
+	/*!
+	Tries to find the first occurance of given value in the array.
+	\return Index of the first occurance of `value` if found, -1 otherwise
+	*/
+	proto int Find(T value);
+	/*!
+	\return Element at the index `n`
+	*/
+
+	proto T Get(int n);
+	/*!
+	Inserts element at the end of array.
+	\param value
+	Element to be inserted
+	\return
+	Position at which element is inserted
+	*/
+	proto int Insert(T value);
+	/*!
+	Inserts element at certain position and moves all elements behind
+	this position by one.
+	\param value
+	Element to be inserted
+	\param index
+	Position at which element is inserted. Must be less than Array::GetCardinality()
+	\return
+	Number of elements after insertion
+	*/
+	proto int InsertAt(T value, int index);
+	/**
+	\brief Inserts all elements from array
+		\param from \p array<T> array from which all elements will be added
+		@code
+			TStringArray arr1 = new TStringArray;
+			arr1.Insert( "Dave" );
+			arr1.Insert( "Mark" );
+			arr1.Insert( "John" );
+			
+			TStringArray arr2 = new TStringArray;
+			arr2.Insert( "Sarah" );
+			arr2.Insert( "Cate" );
+			
+			arr1.InsertAll(arr2);
+			
+			for ( int i = 0; i < arr1.Count(); i++ )
+			{
+				Print( arr1.Get(i) );
+			}
+			
+			delete arr2;
+			delete arr1;
+
+			>> "Dave"
+			>> "Mark"
+			>> "John"
+			>> "Sarah"
+			>> "Cate"
+		@endcode
+	*/
+	void InsertAll(notnull array<T> from)
+	{
+		for ( int i = 0; i < from.Count(); i++ )
+		{
+			Insert( from.Get(i) );
+		}
+	}
+	/*!
+	Removes element from array. The empty position is replaced by
+	last element, so removal is quite fast but do not retain order.
+	\param index
+	Index of element to be removed
+	*/
+	proto native void Remove(int index);
+	/*!
+	Removes element from array, but retain all elements ordered. It's
+	slower than Remove
+	\param index
+	Index of element to be removed
+	*/
+	proto native void RemoveOrdered(int index);
+	/*!
+	Resizes the array to given size.
+	If the `newSize` is lower than current Count overflowing objects are destroyed.
+	If the `newSize` is higher than current Count missing elements are initialized to zero (null).
+	*/
+	proto native void Resize(int newSize);
+	
+	/*!
+	Resizes the array to given size internally.
+	Is used for optimization purposes when the approx. size is known beforehand
+	*/
+	proto native void Reserve(int newSize);
+
+	/*!
+	Swaps the contents of this and `other` arrays.
+	Does not involve copying of the elements.
+	*/
+	proto native void Swap(notnull array<T> other);
+
+	/*!
+	Sorts elements of array, depends on underlaying type.
+	*/
+	proto native void Sort(bool reverse = false);
+	/*!
+	Copes contents of `from` array to this array.
+	\return How many elements were copied
+	*/
+
+	proto int Copy(notnull array<T> from);
+	proto int Init(T init[]);
+
+	void RemoveItem(T value)
+	{
+		int remove_index = Find(value);
+
+		if ( remove_index >= 0 )
+		{
+			RemoveOrdered(remove_index);
+		}
+	}
+	
+	void RemoveItemUnOrdered(T value)
+	{
+		int remove_index = Find(value);
+
+		if ( remove_index >= 0 )
+		{
+			Remove(remove_index);
+		}
+	}
+	
+	bool IsValidIndex( int index )
+	{
+		return ( index > -1 && index < Count() );
+	}
+	
+	/*
+	T GetChecked( int index )
+	{
+		if( IsValidIndex( index ) )
+			return Get( index );
+		else
+			return null;
+	}
+	*/
+
+	/**
+	\brief Print all elements in array
+		\return \p void
+		@code
+			my_array.Debug();
+
+			>> "One"
+			>> "Two"
+			>> "Three"
+		@endcode
+	*/
+	void Debug()
+	{
+		Print(string.Format("Array count: %1", Count()));
+		for (int i = 0; i < Count(); i++)
+		{
+			T item = Get(i);
+			Print(string.Format("[%1] => %2", i, item));
+		}
+	}
+
+	/**
+	\brief Returns a random index of array. If Count is 0, return index is -1 .
+		\return \p int Random index of array
+		@code
+			Print( my_array.GetRandomIndex() );
+
+			>> 2
+		@endcode
+	*/
+	int GetRandomIndex()
+	{
+		if ( Count() > 0 )
+		{
+			return Math.RandomInt(0, Count());
+		}
+		
+		return -1;	
+	}
+
+	/**
+	\brief Returns a random element of array
+		\return \p int Random element of array
+		@code
+			Print( my_array.GetRandomElement() );
+
+			>> "Three"
+		@endcode
+	*/
+	T GetRandomElement()
+	{
+		return Get(GetRandomIndex());
+	}
+
+	void SwapItems(int item1_index, int item2_index)
+	{
+		T item1 = Get(item1_index);
+		Set(item1_index, Get(item2_index));
+		Set(item2_index, item1);
+	}
+	
+	void InsertArray(array<T> other)
+	{
+		for (int i = 0; i < other.Count(); i++)
+		{
+			T item = other.Get(i);
+			Insert(item);
+		}
+	}
+	
+	void Invert()
+	{
+		int left = 0;
+		int right = Count() - 1;
+		if (right > 0)
+		{
+			while (left < right)
+			{
+				T temp = Get(left);
+				Set(left++, Get(right));
+				Set(right--, temp);
+			}
+		}
+	}
+	
+	/**
+	\brief Returns a index in array moved by specific number
+		\return \p int Moved index in this array
+		@code
+			Print( "Count: "+ my_array.Count() );
+			Print( "Moved 1:"+ my_array.MoveIndex(2, 1) );
+			Print( "Moved 3:"+ my_array.MoveIndex(2, 2) );
+
+			>> "Count: 4"
+			>> "Moved index 2 by 1: 3";
+			>> "Moved index 2 by 2: 0";
+		@endcode
+	*/
+	int MoveIndex(int curr_index, int move_number)
+	{
+		int count = Count();
+		int new_index = curr_index;
+		
+		if ( move_number > 0 )
+		{
+			new_index = curr_index + move_number;
+		}
+		
+		if ( move_number < 0 )
+		{
+			new_index = curr_index - move_number;
+			
+			if ( new_index < 0 )
+			{
+				if ( new_index <= -count )
+				{
+					new_index = (new_index % count);
+				}
+				
+				new_index = new_index + count;
+			}
+		}
+		
+		if ( new_index >= count )
+		{
+			new_index = (new_index % count);
+		}
+		
+		// move_number is 0
+		return new_index;
+	}
+	
+	void ShuffleArray()
+	{
+		for (int i = 0; i < Count(); i++)
+		{
+			SwapItems(i,GetRandomIndex());
+		}
+	}
+	
+	/**
+	\brief Returns an index where 2 arrays start to differ from each other
+		\return \p int Index from where arrays differ
+		@code
+			array<int> arr1 = {0,1,2,3};
+			array<int> arr2 = {0,1,3,2};
+			int differsAt = arr1.DifferentAtPosition(arr2);
+			Print(differsAt);
+	
+			>> 2
+		@endcode
+	*/
+	int DifferentAtPosition(array<T> pOtherArray)
+	{
+		if (Count() != pOtherArray.Count())
+		{
+			ErrorEx("arrays are not the same size");
+			return -1;
+		}
+
+		for (int i = 0; i < pOtherArray.Count(); ++i)
+		{
+			if (Get(i) != pOtherArray.Get(i))
+			{
+				return i;
+			}
+		}
+		
+		return -1;
+	}
+};
+
+//force these to compile so we can link C++ methods to them
+typedef array<string> TStringArray;
+typedef array<float> TFloatArray;
+typedef array<int> TIntArray;
+typedef array<bool> TBoolArray;
+typedef array<Class> TClassArray;
+typedef array<Managed> TManagedArray;
+typedef array<ref Managed> TManagedRefArray;
+typedef array<vector> TVectorArray;
+typedef array<typename> TTypenameArray;
+
+class set<Class T>
+{
+	proto native int Count();
+	proto native void Clear();
+	/*!
+	Tries to find the first occurance of given value in the set.
+	\return Index of the first occurance of `value` if found, -1 otherwise
+	*/
+	proto int Find(T value);
+	proto T Get(int n);
+	/*!
+	Inserts element at the end of array.
+	\param value
+	Element to be inserted
+	\return
+	Position at which element is inserted
+	*/
+	proto int Insert(T value);
+	/*!
+	Inserts element at certain position and moves all elements behind
+	this position by one.
+	\param value
+	Element to be inserted
+	\param index
+	Position at which element is inserted. Must be less than Array::GetCardinality()
+	\return
+	Number of elements after insertion
+	*/
+	proto int InsertAt(T value, int index);
+	/*!
+	Removes element from array, but retain all elements ordered.
+	\param index
+	Index of element to be removed
+	*/
+	proto native void Remove(int index);
+	proto int Copy(set<T> from);
+	proto native void Swap(set<T> other);
+	proto int Init(T init[]);
+	
+	void InsertSet(set<T> other)
+	{
+		int count = other.Count();
+		for (int i = 0; i < count; i++)
+		{
+			T item = other[i];
+			Insert(item);
+		}
+	}
+	
+	void RemoveItem(T value)
+	{
+		int remove_index = Find(value);
+		if (remove_index >= 0)
+		{
+			Remove(remove_index);
+		}
+	}
+	
+	void RemoveItems(set<T> other)
+	{
+		int count = other.Count();
+		for (int i = 0; i < count; i++)
+		{
+			T item = other[i];
+			RemoveItem(item);
+		}
+	}
+	
+	void Debug()
+	{
+		Print(string.Format("Set count: %1", Count()));
+		for (int i = 0; i < Count(); i++)
+		{
+			T item = Get(i);
+			Print(string.Format("[%1] => %2", i, item));
+		}
+	}
+};
+
+//force these to compile so we can link C++ methods to them
+typedef set<string> TStringSet;
+typedef set<float> TFloatSet;
+typedef set<int> TIntSet;
+typedef set<Class> TClassSet;
+typedef set<Managed> TManagedSet;
+typedef set<ref Managed> TManagedRefSet;
+typedef set<typename> TTypenameSet;
+
+typedef int MapIterator;
+/**
+ \brief Associative array template
+ \n usage:
+ @code
+ autoptr map<string, int> prg_count = new map<string, int>;
+
+ // fill
+ project_locations.Insert("dayz", 10);
+ project_locations.Insert("arma", 20);
+ project_locations.Insert("tkom", 1);
+
+ Print(project_locations.Get("arma")); // prints '20'
+
+ @endcode
+
+ */
+class map<Class TKey,Class TValue>
+{
+	/*!
+		\return
+		The number of elements in the hashmap.
+	*/
+	proto native int Count();
+
+	/*!
+		Clears the hash map.
+	*/
+	proto native void Clear();
+	/*!
+		Search for an element with the given key.
+			
+		\param key
+		The key of the element to find
+		\return
+		Pointer to element data if found, NULL otherwise.
+	*/
+	proto TValue Get(TKey key);
+	/*!
+		Search for an element with the given key.
+			
+		\param key
+		The key of the element to find
+		\param val
+		result is stored to val
+		\return
+		returns True if given key exist.
+	*/
+	proto bool Find(TKey key, out TValue val);
+	/*!
+	Return the i:th element in the map.
+	Note: This operation is O(n) complexity. Use with care!
+
+	\param index
+	The position of the element in the map
+	\return
+	The element on the i:th position
+	*/
+	proto TValue GetElement(int index);
+	/*!
+	Return the i:th element key in the map.
+	Note: This operation is O(n) complexity. Use with care!
+
+	\param i
+	The position of the element key in the map
+	\return
+	Return key of i-th element
+	*/
+	proto TKey GetKey(int i);
+	/*!
+	Sets value of element with given key. If element with key not exists, it is created.
+	Note: creating new elements is faster using Insert function.
+	*/
+	proto void Set(TKey key, TValue value);
+	/*!
+	Removes element with given key.
+	*/
+	proto void Remove(TKey key);
+	/*!
+	Removes i:th element with given key.
+	Note: This operation is O(n) complexity. Use with care!
+	\param i
+	The position of the element key in the map
+	*/
+	proto void RemoveElement(int i);
+	/*!
+	Returns if map contains element with given key.
+	*/
+	proto bool Contains(TKey key);
+	/*!
+	Insert new element into hash map.
+		
+	\param key
+	Key of element to be inserted.
+	\param value
+	Data of element to be inserted.
+	*/
+	proto bool Insert(TKey key, TValue value);
+	proto int Copy(map<TKey,TValue> from);
+	
+	array<TKey> GetKeyArray()
+	{
+		array<TKey> keys = new array<TKey>;
+		for (int i = 0; i < Count(); i++)
+		{
+			keys.Insert( GetKey( i ) );
+		}
+		return keys;
+	}
+	
+	array<TValue> GetValueArray()
+	{
+		array<TValue> elements = new array<TValue>;
+		for (int i = 0; i < Count(); i++)
+		{
+			elements.Insert( GetElement( i ) );
+		}
+		return elements;
+	}
+	
+	bool ReplaceKey(TKey old_key, TKey new_key)
+	{
+		if (Contains(old_key))
+		{
+			Set(new_key, Get(old_key));
+			Remove(old_key);
+			return true;
+		}	
+		return false;
+	}
+	
+	TKey GetKeyByValue(TValue value)
+	{
+		TKey ret;
+		for (int i = 0; i < Count(); i++)
+		{
+			if (GetElement(i) == value) 
+			{
+				ret = GetKey(i);
+				break;
+			}
+		}
+
+		return ret;
+	}
+	
+	bool GetKeyByValueChecked(TValue value, out TKey key)
+	{
+		for (int i = 0; i < Count(); i++)
+		{
+			if (GetElement(i) == value) 
+			{
+				key = GetKey(i);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	proto native MapIterator Begin();
+	proto native MapIterator End();
+	proto native MapIterator Next(MapIterator it);
+	proto TKey GetIteratorKey(MapIterator it);
+	proto TValue GetIteratorElement(MapIterator it);
+};
+
+typedef map<int, float>				TIntFloatMap;
+typedef map<int, int>					TIntIntMap;
+typedef map<int, string>			TIntStringMap;
+typedef map<int, Class>				TIntClassMap;
+typedef map<int, Managed>			TIntManagedMap;
+typedef map<int, ref Managed>	TIntManagedRefMap;
+typedef map<int, typename>		TIntTypenameMap;
+typedef map<int, vector>			TIntVectorMap;
+
+typedef map<string, float>		TStringFloatMap;
+typedef map<string, int>			TStringIntMap;
+typedef map<string, string>		TStringStringMap;
+typedef map<string, Class>		TStringClassMap;
+typedef map<string, Managed>	TStringManagedMap;
+typedef map<string, ref Managed>	TStringManagedRefMap;
+typedef map<string, typename>	TStringTypenameMap;
+typedef map<string, vector>		TStringVectorMap;
+
+typedef map<Class, float>		TClassFloatMap;
+typedef map<Class, int>			TClassIntMap;
+typedef map<Class, string>		TClassStringMap;
+typedef map<Class, Class>		TClassClassMap;
+typedef map<Class, Managed>		TClassManagedMap;
+typedef map<Class, ref Managed>		TClassManagedRefMap;	
+typedef map<Class, typename>	TClassTypenameMap;
+typedef map<Class, vector>		TClassVectorMap;
+
+typedef map<typename, float>		TTypeNameFloatMap;
+typedef map<typename, int>			TTypeNameIntMap;
+typedef map<typename, string>		TTypeNameStringMap;
+typedef map<typename, Class>		TTypeNameClassMap;
+typedef map<typename, Managed>		TTypeNameManagedMap;
+typedef map<typename, ref Managed>	TTypeNameManagedRefMap;
+typedef map<typename, typename>		TTypeNameTypenameMap;
+typedef map<typename, vector>		TTypeNameVectorMap;
+
+typedef map<Managed, float>		TManagedFloatMap;
+typedef map<Managed, int>		TManagedIntMap;
+typedef map<Managed, string>	TManagedStringMap;
+typedef map<Managed, Class>		TManagedClassMap;
+typedef map<Managed, Managed>	TManagedManagedMap;
+typedef map<Managed, ref Managed>	TManagedManagedRefMap;
+typedef map<Managed, typename>	TManagedTypenameMap;
+typedef map<Managed, vector>	TManagedVectorMap;
+
+typedef map<ref Managed, float>	TManagedRefFloatMap;
+typedef map<ref Managed, int>		TManagedRefIntMap;
+typedef map<ref Managed, string>	TManagedRefStringMap;
+typedef map<ref Managed, Class>		TManagedRefClassMap;
+typedef map<ref Managed, Managed>	TManagedRefManagedMap;
+typedef map<ref Managed, ref Managed>	TManagedRefManagedRefMap;
+typedef map<ref Managed, typename>	TManagedRefTypenameMap;
+typedef map<ref Managed, vector>	TManagedRefVectorMap;
+
+ //@}

scripts/1_Core/DayZ/proto/EnString.c

@@ -0,0 +1,529 @@
+/**
+ * \defgroup Strings Strings
+ * @{
+ */
+class string
+{
+	static const string Empty;
+			
+	/**
+	\brief Converts string to integer
+		\return \p int - Converted \p string.
+		@code
+			string str = "56";
+			int i = str.ToInt();
+			Print(i);
+
+			>> i = 56
+		@endcode
+	*/
+	proto native int ToInt();
+	
+	/**
+	\brief Converts string to integer
+		\return \p int - Converted \p string.
+		@code
+			string str = "0xFF";
+			int i = str.HexToInt();
+			Print(i);
+
+			>> i = 255
+		@endcode
+	*/
+	proto native int HexToInt();
+	
+	/**
+	\brief Converts string to float
+		\return \p float - Converted \p string \p in float.
+		@code
+			string str = "56.6";
+			float f = str.ToFloat();
+			Print(f);
+
+			>> f = 56.6
+		@endcode
+	*/
+	proto native float ToFloat();
+			
+	/**
+	\brief Returns a vector from a string
+		\return \p vector Converted s as vector
+		@code
+			string str = "1 0 1";
+			vector v = str.ToVector();
+			Print(v);
+
+			>> v = <1,0,1>
+		@endcode
+	*/
+	proto vector ToVector();
+		
+	
+	/**
+	\brief Convert beautified string into a vector
+	    \param vec \p beautified string
+		\return \p vector resulting vector
+	*/
+	vector BeautifiedToVector()
+	{
+		string copy = value;
+		copy.Replace("<", "");
+		copy.Replace(">", "");
+		copy.Replace(",", " ");
+		return copy.ToVector();
+	}
+	/**
+	\brief Converts string's first character to ASCII code
+		\param str String for convert to ASCII code
+		\return \p ascii code \p int.
+		@code
+			int ascii = "M".ToAscii();
+			Print(ascii);
+
+			>> ascii = 77
+		@endcode
+	*/
+	proto native int ToAscii();
+	
+	/**
+	\brief Returns internal type representation. Can be used in runtime, or cached in variables and used for faster inheritance checking
+		\returns \p typename Type of class
+		@code
+			???
+		@endcode
+	*/
+	proto native typename ToType();
+
+	//! Return string representation of variable
+	static proto string ToString(void var, bool type = false, bool name = false, bool quotes = true);
+	
+	/**
+	\brief Substring of 'str' from 'start' position 'len' number of characters
+		\param start Position in \p str
+		\param len Count of characters
+		\return \p string - Substring of \p str
+		@code
+			string str = "Hello World";
+			string strSub = str.Substring(2, 5);
+			Print(strSub);
+
+			>> strSub = llo W
+		@endcode
+	*/
+	proto string Substring(int start, int len);
+	
+	//! Inverted SubString. This deletes everything in between position_start and position_end.
+	string SubstringInverted( string string_to_split, int position_start, int position_end )
+	{
+		string first_half = string_to_split.Substring(0, position_start);
+		string second_half = string_to_split.Substring( position_end, string_to_split.Length() - position_end );
+		string result = first_half + second_half;
+		return result;
+	}
+	
+	/**
+	\brief Substring of 'str' from 'startChar' position 'len' number of characters for UTF8 strings with multibyte chars
+		\param startChar Position in \p str.
+		\param len Count of characters
+		\return \p string - Substring of \p str with \p startChar character and \p len characters
+		@code
+			string str = "こんにちは世界";
+			string strSub = str.SubstringUtf8(2, 4);
+			Print(strSub);
+
+			>> strSub = にちは世
+		@endcode
+	*/
+	proto string SubstringUtf8(int startChar, int len);
+
+	/**
+	\brief Replace all occurrances of 'sample' in 'str' by 'replace'
+		\param sample string to search in \p str
+		\param replace string which replace \p sample in \p str
+		\return \p int - number of occurrances of 'sample' in 'str' 
+		@code
+		string test = "If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.";
+		Print(test);
+		int count = test.Replace("the", "*");
+		Print(count);
+		Print(test);
+
+		>> string test = 'If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.';
+		>> int count =   4
+		>> string test = 'If * length of * C string in source is less than num, only * content up to * terminating null-character is copied.'
+		@endcode
+	*/
+	proto int Replace(string sample, string replace);
+
+	/**
+	\brief Changes string to lowercase. Returns length
+		\return \p int - Length of changed string
+		@code
+			string str = "Hello World";
+			int i = str.ToLower();
+			Print(str);
+			Print(i);
+
+			>> str = hello world
+			>> i = 11
+		@endcode
+	*/
+	proto int ToLower();
+
+	/**
+	\brief Changes string to uppercase. Returns length
+		\return \p int - Length of changed string
+		@code
+			string str = "Hello World";
+			int i = str.ToUpper();
+			Print(str);
+			Print(i);
+
+			>> str = HELLO WORLD
+			>> i = 11
+		@endcode
+	*/
+	proto int ToUpper();
+
+	/**
+	\brief Returns length of string
+		\return \p int - Length of string
+		@code
+			string str = "Hello World";
+			int i = str.Length();
+			Print(i);
+
+			>> i = 11
+		@endcode
+	*/
+	proto native int Length();
+	
+	/**
+	\brief Returns number of characters in UTF8 string
+		\return \p int - Number of characters in UTF8 string
+		@code
+			string str = "こんにちは世界";
+			int i = str.LengthUtf8();
+			Print(i);
+
+			>> i = 7
+		@endcode
+	*/
+	proto native int LengthUtf8();
+
+	/**
+	\brief Returns hash of string
+		\return \p int - Hash of string
+		@code
+			string str = "Hello World";
+			int hash = str.Hash();
+			Print(hash);
+		@endcode
+	*/
+	proto native int Hash();
+	
+	/**
+	\brief Finds 'sample' in 'str'. Returns -1 when not found
+		\param sample \p string Finding string
+		\return \p int - Returns position where \p sample starts, or -1 when \p sample not found
+		@code
+			string str = "Hello World";
+			Print( str.IndexOf( "H" ) );
+			Print( str.IndexOf( "W" ) );
+			Print( str.IndexOf( "Q" ) );
+
+			>> 0
+			>> 6
+			>> -1
+		@endcode
+	*/
+	proto native int IndexOf(string sample);
+	
+	/**
+	\brief Finds last 'sample' in 'str'. Returns -1 when not found
+		\param sample \p string Finding string
+		\return \p int - Returns position where \p sample starts, or -1 when \p sample not found
+		@code
+			string str = "Hello World";
+			Print( str.IndexOf( "l" ) );
+			
+			>> 9
+		@endcode
+	*/
+	proto native int LastIndexOf(string sample);
+
+	/**
+	\brief Finds 'sample' in 'str' from 'start' position. Returns -1 when not found
+		\param start \p int Start from position
+		\param sample \p string Finding string expression
+		\return \p int - Length of string \p s
+		@code
+			string str = "Hello World";
+			Print( str.IndexOfFrom( 3, "H" ) );
+			Print( str.IndexOfFrom( 3, "W" ) );
+			Print( str.IndexOfFrom( 3, "Q" ) );
+
+			>> -1
+			>> 6
+			>> -1
+		@endcode
+	*/
+	proto native int IndexOfFrom(int start, string sample);
+
+	/**
+	\brief Returns true if sample is substring of string
+		\param sample \p string Finding string expression
+		\return \p bool true if sample is substring of string
+		@code
+			string str = "Hello World";
+			Print( str.IndexOfFrom( 3, "Hello" ) );
+			Print( str.IndexOfFrom( 3, "Mexico" ) );
+			
+			>> true
+			>> false
+		@endcode
+	*/
+	bool Contains(string sample)
+	{
+		return value.IndexOf(sample) != -1;
+	}
+
+	/**
+	\brief Returns trimmed string with removed leading and trailing whitespaces
+		\return \p string - Trimmed string
+		@code
+			string str = " Hello World "
+			Print( str );
+			Print( str.Trim() );
+
+			>> ' Hello World '
+			>> 'Hello World'
+		@endcode
+
+	*/
+	proto string Trim();
+
+	/**
+	\brief Removes leading and trailing whitespaces in string. Returns length
+		\return \p int - Count of chars
+		@code
+			string str = " Hello World ";
+			int i = str.TrimInPlace();
+			Print(str);
+			Print(i);
+
+			>> str = 'Hello World'
+			>> i = 11
+		@endcode
+	*/
+	proto int TrimInPlace();
+	
+	/**
+	\brief Parses one token from input string. Result is put into token string, and type of token is returned. Input string is left-truncated by the resulting token length.
+		\param[out] token \p string Founded string token
+		\return \p int Type of token
+		\verbatim
+	Token types:
+	 0 - error, no token
+	 1 - defined token (special characters etc. . / * )
+	 2 - quoted string. Quotes are removed -> TODO
+	 3 - alphabetic string
+	 4 - number
+	 5 - end of line -> TODO
+		\endverbatim
+		@code
+			string input = "Hello*World";
+			string token1;
+			string token2;
+
+			int result1 = input.ParseStringEx(token1);
+			int result2 = input.ParseStringEx(token2);
+
+			Print( "Token1 = '" + token1 + "' Type = " + result1.ToString() ) );
+			Print( "Token2 = '" + token2 + "' Type = " + result2.ToString() ) );
+			
+			>> 'Toke1 = 'Hello' Type = 3'
+			>> 'Toke1 = '*' Type = 1'
+		@endcode
+	*/
+	proto int ParseStringEx(out string token);
+
+	/**
+	\brief Parses string into array of tokens returns number of tokens
+		\param[out] tokens \p array[] Parsed string in array
+		\return \p int Number of tokens
+		@code
+			string token[2];
+			string str = "Hello World";
+			int result = str.ParseString(token);
+
+			for (int i = 0; i < 2; i++)
+			{
+				Print(token[i]);
+			}
+
+			>> 'Hello'
+			>> 'World'
+		@endcode
+	*/
+	proto int ParseString(out string tokens[]);
+	
+	/**
+	\brief Splits string into array of strings separated by 'sample'
+		\param sample \p string Strings separator
+		\return \p TStringArray Array with strings
+		@code
+			string example = "The quick brown fox jumps over the lazy dog";
+			TStringArray strs = new TStringArray;
+			example.Split(" ", strs);
+			
+			for (int i = 0; i < strs.Count(); i++)
+			{
+				Print(strs.Get(i));
+			}
+
+			>> 'The'
+			>> 'quick'
+			>> 'brown'
+			>> 'fox'
+			>> 'jumps'
+			>> 'over'
+			>> 'the'
+			>> 'lazy'
+			>> 'dog'
+		@endcode
+	*/
+	void Split(string sample, out array<string> output)
+	{
+		int txt_len	= 0;
+		int sep_pos	= -1;
+		int nxt_sep_pos = 0;
+		string text = "";
+
+		bool line_end = false;
+		while (line_end == false)
+		{
+			sep_pos = sep_pos + txt_len + 1;
+			nxt_sep_pos = value.IndexOfFrom(sep_pos, sample);
+			if ( nxt_sep_pos == -1 )
+			{
+				nxt_sep_pos = value.Length();
+				line_end = true;
+			}
+
+			txt_len = nxt_sep_pos - sep_pos;
+			if ( txt_len > 0 )
+			{
+				text = value.Substring(sep_pos, txt_len);
+				output.Insert(text);
+			}
+		}
+	}
+
+	// !Joins array of strings into a single string, separated by 'separator'. Inverse of Split
+	static string Join(string separator, notnull TStringArray tokens)
+	{
+		string output;
+		foreach (int i, string s: tokens)
+		{
+			if (i != 0)
+				output += separator;
+			output += s;
+		}
+		return output;
+	}
+
+	/**
+	\brief Gets n-th character from string
+		\param index character index
+		\return \p string character on index-th position in string
+		\warning VME When index less than 0 or greater than string length  
+		@code
+			string str = "Hello World";
+			Print( str[4] ); // Print( str.Get(4) );
+
+			>> 'o'
+		@endcode
+	*/ 			
+	proto string Get(int index);
+	
+	/**
+	\brief Sets the n-th character in string with the input, replacing previous value
+		\param index index to be replaced
+		\param input single non-terminated character value to replace with
+		\warning VME When index less than 0 or greater than string length  
+		\warning (Diag)		VME When string is empty or greater than length of 1
+				 (Retail)	Calls 'string.Insert' except it replaces only the initial character
+		@code
+			string str = "Hello World";
+			str[4] = "O";
+			Print( str );
+	
+			>> 'HellO World'
+		@endcode
+		
+		@code
+			string str = "Hello World";
+			str[6] = "Test ";
+			Print( str );
+	
+			>> 'Hello Test orld'
+		@endcode
+	*/ 
+	proto void Set(int index, string input);
+
+#ifdef DIAG_DEVELOPER
+	/**
+	\brief Do not use. Re-implemented for verification of new function due to design of previous function allowing for unexpected behavior that modders may depend on.
+		\see string.Set warnings for handling existing mods in Retail 
+		@code
+			string str = "Hello World";
+			str.OldSet(6, "Test ");
+			Print( str );
+	
+			>> 'Hello Test orld'
+		@endcode
+	 */
+	void OldSet(int n, string _value)
+	{
+		string pre = value.Substring(0, n);
+		n += 1;
+		int length = value.Length() - n;
+		string post = value.Substring(n, length);
+		value = pre + _value + post;
+	}
+#endif
+	
+	/**
+	\brief Inserts a string into the n-th index, increasing the string length by the size of the input
+		\param index index to insert at
+		\param input string value to insert with
+		\warning VME When index less than 0 or greater than string length  
+		\warning VME When string is empty
+		@code
+			string str = "Hello World";
+			str.Insert(6, "Test ");
+			Print( str );
+	
+			>> 'Hello Test World'
+		@endcode
+	*/ 
+	proto void Insert(int index, string input);
+	
+	/**
+	\brief Gets n-th character from string
+		\param index character index
+		\return \p string character on index-th position in string
+		@code
+		int a = 5;
+		float b = 5.99;
+		string c = "beta";
+		string 	test = string.Format("Ahoj %1 = %3 , %2", a, b, c);
+		Print(test);	
+		>> 'Ahoj 5 = 'beta' , 5.99'
+		@endcode
+	*/ 			
+	static proto string Format(string fmt, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+};
+
+//@}

scripts/1_Core/DayZ/proto/EnSystem.c

@@ -0,0 +1,534 @@
+/**
+ * \defgroup System System
+ * @{
+ */
+
+/**
+\brief Returns world time
+	\param[out] hour \p int Hour
+	\param[out] minute \p int Minute
+	\param[out] second \p int Second
+	\return \p void
+	@code
+		int hour = 0;
+		int minute = 0;
+		int second = 0;
+
+		GetHourMinuteSecondUTC(hour, minute, second);
+
+		Print(hour);
+		Print(minute);
+		Print(second);
+
+		>> hour = 16
+		>> minute = 38
+		>> second = 7
+	@endcode
+*/
+proto void GetHourMinuteSecond(out int hour, out int minute, out int second);
+
+/**
+\brief Returns world date
+	\param[out] year \p int Year
+	\param[out] month \p int Month
+	\param[out] day \p int Day
+	\return \p void
+	@code
+		int year = 0;
+		int month = 0;
+		int day = 0;
+
+		GetYearMonthDay(year, month, day);
+
+		Print(year);
+		Print(month);
+		Print(day);
+
+		>> year = 2015
+		>> month = 3
+		>> day = 24
+	@endcode
+*/
+proto void GetYearMonthDay(out int year, out int month, out int day);
+
+/**
+\brief Returns UTC world time
+	\param[out] hour \p int Hour
+	\param[out] minute \p int Minute
+	\param[out] second \p int Second
+	\return \p void
+	@code
+		int hour = 0;
+		int minute = 0;
+		int second = 0;
+
+		GetHourMinuteSecondUTC(hour, minute, second);
+
+		Print(hour);
+		Print(minute);
+		Print(second);
+
+		>> hour = 15
+		>> minute = 38
+		>> second = 7
+	@endcode
+*/
+proto void GetHourMinuteSecondUTC(out int hour, out int minute, out int second);
+
+/**
+\brief Returns UTC world date
+	\param[out] year \p int Year
+	\param[out] month \p int Month
+	\param[out] day \p int Day
+	\return \p void
+	@code
+		int year = 0;
+		int month = 0;
+		int day = 0;
+
+		GetYearMonthDayUTC(year, month, day);
+
+		Print(year);
+		Print(month);
+		Print(day);
+
+		>> year = 2015
+		>> month = 3
+		>> day = 24
+	@endcode
+*/
+proto void GetYearMonthDayUTC(out int year, out int month, out int day);
+
+proto string GetProfileName();
+proto string GetMachineName();
+
+//! performance counter. Returns number of CPU ticks between 'prev' and 'now'
+proto native int TickCount(int prev);
+
+/**
+\brief Switches memory validation (huge slowdown! Use with care only for certain section of code!)
+	\param enable \p bool Enable
+	\return \p void
+	@code
+		???
+	@endcode
+*/
+proto native void MemoryValidation(bool enable);
+
+/**
+\brief Returns command line argument
+	\param name of a command line argument
+	\param val \p string value of the param or empty string if the param hasn't been found
+	\return True if param is present, False if hasn't been found
+	@code
+		string param;
+		GetCLIParam("world", param); // return a value when program executed with param -world something
+	@endcode
+*/
+proto bool GetCLIParam(string param, out string val);	
+	
+/**
+\brief Returns if command line argument is present
+	\param name of a command line argument
+	\return True if param is present, False if hasn't been found
+	@code
+		if (IsCLIParam("verbose")) // Prints "something" when program executed with param -verbose
+		{ 
+			Print("something");
+		}
+	@endcode
+*/
+proto native bool IsCLIParam(string param);		
+	
+#ifdef ENF_DONE
+
+//! developer tool - start video grabber
+proto native void StartVideo(string name);
+//! developer tool - stop video grabber
+proto native void StopVideo();
+#endif
+
+
+/**
+ * \defgroup Keyboard Keyboard input API
+ * @{
+ */
+enum KeyCode
+{
+	KC_ESCAPE,
+	KC_1,
+	KC_2,
+	KC_3,
+	KC_4,
+	KC_5,
+	KC_6,
+	KC_7,
+	KC_8,
+	KC_9,
+	KC_0,
+	KC_MINUS,   ///< - on main keyboard 
+	KC_EQUALS,
+	KC_BACK,    ///< backspace 
+	KC_TAB,
+	KC_Q,
+	KC_W,
+	KC_E,
+	KC_R,
+	KC_T,
+	KC_Y,
+	KC_U,
+	KC_I,
+	KC_O,
+	KC_P,
+	KC_LBRACKET,
+	KC_RBRACKET,
+	KC_RETURN,   ///< Enter on main keyboard 
+	KC_LCONTROL,
+	KC_A,
+	KC_S,
+	KC_D,
+	KC_F,
+	KC_G,
+	KC_H,
+	KC_J,
+	KC_K,
+	KC_L,
+	KC_SEMICOLON,
+	KC_APOSTROPHE,
+	KC_GRAVE,    ///< accent grave 
+	KC_LSHIFT,
+	KC_BACKSLASH,
+	KC_Z,
+	KC_X,
+	KC_C,
+	KC_V,
+	KC_B,
+	KC_N,
+	KC_M,
+	KC_COMMA,
+	KC_PERIOD,   ///< . on main keyboard 
+	KC_SLASH,    ///< / on main keyboard 
+	KC_RSHIFT,
+	KC_MULTIPLY,    ///< * on numeric keypad 
+	KC_LMENU,    ///< left Alt 
+	KC_SPACE,
+	KC_CAPITAL,
+	KC_F1,
+	KC_F2,
+	KC_F3,
+	KC_F4,
+	KC_F5,
+	KC_F6,
+	KC_F7,
+	KC_F8,
+	KC_F9,
+	KC_F10,
+	KC_NUMLOCK,
+	KC_SCROLL,    ///< Scroll Lock 
+	KC_NUMPAD7,
+	KC_NUMPAD8,
+	KC_NUMPAD9,
+	KC_SUBTRACT,    ///< - on numeric keypad 
+	KC_NUMPAD4,
+	KC_NUMPAD5,
+	KC_NUMPAD6,
+	KC_ADD,    ///< + on numeric keypad 
+	KC_NUMPAD1,
+	KC_NUMPAD2,
+	KC_NUMPAD3,
+	KC_NUMPAD0,
+	KC_DECIMAL,   ///< . on numeric keypad 
+	KC_OEM_102,    ///< < > | on UK/Germany keyboards 
+	KC_F11,
+	KC_F12,
+	KC_NUMPADEQUALS,    ///< = on numeric keypad (NEC PC98) 
+	KC_PREVTRACK,    ///< Previous Track (DIKC_CIRCUMFLEX on Japanese keyboard) 
+	KC_AT,    ///<                     (NEC PC98) 
+	KC_COLON,    ///<                     (NEC PC98) 
+	KC_UNDERLINE,    ///<                     (NEC PC98) 
+	KC_STOP,    ///<                     (NEC PC98) 
+	KC_AX,    ///<                     (Japan AX) 
+	KC_UNLABELED,    ///<                        (J3100) 
+	KC_NEXTTRACK,    ///< Next Track 
+	KC_NUMPADENTER,    ///< Enter on numeric keypad 
+	KC_RCONTROL,
+	KC_MUTE,    ///< Mute 
+	KC_CALCULATOR,    ///< Calculator 
+	KC_PLAYPAUSE,    ///< Play / Pause 
+	KC_MEDIASTOP,    ///< Media Stop 
+	KC_VOLUMEDOWN,    ///< Volume - 
+	KC_VOLUMEUP,    ///< Volume + 
+	KC_WEBHOME,    ///< Web home 
+	KC_NUMPADCOMMA,    ///< , on numeric keypad (NEC PC98) 
+	KC_DIVIDE,    ///< / on numeric keypad 
+	KC_SYSRQ,
+	KC_RMENU,    ///< right Alt 
+	KC_PAUSE,    ///< Pause 
+	KC_HOME,    ///< Home on arrow keypad 
+	KC_UP,    ///< UpArrow on arrow keypad 
+	KC_PRIOR,    ///< PgUp on arrow keypad 
+	KC_LEFT,    ///< LeftArrow on arrow keypad 
+	KC_RIGHT,    ///< RightArrow on arrow keypad 
+	KC_END,    ///< End on arrow keypad 
+	KC_DOWN,    ///< DownArrow on arrow keypad 
+	KC_NEXT,    ///< PgDn on arrow keypad 
+	KC_INSERT,    ///< Insert on arrow keypad 
+	KC_DELETE,    ///< Delete on arrow keypad 
+	KC_LWIN,    ///< Left Windows key 
+	KC_RWIN,    ///< Right Windows key 
+	KC_APPS,    ///< AppMenu key 
+	KC_POWER,    ///< System Power 
+	KC_SLEEP,    ///< System Sleep 
+	KC_WAKE,    ///< System Wake 
+	KC_MEDIASELECT   ///< Media Select 
+};
+
+/*!
+Gets key state
+\param key	Key code
+\returns 0 when not pressed, 15. bit set when pressed, 0.-14. bit pressed count 
+*/
+proto native int KeyState(KeyCode key);
+
+/*!
+Clears the key state.
+Call this function if you want to overcome autorepeating in reporting key state. If called, the KeyState returns pressed only after the key is released and pressed again.
+*/
+proto native void ClearKey(KeyCode key);
+/** @}*/
+
+//! returns index of defined key in InputDevice by its name
+//proto native int GetDefKey(string name);
+//proto native int DefKeyState(int defkey, bool clear);
+
+
+/**
+ * \defgroup Mouse Mouse API
+ * @{
+ */
+
+enum MouseState
+{
+	LEFT,
+	RIGHT,
+	MIDDLE,
+	X,
+	Y,
+	WHEEL
+};
+//const int MB_PRESSED_MASK
+
+/*!
+Returns state of mouse button. It's combination of number of release/pressed edges and mask MB_PRESSED_MASK
+that is set when button is pressed.
+If you want just to check if button is pressed, use this: if(GetMouseState(MouseState.LEFT) & MB_PRESSED_MASK)) Print("left button pressed");
+*/	
+proto native int GetMouseState(MouseState index);
+
+// Gets current mouse position
+proto void GetMousePos(out int x, out int y);
+// Gets current screen size (resolution)
+proto void GetScreenSize(out int x, out int y);
+
+/** @}*/
+
+/**
+ * \defgroup Gamepad API
+ * @{
+ */
+
+enum GamepadButton
+{
+	BUTTON_NONE,
+	MENU,
+	VIEW,
+	A,
+	B,
+	X,
+	Y,
+	PAD_UP,
+	PAD_DOWN,
+	PAD_LEFT,
+	PAD_RIGHT,
+	SHOULDER_LEFT,
+	SHOULDER_RIGHT,
+	THUMB_LEFT,
+	THUMB_RIGHT
+};
+
+enum GamepadAxis
+{
+	LEFT_THUMB_HORIZONTAL,
+	LEFT_THUMB_VERTICAL,
+	RIGHT_THUMB_HORIZONTAL,
+	RIGHT_THUMB_VERTICAL,
+	LEFT_TRIGGER,
+	RIGHT_TRIGGER,
+};
+
+//! return if the button is pressed or not
+proto native int GetGamepadButton(GamepadButton button);
+//! return value in gamepad axis <-1000; 1000>
+proto native float GetGamepadAxis(GamepadAxis axis);
+
+/** @}*/
+
+//----------------------------------------------
+/**
+ * \defgroup File FileIO API
+ * @{
+ */
+
+enum FileMode
+{
+	READ,
+	WRITE,
+	APPEND
+};
+	
+typedef int[] ParseHandle;
+typedef int[] FileHandle;
+
+proto native ParseHandle BeginParse(string filename);
+proto int ParseLine(ParseHandle tp, int num, string tokens[]);
+proto native void EndParse(ParseHandle file);
+
+//!Check existence of file
+proto bool FileExist(string name);
+
+/**
+\brief Opens File
+	@param name of a file to open, (you can use filesystem prefixes ('$profile','$saves','$mission'). For accessing profile dir use '$profile', e.g. '$profile:myfilename.txt')
+	@param mode constants FileMode.WRITE, FileMode.READ or FileMode.APPEND flag can be used
+	\return file handle ID or 0 if fails
+	\n usage :
+	@code
+	FileHandle file = OpenFile("$profile:testiik.txt", FileMode.WRITE);
+	//FileHandle file = OpenFile("$profile:testiik.txt", FileMode.APPEND);
+	if (file != 0)
+	{
+		FPrintln(file, "line1");
+		FPrintln(file, "line2");
+		FPrintln(file, "line3");
+		CloseFile(file);
+	}
+	@endcode
+*/
+proto FileHandle		OpenFile(string name, FileMode mode);
+
+/**
+Reads raw data from file.
+\param param_array Receiving array for the data. Valid types are int[] or string
+\param length Length of data
+\returns number of read bytes
+*/
+proto int ReadFile(FileHandle file, void param_array, int length);
+
+/**
+\brief Close the File
+	@param file File handle ID of a opened file
+	\return void
+	\n usage :
+	@code
+	FileHandle file = OpenFile("$profile:testiik.txt", FileMode.WRITE);
+	if (file != 0)
+	{
+		FPrintln(file, "line1");
+		FPrintln(file, "line2");
+		FPrintln(file, "line3");
+		CloseFile(file);
+	}
+	@endcode
+*/
+proto void		CloseFile(FileHandle file);
+
+/**
+\brief Write to file
+	@param file File handle ID of a opened file
+	@param var Value to write
+	\return void
+	\n usage :
+	@code
+	FileHandle file = OpenFile("$profile:testiik.txt", FileMode.WRITE);
+	if (file != 0)
+	{
+		FPrint(file, "A");
+		FPrint(file, "B");
+		FPrint(file, "C");
+		CloseFile(file);
+	}
+	@endcode
+*/
+proto void		FPrint(FileHandle file, void var);
+
+/**
+\brief Write to file and add new line
+	@param file File handle ID of a opened file
+	@param var Value to write
+	\return void
+	\n usage :
+	@code
+	FileHandle file = OpenFile("$profile:testiik.txt", FileMode.WRITE);
+	if (file != 0)
+	{
+		FPrintln(file, "line1");
+		FPrintln(file, "line2");
+		FPrintln(file, "line3");
+		CloseFile(file);
+	}
+	@endcode
+*/
+proto void		FPrintln(FileHandle file, void var);
+
+/**
+\brief Get line from file, every next call of this function returns next line
+	@param file File handle ID of a opened file
+	@param var Value to write
+	\return int Count of chars or -1 if is not any for read (end of file is EMPTY line)
+	\n usage :
+	@code
+		FileHandle file_handle = OpenFile("$profile:testiik.txt", FileMode.READ);
+		string line_content;
+
+		while ( FGets( file_handle,  line_content ) > 0 )
+		{
+			Print(line_content);
+		}
+
+		CloseFile(file_handle);
+	@endcode
+*/
+proto int		FGets(FileHandle file, string var);
+
+typedef int[] FindFileHandle;
+
+enum FileAttr
+{
+	DIRECTORY, ///<File is directory
+	HIDDEN, ///<File is hidden
+	READONLY, ///<File is read-only
+	INVALID ///<Invalid file
+};
+
+enum FindFileFlags
+{
+	DIRECTORIES, ///<Looks for files in fs directories only.
+	ARCHIVES,	///<Looks for files in archive only. (.pak)
+	ALL ///<Looks in archives and fs directories.
+}
+
+proto FindFileHandle FindFile(string pattern, out string fileName, out FileAttr fileAttributes, FindFileFlags flags);
+proto bool FindNextFile(FindFileHandle handle, out string fileName, out FileAttr fileAttributes);
+proto native void CloseFindFile(FindFileHandle handle);
+
+//!Makes a directory
+proto native bool MakeDirectory(string name);
+
+//!delete file. Works only on "$profile:" and "$saves:" locations
+proto native bool DeleteFile(string name);
+
+//! copy file. destName must be "$profile:" or "$saves:" location
+proto native bool CopyFile(string sourceName, string destName);
+/** @}*/
+
+ //@}

scripts/1_Core/DayZ/proto/EnVRDevice.c

@@ -0,0 +1,281 @@
+#ifdef GAME_TEMPLATE
+
+/**
+* \defgroup VRDeviceAPI generic and platform specific devices
+* @{
+*/
+
+enum VRDeviceType
+{
+	DEVICE_TYPE_OCULUS,
+	DEVICE_TYPE_PS4
+}
+
+enum VRStatus
+{
+	VR_STATUS_UNKNOWN,					//< Unknown state, probably uninitialized.
+	VR_STATUS_VISIBLE,					//< The HMD is being used for rendering.
+	VR_STATUS_PRESENT,					//< The HMD port is open.
+	VR_STATUS_MOUNTED,					//<	The HMD is mounted on users head.
+	VR_STATUS_DISPLAY_LOST,			//< The HMD was present and disappeared.
+	VR_STATUS_SHOULD_QUIT,			//< Application requested exit.
+	VR_STATUS_SHOULD_RECENTER,	//< The HMD Recenter request event was triggered. 
+	VR_STATUS_TRACKED,					//< The tracking data for the HMD are up to date.
+	VR_STATUS_CALIBRATING,			//< The HMD is being calibrated.
+}
+
+enum VRHandEnum
+{
+	VR_HAND_LEFT, //< HMD controller left hand.
+	VR_HAND_RIGHT //< HMD controller right hand.
+}
+
+enum VREye
+{
+	VR_EYE_LEFT, // HMD left eye.
+	VR_EYE_RIGHT // HMD right eye.
+}
+
+/*!
+	VRDevice interface common for all VR implementations.
+
+	DO NOT INHERIT FROM THIS CLASS!
+*/
+class VRDevice : Managed
+{
+	/*!
+		\brief returns VRDevice instance.
+		\return device instance.
+	*/
+	proto native static VRDevice GetInstance();
+
+	/*!
+		\brief returns status flags.
+
+		\return current device state flags.
+	*/
+	proto native VRStatus 				GetStatusFlags();
+	/*!
+		\brief returns device name.
+		\return device brand name.
+	*/
+	proto native owned string	GetName();
+	/*!
+		\brief returns device type. 
+		\return device type enum.
+	*/
+	proto native VRDeviceType GetDeviceType();
+	/*!
+		\brief Forces immediate head recenter.
+
+		Uses the current scene position and orientation
+		as the new camera origin.
+	*/
+	proto native void 								RecenterHeadTracking();
+	/*!
+		\brief returns HMD head position .
+		\return position in world space.
+	*/
+	proto native vector 						GetHeadPosition();
+	/*!
+		\brief returns HMD head orientation. 
+		\return Euler angles in device space. (Yaw, Pitch, Roll)
+	*/
+	proto native vector 						GetHeadOrientation();
+	/*!
+		\brief returns HMD controller's position.
+
+		\param hand left/right hand enum.
+		\return position in world space.
+	*/
+	proto native vector 						GetHandPosition(VRHand hand);
+	/*!
+		\brief returns HMD controller's orientation.
+
+		\param hand left/right hand enum.
+		\return Euler angles in device space. (Yaw, Pitch, Roll)
+	*/
+	proto native vector 						GetHandOrientation(VRHand hand);
+	/*!
+		\brief returns HMD Eye's position.
+
+		\param eye left/right eye enum.
+		\return position in world space.
+	*/
+	proto native vector 						GetEyePosition(VREye eye);
+	/*!
+		\brief returns HMD Eye's orientation.
+		
+		\param eye left/right eye enum.
+		\return Euler angles in device space. (Yaw, Pitch, Roll)
+	*/
+	proto native vector							GetEyeOrientation(VREye eye);
+	/*!
+		\brief Sets up current vr scale.
+		
+		All translations will get scaled by this value.
+		With higher scale values will the world around look smaller.
+
+		"Warning: The tracking errors will render more visible with high scale."
+		\param scale the scale amount.
+	*/
+	proto native void 								SetScale(float scale);
+	/*!
+		\brief returns current vr scale.
+		\return the scale amount. 
+	*/
+	proto native float 							GetScale();
+
+	/*!
+		\brief returns current FOV's tangent values.
+
+		In VR mode the FOV should be asymmetric.
+		\returns tangent values of asymetric FOV.
+	*/
+	proto external void 						GetEyeFOV(VREye eye, out float leftTan, out float rightTan, out float upTan, out float downTan);
+};
+
+enum PSVrHeadRecenterFlagsEnum
+{
+	VR_RECENTER_POSITION,
+	VR_RECENTER_ORIENTATION
+}
+
+enum PSVrBrightnessRiskEnum
+{
+	VR_BRIGHTNESS_RISK_LOW,
+	VR_BRIGHTNESS_RISK_HIGH,
+	VR_BRIGHTNESS_RISK_MAX
+}
+
+enum PSVrTrackingQualityEnum
+{
+	VR_TRACKING_QUALITY_NONE,
+	VR_TRACKING_QUALITY_NOT_VISIBLE,
+	VR_TRACKING_QUALITY_PARTIAL,
+	VR_TRACKING_QUALITY_FULL
+}
+
+enum PSVrDialogStatusEnum
+{
+	VR_DIALOG_UNKNOWN,
+	VR_DIALOG_OK,
+	VR_DIALOG_CANCELED,
+	VR_DIALOG_RUNNING	
+}
+
+/*!
+	PS4 specific VR interface.
+*/
+class VRDevice_PS4 : VRDevice
+{
+	/*!
+		\brief Switches VR device into 2D "theater" mode.
+
+		Don't forget to set appropriate FOV.
+
+		At the moment the device uses the render targets of the
+		left eye. These render targets are 8:9 and we are still rendering
+		both eyes. If the feature gets used in a actual gameplay we can
+		extend it to separate set of 16:9 render targets.
+
+		\param enabled enable/disable flag.
+	*/
+	proto native void Set2D(bool enabled);
+	/*!
+		\brief Pops up HMD service dialog.
+		\return true when dialog was opened and his state was resolved as OK.
+	*/
+	proto native bool ShowHmdServiceDialog();
+	/*!
+		\brief Pops up HMD setup dialog.
+		\return true when dialog was opened and closed successfully.
+	*/
+	proto native bool ShowHmdSetupDialog();
+	/*!
+		\brief Returns current setup dialog state.
+		\return dialog state enum.
+	*/
+	proto native PSVrDialogStatusEnum GetSetupDialogStatus();
+	/*!
+		\brief Returns current service dialog state.
+		\return dialog state enum.
+	*/
+	proto native PSVrDialogStatusEnum GetServiceDialogStatus();
+
+	/*!
+		\brief HMD recentering hint flags setup.
+	*/
+	proto native void SetRecenterHeadFlags(PSVrHeadRecenterFlagsEnum flags);
+	/*!
+		\brief Returns HMD recentering flags.
+		\return recentering enum.
+	*/
+	proto native PSVrHeadRecenterFlagsEnum GetRecenterHeadFlags();
+	/*!
+		\brief Returns the eye offset in device space.
+		\return 3D position centered around device space center.
+	*/
+	proto native vector GetEyeOffset(VREye eye);
+	/*!
+		\brief Sets up the minimal displayable color.
+
+		Setup this value when smears start appearing in 
+		dark environments.
+	*/
+	proto native void SetMinOutputColor(int color);
+	/*!
+		\brief Per eye FOV setup.
+
+		Keep in mind that changing the values from device presets
+		may cause user discomfort.
+	*/
+	proto native void SetEyeFOV(VREye eye, float leftTan, float rightTan, float upTan, float downTan);
+	/*!
+		\brief Resets the FOV settings to device preset value.
+	*/
+	proto native void ResetToDeviceFOV(VREye eye);
+	/*!
+		\brief Sets up the render target size multiplier.
+
+		Set this value before the device gets initialized.
+	*/
+	proto native void SetOversamplingFactor(float factor);
+	/*!
+		\brief Returns HMD tracking status.
+		\param bRisk tracked scene brightness risk.
+		\param posQuality precision of the HMD position.
+		\param orQuality precision of tthe HMD orientation.
+		\return false when the HMD port is not open.
+	*/
+	proto bool GetHmdTrackingStatus(	out PSVrBrightnessRiskEnum bRisk, 
+																		out PSVrTrackingQualityEnum posQuality, 
+																		out PSVrTrackingQualityEnum orQuality);
+	/*!
+		\brief Returns Move controller tracking status.
+
+		\param hand identifier of the contoller.
+		\param bRisk tracked scene brightness risk.
+		\param posQuality precision of the controllers position.
+		\param orQuality precision of the controllers orientation.
+		\return false when the Move port is not open.
+	*/
+	proto bool GetMoveTrackingStatus(	VRHand hand, 
+																						out PSVrBrightnessRiskEnum bRisk, 
+																						out PSVrTrackingQualityEnum posQuality, 
+																						out PSVrTrackingQualityEnum orQuality);
+}				
+
+/*!
+	Oculus specific VR interface.
+*/
+class Oculus : VRDevice
+{
+	// TODO:
+}
+
+/*
+* @}
+*/
+
+#endif

scripts/1_Core/DayZ/proto/EnVisual.c

@@ -0,0 +1,244 @@
+/**
+ * \defgroup Visual Visual objects
+ * @{
+ */
+
+//! Loads object from data, or gets it from cache. Object must be released when not used
+proto native vobject GetObject(string name);
+
+/*!
+Release object. When there are not any other references, object is stored into cache and ready to be victed if necessary.
+\param object Object handle
+\param flag If RF_RELEASE is used, the object is evicted immediatelly, if not used by anyone else
+*/
+proto native void ReleaseObject(vobject object, int flag = 0);
+
+//! Returns number of frames, if the object is animation
+proto native int GetNumAnimFrames(vobject anim);
+
+//! Returns name of visual object
+proto string vtoa(vobject vobj);
+
+/**
+ * \defgroup MeshObject Mesh object (XOB)
+ * @{
+ */
+
+proto int GetObjectMaterials(vobject object, string materials[]);
+
+// dynamic model creation (for dynamic aabb triggers)
+//proto void CreateModel(IEntity ent, vector mins, vector maxs);
+//proto void RemoveModel(IEntity ent);
+
+//! Dynamic MeshObject
+proto vobject CreateXOB(int nsurfaces, int nverts[], int numindices[], string materials[]);
+proto void UpdateVertsEx(notnull IEntity ent, int surf, vector verts[], float uv[]);
+proto void UpdateIndices(vobject obj, int surf, int indices[]);
+
+proto native void	SetBone(notnull IEntity ent, int bone, vector angles, vector trans, float scale);
+proto native bool	SetBoneMatrix(notnull IEntity ent, int bone, vector mat[4]);
+proto native void	SetBoneGlobal(notnull IEntity ent, int bone, vector mat[4]);
+proto native bool	GetBoneMatrix(notnull IEntity ent, int bone, vector mat[4]);
+proto native bool	GetBoneLocalMatrix(notnull IEntity ent, int bone, vector mat[4]);
+
+proto native void	SetAnimFrame(notnull IEntity ent, int slot, float frame);
+
+//! BoneMask == NULL means that all bits are set
+//! WARNING: Non-managed, needs manual delete call, should not be ref'd
+class BoneMask
+{
+	int Mask[8]
+}
+
+enum AnimFlags
+{
+	//! animation is played only once and then if freezes at the last frame. EntityEvent.ANIMEND is called
+	ONCE,
+/*! defaultne zustava animace pri prehravani a AF_ONCE po skonceni na posledni frame "zamrzla", dokud neni nahrazena jinou,
+ nebo neni kanal vynulovan. Pokud se nastavi AF_BLENDOUT, postara se engine o vyhozeni animace sam a pro preblendovani pouzije hodnotu
+ blendout. Pokud je odchycen EOnAnimEnd a byla zmenena animace na jinou, nebo byl kanal rucne vynulovan, tak se tato
+ funkcnost neprovede. */
+	BLENDOUT,
+
+//! animation waits on the first frame. Frame is set by calling SetFrame()
+	USER,
+
+//! forces animation to start from begining (including blending)
+	RESET,
+
+/*! defaul framerate is from anim.def. If it is missing, parametr fps applies
+It is possible to use fps parameter even when the framerate is defined in the anim.def, is using this flag
+*/
+	FORCEFPS,
+
+//! EntityEvent.ANIMEND will not be called
+	NOANIMEND,
+
+//! Animhooks will not be called
+	NOANIMHOOKS
+};
+
+proto native void	SetAnimSlot(notnull IEntity ent, int slot, vobject anim, float blendin, float blendout, BoneMask mask, int fps, AnimFlags flags);
+
+// changes a mask and does the blending if the blendin is set
+proto native void ChangeAnimSlotMask(notnull IEntity ent, int slot, float blendin, BoneMask mask);
+
+// changes animation framerate to fps param
+proto native void ChangeAnimSlotFPS(notnull IEntity ent, int slot, int fps);
+
+// set mask for a channel. There are 12 chanels and mask is using first for bits 0..3
+proto native void	SetAnimMask(notnull IEntity ent, int mask);
+
+// clears chanal mask, return bits which were cleared
+proto native int	ClearAnimMask(notnull IEntity ent, int mask);
+
+//vrati nastavene bity tech kanalu, ktere maji nastavenou animaci, nejsou na konci
+// a pro ktere byla nastavena vstupni maska.
+//Je tim mozno se dotazat na stav vice slotu najednou
+proto native int IsAnimSlotPlaying(notnull IEntity ent, int mask);
+//mask - 16bitu, pro 16 anim slotu. Maximalni hodnota je tedy 0xffff!
+
+//sets how much this morph affect object
+proto native bool SetMorphState(notnull IEntity ent, string morph, float value);
+//morph name
+//value 0...1
+//@}
+
+
+/**
+ * \defgroup ParticleEffect Particle effect API
+ * @{
+ */
+
+enum EmitorParam
+{
+	//! Vector3 R/W
+	CONEANGLE,
+	
+	//! Vector3 R/W
+	EMITOFFSET,
+	
+	//! Float R/W
+	VELOCITY,
+	
+	//! Float R/W
+	VELOCITY_RND,
+	
+	//! Float R/W
+	AVELOCITY,
+	
+	//! Float R/W
+	SIZE,
+	
+	//! Float R/W
+	STRETCH,
+
+	//! begin with random rotation. Bool R/W
+	RANDOM_ANGLE,
+	
+	//! rotate in random direction. Bool R/W
+	RANDOM_ROT,
+
+	//! Float R/W
+	AIR_RESISTANCE,
+	
+	//! Float R/W
+	AIR_RESISTANCE_RND,
+
+	//! Float R/W
+	GRAVITY_SCALE,
+
+	//! Float R/W
+	GRAVITY_SCALE_RND,
+	
+	//! Float R/W
+	BIRTH_RATE,
+
+	//! Float R/W
+	BIRTH_RATE_RND,
+
+	//! Float R/W
+	LIFETIME,
+
+	//! Float R/W
+	LIFETIME_RND,
+
+	//! Bool R/W
+	LIFETIME_BY_ANIM,
+
+	//! Bool R/W
+	ANIM_ONCE,
+
+	//! Bool R/W
+	RAND_FRAME,
+
+	//! efector's total time. Float R/W
+	EFFECT_TIME,
+
+	//! should efector repeate after time up? Bool R/W
+	REPEAT,
+
+	//! current efector's time. Float R/W
+	CURRENT_TIME,
+
+	//! number of active particles. Int R
+	ACTIVE_PARTICLES,
+
+	//! Bool R/W
+	SORT,
+
+	//! Bool R/W
+	WIND,
+
+	//! Float R/W
+	SPRING
+};
+
+// return total count of active particles in all emitors
+// internally does a sum
+// HasActiveParticles is better when just needing to check if there are any active
+proto native int GetParticleCount(notnull IEntity ent);
+
+// return if there are any active particles
+proto bool HasActiveParticle(notnull IEntity ent);
+
+int ParticleGetCount(IEntity ent)
+{
+	return GetParticleCount(ent);
+}
+
+bool ParticleHasActive(IEntity ent)
+{
+	return HasActiveParticle(ent);
+}
+
+// gets name of defined emitors in a particle effect
+// return number of emitors and their names in an array (max defines max. emitors to return)
+proto int GetParticleEmitors(notnull IEntity ent, out string emitors[], int max);
+
+// return number of emitors
+proto int GetParticleEmitorCount(notnull IEntity ent);
+
+// sets a parametr of the particle emitor
+// if the emitor == - 1, it sets the parameter for all emitors
+proto void SetParticleParm(notnull IEntity ent, int emitor, EmitorParam parameter, void value);
+
+//gets parameter of particle emitor
+proto void GetParticleParm(notnull IEntity ent, int emitor, EmitorParam parameter, out void value);
+
+//gets original parameter of particle emitor
+proto void GetParticleParmOriginal(notnull IEntity ent, int emitor, EmitorParam parameter, out void value);
+
+//Force-changes particle emitor position to the current one.
+//Used for sudden changes of particle position to avoid spreading emitted
+//particles between previous and the new one position
+proto native void ResetParticlePosition(notnull IEntity ent);
+
+//Restart particle effect to its default state. This means no 
+//particles, timer reset and so on. Usefull for implementing
+//particle cache.
+proto native void RestartParticle(notnull IEntity ent);
+//@}
+
+
+//@}

scripts/1_Core/DayZ/proto/EnWidgets.c

@@ -0,0 +1,712 @@
+/**
+ * \defgroup WidgetAPI Widget UI system
+ * @{
+ */
+
+#ifdef DOXYGEN
+/** @name WidgetType
+ *  Following WidgetType constants are available to script 
+ */
+///@{
+
+	//!Single-line text. See enf::TextWidget
+	TextWidgetTypeID,
+	//!Multi-line text. See enf::MultilineTextWidget
+	MultilineTextWidgetTypeID,
+	//!Multi-line edit box. See enf::MultilineTextWidget
+	MultilineEditBoxWidgetTypeID,
+	//!Multi-line text with images in text. See enf::RichTextWidget
+	RichTextWidgetTypeID,
+	//! Render target for enf::BaseWorld. See enf::RenderTargetWidget
+	RenderTargetWidgetTypeID,
+	//! Picture, or multiple picture. See enf::ImageWidget
+	ImageWidgetTypeID,
+	//!Console. See enf::ConsoleWidget
+	ConsoleWidgetTypeID,
+	//!Video player. See enf::VideoWidget
+	VideoWidgetTypeID,
+	//! Texture used as render target for children widgets. See enf::RTTextureWidget
+	RTTextureWidgetTypeID,
+	//! Dummy frame, used as hierarchy node and clipper
+	FrameWidgetTypeID,
+	//! Dummy frame, used for embedding another layout and as hierarchy node and clipper
+	EmbededWidgetTypeID,
+	ButtonWidgetTypeID,
+	CheckBoxWidgetTypeID,
+	WindowWidgetTypeID,
+	ComboBoxWidgetTypeID,
+	SimpleProgressBarWidgetTypeID,
+	ProgressBarWidgetTypeID,
+	SliderWidgetTypeID,
+	BaseListboxWidgetTypeID,
+	TextListboxWidgetTypeID,
+	GenericListboxWidgetTypeID,
+	EditBoxWidgetTypeID,
+	PasswordEditBoxWidgetTypeID,
+	WorkspaceWidgetTypeID,
+	GridSpacerWidgetTypeID,
+	WrapSpacerWidgetTypeID,
+	ScrollWidgetTypeID,	
+///@}
+#else
+	typedef TypeID WidgetType;
+#endif
+
+typedef TypeID EventType;
+
+enum WidgetFlags
+{
+	SOURCEALPHA, //< takes alpha from texture * alpha from color. If not set, considers texture as non-transparent and transparency is set only by color
+	BLEND,	//< texture is blended with a surface base on alpha
+	ADDITIVE,	//< texture is added to a surface based on alpha
+	VISIBLE,	//<Widget is visible - ShowWidget(w, true)
+	NOWRAP,	//< Do not do texture wrapping
+	CENTER,	//< Centers TextWidgetTypeID
+	VCENTER,	//< Centers TextWidgetTypeID verticaly
+	HEXACTPOS,
+	VEXACTPOS,
+	EXACTPOS,	//< Uses physical resolution (g_iWidth, h_iHeight)
+	HEXACTSIZE,	//< Uses physical resolution (g_iWidth)
+	VEXACTSIZE,	//< Uses physical resolution (h_iHeight)
+	EXACTSIZE,	//< Uses physical resolution
+	NOFILTER,	//< no texture filtering (no blur)
+	RALIGN,	//< Right alignment TextWidgetTypeID
+	STRETCH,	//< Stretch texture to a full size
+	FLIPU,	//< Flips texture in U axis
+	FLIPV,	//< Flips texture in V axis
+	CUSTOMUV,	//< ignores STRETCH/FLIPU/FLIPV and take custom UV set by SetWidgetUV()
+	IGNOREPOINTER,
+	DISABLED,
+	NOFOCUS,
+	CLIPCHILDREN,
+	RENDER_ALWAYS,
+	NOCLEAR,
+	DRAGGABLE
+};
+
+//------------------------------------------
+enum WidgetAlignment
+{
+	WA_LEFT			= 0,
+	WA_RIGHT		= 1,
+	WA_CENTER		= 2,
+	WA_TOP			= 0,
+	WA_BOTTOM		= 1,
+}
+
+//------------------------------------------
+//! Defined in code
+/*enum LinebreakOverrideMode
+{
+	LINEBREAK_DEFAULT,
+	LINEBREAK_WESTERN,
+	LINEBREAK_ASIAN
+};*/
+
+//------------------------------------------
+class Widget: Managed
+{
+	proto void ~Widget();
+	proto private void Widget();
+	
+	proto static string TranslateString(string stringId);
+	
+	//! Set global LV of widgets, value between [-15, 0], default: 0, lower value is less bright
+	proto static void SetLV(float lv);
+	//! Set global LV of the text in widgets, value between [-15, 0], default: 0, lower value is less bright
+	proto static void SetTextLV(float lv);
+	//! Set global lighting of objects in widgets, value between [0, 1], default: 1, lower value is less bright
+	proto static void SetObjectLighting(float lighting);
+	
+	proto native owned string GetName();
+	proto native void SetName(string name);
+	proto native owned string GetTypeName();
+	proto native WidgetType GetTypeID();
+	proto native void Show(bool show, bool immedUpdate = true);
+	proto native void Enable(bool enable);
+	proto native int GetFlags();
+	proto native int SetFlags(int flags, bool immedUpdate = true);
+	proto native int GetSort();
+	proto native void SetSort(int sort, bool immedUpdate = true);
+	proto native int ClearFlags(int flags, bool immedUpdate = true);
+	proto native bool IsControlClass();
+	proto native owned string GetStyleName();
+	proto void GetUserData(out Class data);
+	proto native void SetUserData(Class data);
+	proto native int GetUserID();
+	proto native void SetUserID(int id);
+	proto native bool IsVisible();
+	proto native bool IsVisibleHierarchy();
+	proto native void SetPos(float x, float y, bool immedUpdate = true);
+	proto native void SetSize(float w, float h, bool immedUpdate = true);
+	proto native void SetScreenPos(float x, float y, bool immedUpdate = true);
+	proto native void SetScreenSize(float w, float h, bool immedUpdate = true);
+	proto native void SetColor(int color);
+	proto native int GetColor();
+	proto native void SetRotation(float roll, float pitch, float yaw, bool immedUpdate = true);
+	//! returns rotation of widget in order roll, pitch, yaw
+	proto native vector GetRotation();
+	proto native void SetAlpha(float alpha);
+	proto native float GetAlpha();
+	proto void GetPos(out float x, out float y);
+	proto void GetSize(out float width, out float height);
+	proto void GetScreenPos(out float x, out float y);
+	proto void GetScreenSize(out float width, out float height);
+
+  proto native void SetTransform(vector mat[4], bool immedUpdate = true);
+
+  proto native Widget GetParent();
+	proto native Widget GetChildren();
+	proto native Widget GetSibling();
+	proto native void AddChild(Widget child, bool immedUpdate = true);
+	proto native void RemoveChild(Widget child);
+
+	proto native volatile void Update();
+
+	proto void GetScript(out Class data);
+
+	proto native Widget FindWidget(string pathname);	//find Widget by path. e.g FindWidget("widget1.widget2.widget3.mywidget")
+	proto native Widget FindAnyWidget(string pathname);	//find Widget by name e.g. FindWidget("widget1")
+	proto native Widget FindAnyWidgetById(int user_id);	//find Widget by userID
+
+	proto native void SetHandler(ScriptedWidgetEventHandler eventHandler);
+	proto native void Unlink(); //destroys widget and all its children
+};
+
+class WorkspaceWidget: Widget
+{
+	//!Create widgets by \ref WidgetType
+	proto native external Widget CreateWidget(WidgetType type, int left, int top, int width, int height, WidgetFlags flags, int color, int sort, Widget parentWidget = NULL);
+	//!Create widgets from *.layout file
+	proto native external Widget CreateWidgets(string layout, Widget parentWidget = NULL, bool immedUpdate = true);	
+};
+
+proto native Widget GetWidgetUnderCursor();
+proto native Widget CancelWidgetDragging();
+proto native Widget GetDragWidget();
+proto native void ReportMouse(int mousex, int mousey, Widget rootWidget);
+
+class TextWidget extends Widget
+{
+  	proto native void SetTextSpacing(int horiz, int vert);
+	//! set text exact size. Exact Text flag must be enabled. 0 equals original size.
+	proto native void SetTextExactSize(int size);
+  	proto native void SetTextOffset(int left, int top);
+	proto native void SetText(string text, bool immedUpdate = true);
+	proto native void SetOutline(int outlineSize, int argb = 0xFF000000);
+	proto native int GetOutlineSize();
+	proto native int GetOutlineColor();
+	proto native void SetShadow(int shadowSize, int shadowARGB = 0xFF000000, float shadowOpacity = 1, float shadowOffsetX = 0, float shadowOffsetY = 0);
+	proto native int GetShadowSize();
+	proto native int GetShadowColor();
+	proto native float GetShadowOpacity();
+	proto void GetShadowOffset(out float sx, out float sy);
+	proto native void SetItalic(bool italic);
+	proto native bool GetItalic();
+	proto native void SetBold(bool bold);
+	proto native bool GetBold();
+	
+	//! Returns text size in pixels
+	proto void GetTextSize(out int sx, out int sy);
+	proto void SetTextFormat(string text, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+	
+	//! Get text proportion - ratio between button height and button text height in interval <0,1>
+	proto native float GetTextProportion();
+	//! Set text proportion - ratio between button height and button text height in interval <0,1>
+	proto native void SetTextProportion(float val);
+};
+
+class MultilineTextWidget extends TextWidget
+{
+	proto native float SetLineBreakingOverride(int mode);
+};
+
+class RichTextWidget extends TextWidget
+{
+	proto native float GetContentHeight();
+	proto native float GetContentOffset();
+	proto native void  SetContentOffset(float offset, bool snapToLine = false);
+	proto native void  ElideText(int line, float maxWidth, string str);
+	proto native int   GetNumLines();
+	proto native void  SetLinesVisibility(int lineFrom, int lineTo, bool visible);
+	proto native float GetLineWidth(int line);
+	proto native float SetLineBreakingOverride(int mode);
+};
+
+class RenderTargetWidget extends Widget
+{
+//!when period > 1 then every n-th frame will be rendered. Offset is initial counter.
+	proto native void SetRefresh(int period, int offset);
+	proto native void SetResolutionScale(float xscale, float ycale);
+};
+
+class RTTextureWidget extends Widget
+{
+};
+
+class ImageWidget extends Widget
+{
+	/*!
+	Loads image. When image of this 'num' is already loaded, then is replaced
+	by new one.
+	\param num Number of image (0...7)
+	\param name Name of image file
+	\param noCache Do not cache the texture
+	\return True when image is loaded, false otherwise
+	*/
+	proto native bool LoadImageFile(int num, string name, bool noCache = false);
+	proto native void SetImageTexture(int image, RTTextureWidget texture);
+	//! returns size of image
+	proto void GetImageSize(int image, out int sx, out int sy);
+	
+	/*!
+	Switches to another image, if it's loaded
+	\param num Number of image.
+	\return True when there is such image, false otherwise.
+	*/
+	proto native bool SetImage(int num);
+	//!Returns active image
+	proto native int GetImage();
+	/*!
+	When WF_CUSTOMUV is set, we can supply our own UV coords instead of computed ones.
+	\param uv
+	Pointer to array of at least 8 floats (4 corners * 2 floats for u/v)
+	*/
+	proto native void SetUV(float uv[4][2]);
+	
+	/*!
+	Loads texture as mask used for alpha masking.
+	\param resource Resource name of the texture to load
+	\return True if texture was successfully loaded, false otherwise
+	*/
+	proto native bool LoadMaskTexture(string resource);
+	
+	/*!
+	Progress determines which alpha values are opaque using the mask. For progress x, 
+	pixels with alpha in mask < x will be opaque and alpha in mask > x will be transparent.
+	For smooth transition see GetMaskTransitionWidth.
+	\return Progress from 0 to 1 representing alpha range which is visible in the mask
+	*/
+	proto native float GetMaskProgress();
+	
+	/*!
+	See GetMaskProgress for explanation.
+	\param value Expected in range [0; 1]
+	*/
+	proto native void SetMaskProgress(float value);
+	
+	/*!
+	Transition width 0.1 and progress 0.2 mean that values in mask lower than progress will be opaque.
+	Values higher than (progress + width) will be transparent and values between progress and (progress + width)
+	will be smoothly transitioned.
+	\return Width of the alpha mask transition representing softness of the transition.
+	*/
+	proto native float GetMaskTransitionWidth();
+
+	/*!
+	See GetMaskTransitionWidth for transition width explanation.
+	\param value Expected in range [0; 1]
+	*/
+	proto native void SetMaskTransitionWidth(float value);
+};
+
+class MultilineEditBoxWidget extends TextWidget
+{
+	proto native int GetLinesCount();
+	proto native int GetCarriageLine();
+	proto native int GetCarriagePos();
+	proto void GetText(out string text);
+	proto native void SetLine(int line, string text);
+	proto void GetLine(int line, out string text);
+};
+
+class UIWidget extends Widget
+{
+	proto native void SetTextColor(int color);
+	proto native void SetTextOutline(int outlineSize, int argb = 0xFF000000);
+	proto native int GetTextOutlineSize();
+	proto native int GetTextOutlineColor();
+	proto native void SetTextShadow(int shadowSize, int shadowARGB = 0xFF000000, float shadowOpacity = 1.0, float shadowOffsetX = 0.0, float shadowOffsetY = 0.0);
+	proto native int GetTextShadowSize();
+	proto native int GetTextShadowColor();
+	proto native float GetTextShadowOpacity();
+	proto native float GetTextShadowOffsetX();
+	proto native float GetTextShadowOffsetY();
+	proto native void SetTextItalic(bool italic);
+	proto native bool GetTextItalic();
+	proto native void SetTextBold(bool bold);
+	proto native bool GetTextBold();
+};
+
+class CanvasWidget extends Widget
+{
+	proto native void DrawLine(float x1, float y1, float x2, float y2, float width, int color);
+	proto native void Clear();
+};
+
+class EditBoxWidget extends UIWidget
+{
+	proto string GetText();
+	proto native void SetText(string str);
+};
+
+class PasswordEditBoxWidget extends EditBoxWidget
+{
+	proto native void SetHideText(bool hide);
+};
+
+class SliderWidget extends UIWidget
+{
+	proto native void SetMinMax(float minimum, float maximum);
+	proto native float GetMin();
+	proto native float GetMax();
+	proto native float GetCurrent();
+	proto native void SetCurrent(float curr);
+	proto native float GetStep();
+	proto native void SetStep(float step);
+};
+
+class SimpleProgressBarWidget extends UIWidget
+{
+	proto native float GetMin();
+	proto native float GetMax();
+	proto native float GetCurrent();
+	proto native void SetCurrent(float curr);
+};
+
+class ProgressBarWidget extends SimpleProgressBarWidget
+{
+};
+
+class ButtonWidget extends UIWidget
+{
+	proto native bool GetState();
+ 
+	proto native bool SetState(bool state);
+
+	proto native void SetText(string text);
+
+	proto void GetText(out string text);
+
+	proto native void SetTextOffset(float xoffset, float yoffset);
+/**
+\param align ALIGN_CENTER, ALIGN_LEFT, ALIGN_RIGHT
+*/
+	proto native void SetTextHorizontalAlignment(int align);
+/**
+\param align ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM
+*/
+	proto native void SetTextVerticalAlignment(int align);
+
+	//! Get text proportion - ratio between button height and button text height in interval <0,1>
+	proto native float GetTextProportion();
+	//! Set text proportion - ratio between button height and button text height in interval <0,1>
+	proto native void SetTextProportion(float val);
+};
+
+class XComboBoxWidget extends UIWidget
+{
+	proto native int AddItem(string item);
+	proto native void ClearAll();
+	proto native void SetItem(int item, string value);
+	proto native void RemoveItem(int item);
+	proto native int GetNumItems();
+	proto native int SetCurrentItem(int n);
+	proto native int GetCurrentItem();
+};
+
+class CheckBoxWidget extends UIWidget
+{
+	proto native void SetText(string str);
+	proto native bool IsChecked();
+	proto native void SetChecked(bool checked);
+};
+
+class BaseListboxWidget extends UIWidget
+{
+	proto native void ClearItems();
+	proto native int GetNumItems();
+	proto native void SelectRow(int row);
+	proto native int GetSelectedRow();
+	proto native void RemoveRow(int row);
+	proto native void EnsureVisible(int row);
+};
+
+class SimpleListboxWidget extends BaseListboxWidget
+{
+};
+
+class TextListboxWidget extends SimpleListboxWidget
+{
+	//! Insert new Row, if row = -1, new Row is inserted at the end otherwise at row index.
+	proto native int AddItem(string text, Class userData, int column, int row = -1);
+	proto native void SetItem(int position, string text, Class userData, int column);
+/**
+\brief Get item
+	\param row \p int Index of row
+	\param column \p int Index of column
+	\return \p string Value in widget on row and column
+	@code
+		string value;
+		textListboxWidg.GetItemText(2, 0, value);
+	@endcode
+*/
+	proto bool GetItemText(int row, int column, out string text);
+	proto void GetItemData(int row, int column, out Class data);
+	
+	proto native void SetItemColor(int row, int column, int color );
+};
+
+class SpacerBaseWidget extends UIWidget
+{
+	proto native void AddChildAfter(Widget child,Widget after, bool immedUpdate = true);
+}
+
+class SpacerWidget extends SpacerBaseWidget
+{
+	proto native WidgetAlignment GetContentAlignmentH();
+	proto native void SetContentAlignmentH(WidgetAlignment alignment);
+	proto native WidgetAlignment GetContentAlignmentV();
+	proto native void SetContentAlignmentV(WidgetAlignment alignment);
+}
+
+class GridSpacerWidget extends SpacerWidget
+{
+}
+
+class WrapSpacerWidget extends SpacerWidget
+{
+}
+
+class ScrollWidget extends SpacerBaseWidget
+{
+	proto native float GetScrollbarWidth();
+	proto native bool IsScrollbarVisible(); //reflects native C++ side scrollbar state
+
+	proto native float GetContentWidth();
+	proto native float GetContentHeight();
+	
+	proto native float GetHScrollPos();
+	proto native float GetHScrollPos01();
+	proto native bool HScrollStep(int steps);
+	proto native void HScrollToPos(float pos);
+	proto native void HScrollToPos01(float pos01);
+	proto native void HScrollToWidget(Widget child);
+
+	proto native float GetVScrollPos();
+	proto native float GetVScrollPos01();
+	proto native bool VScrollStep(int steps);
+	proto native void VScrollToPos(float pos);
+	proto native void VScrollToPos01(float pos01);
+	proto native void VScrollToWidget(Widget child);
+};
+
+//! Legacy, do not use
+enum VideoCommand
+{
+	PLAY,
+	STOP,
+	REWIND,
+	POSITION,
+	REPEAT,
+	ISPLAYING,
+	KILL
+};
+
+enum VideoState
+{
+	//! There is no video
+	NONE,
+	//! The video is playing
+	PLAYING,
+	//! The video is paused
+	PAUSED,
+	//! The video is paused at the beginning of the video
+	STOPPED,
+	//! The video is paused at the end of the video
+	FINISHED,
+};
+
+enum VideoCallback
+{
+	ON_PLAY,
+	ON_PAUSE,
+	ON_STOP,
+	ON_END,
+	ON_LOAD,
+	ON_SEEK,
+	ON_BUFFERING_START,
+	ON_BUFFERING_END,
+};
+
+class VideoWidget extends Widget
+{
+	//! Load a video file
+	proto native bool Load(string name, bool looping = false, int startTime = 0);
+	//! Unload the video, freeing up all resources
+	proto native void Unload();
+	
+	//! Starts video playback
+	proto native bool Play();
+	//! Pauses video playback
+	proto native bool Pause();
+	//! Stop video playback (cancels everything and sets it back at time 0)
+	proto native bool Stop();
+	
+	//! Set the desired time for the video (preload decides whether it will already load the next frames too)
+	proto native bool SetTime(int time, bool preload);	
+	//! Get the current time of the video
+	proto native int GetTime();
+	//! Get the total time of the video
+	proto native int GetTotalTime();
+	
+	//! Set whether the video should loop
+	proto native void SetLooping(bool looping);	
+	//! Whether looping is enabled
+	proto native bool IsLooping();
+	
+	//! QoL direct method to check for playing state (buffering while playing will still return true)
+	proto native bool IsPlaying();
+	//! Get the current state of the video
+	proto native VideoState GetState();
+	
+	/**
+	\brief Enable/Disable subtitles
+	\warning Subtitles need font to be assigned to VideoWidget in layout to work
+	\note Subtitles are in the format "videoName_Language.srt"
+	\note It is best to have the English one without language specified "videoName.srt"
+	*/
+	proto native void DisableSubtitles(bool disable);
+	//! Check if subtitles are disabled (enabled by default if available, so it will return false even if there are none)
+	proto native bool IsSubtitlesDisabled();
+	
+	//! Set a callback for a certain video event
+	proto void SetCallback(VideoCallback cb, func fn);
+	
+	//! Legacy, preferably not used, left for backwards compat
+	int Play(VideoCommand cmd)
+	{
+		// Yes, some things here do not do what the name implies
+		// And it returns 0 whether successful or not
+		// But this is what the old functionality looked like
+		// So for true backwards compat, it will be left like this
+		switch (cmd)
+		{
+			case VideoCommand.PLAY:
+				Play();
+				break;
+			case VideoCommand.STOP:
+				Pause();
+				break;
+			case VideoCommand.REWIND:
+				SetTime(0, true);
+				break;		
+			case VideoCommand.POSITION:
+				return GetTime();
+			case VideoCommand.REPEAT:
+				SetLooping(true);
+				break;
+			case VideoCommand.ISPLAYING:
+				return IsPlaying();
+			case VideoCommand.KILL:
+				Unload();
+				break;
+			default:
+				return 0;
+		}
+		
+		return 0;
+	}
+	
+	//! Legacy, preferably not used, left for backwards compat
+	bool LoadVideo(string name, int soundScene)
+	{
+		return Load(name);
+	}
+};
+
+/*! sets Widget typu RTTextureWidgetTypeID, to which it is possible to reference in shader as $rendertarget
+it is posible to use only after object selection. When selecting another object, it is necessary to set GUI widget again
+*/
+proto native void SetGUIWidget(IEntity ent, int index, RTTextureWidget w);
+
+enum ControlID
+{
+	CID_NONE = 0,
+	CID_SELECT = 1,//select/use focused
+	CID_BACK,
+	CID_LEFT, //navigation
+	CID_RIGHT,
+	CID_UP,
+	CID_DOWN,
+	CID_MENU, //get to main menu
+	CID_DRAG, //probably needed only for consoles
+	CID_TABLEFT,
+	CID_TABRIGHT,
+	CID_RADIALMENU,
+	CID_COUNT
+};
+
+class ScriptedWidgetEventHandler: Managed
+{
+	bool OnClick(Widget w, int x, int y, int button);
+	bool OnModalResult(Widget w, int x, int y, int code, int result);
+	bool OnDoubleClick(Widget w, int x, int y, int button);
+	bool OnSelect(Widget w, int x, int y);
+	bool OnItemSelected(Widget w, int x, int y, int row, int column, int oldRow, int oldColumn);
+	bool OnFocus(Widget w, int x, int y);
+	bool OnFocusLost(Widget w, int x, int y);
+	bool OnMouseEnter(Widget w, int x, int y);
+	bool OnMouseLeave(Widget w, Widget enterW, int x, int y);
+	bool OnMouseWheel(Widget w, int x, int y, int wheel);
+	bool OnMouseButtonDown(Widget w, int x, int y, int button);
+	bool OnMouseButtonUp(Widget w, int x, int y, int button);
+	//! control is one of ControlID 
+	bool OnController(Widget w, int control, int value);
+	bool OnKeyDown(Widget w, int x, int y, int key);
+	bool OnKeyUp(Widget w, int x, int y, int key);
+	bool OnKeyPress(Widget w, int x, int y, int key);
+	bool OnChange(Widget w, int x, int y, bool finished);
+	bool OnDrag(Widget w, int x, int y);
+	bool OnDragging(Widget w, int x, int y, Widget reciever);
+	bool OnDraggingOver(Widget w, int x, int y, Widget reciever);
+	bool OnDrop(Widget w, int x, int y, Widget reciever);
+	bool OnDropReceived(Widget w, int x, int y, Widget reciever);
+	bool OnResize(Widget w, int x, int y);
+	bool OnChildAdd(Widget w, Widget child);
+	bool OnChildRemove(Widget w, Widget child);
+	bool OnUpdate(Widget w);
+	bool OnEvent(EventType eventType, Widget target, int parameter0, int parameter1);
+};
+
+//Common Widget API
+proto native void SetCursorWidget(Widget cursor);
+//! direct mouse cursor visibility control
+proto native void ShowCursorWidget(bool show);
+proto native bool LoadWidgetImageSet(string filename);
+proto native void LoadWidgetStyles(string filename);
+// sets active window (widget which owns some control inputs like buttons, listboxes etc.). Necessary for controlling the focus by keyboard/joypad. In case when setFocus is set to true, it sets focus on a first child Widget, which may receive the focus (is not disabled, set as NoFocus etc.)
+proto native bool SetActiveWindow(Widget w, bool resetFocus);
+
+// sets focus (necessary when using keyboard/joyped) to a particular widget. Widget must have some inputs like button, listbox, checkbox, combobox etc.
+proto native void SetFocus(Widget w);
+
+proto native void SetModal(Widget w);
+
+proto native Widget GetFocus();
+
+//RenderTargetWidgetTypeID
+proto native void SetWidgetWorld(RenderTargetWidget w, IEntity wrldEntity, int camera);
+
+
+#ifdef PS3
+	/*!
+	circle and cross can be swapped when license area is japan/asia
+	*/
+	proto native bool IsCircleToCrossSwapped();
+#endif
+
+proto native bool ReloadTexture(string path);
+
+
+//@}

scripts/1_Core/DayZ/proto/EnWorld.c

@@ -0,0 +1,436 @@
+/**																																											 /**
+ * \defgroup World World
+ * @{
+ */
+
+//----------------------------------------------
+/**
+ * \defgroup WorldCommon World
+ * @{
+ */
+
+typedef int[] WorldHandle;
+
+proto native float GetWorldTime();
+
+/*! Sets current world. It allows to work with entities outside world processing
+// return previous world
+*/
+proto native WorldHandle SetCurrentWorld(WorldHandle world);
+
+//proto native void SchedulePreload(vector pos, float radius);
+
+proto native IEntity FindEntityByName(IEntity worldEnt, string name);
+proto native IEntity FindEntityByID(IEntity worldEnt, int ID);
+
+//!returns number of active (simulated) Entities in the world
+proto native int GetNumActiveEntities(IEntity worldEntity);
+//!returns active entity
+proto native IEntity GetActiveEntity(IEntity worldEntity, int index);
+//@}
+
+//----------------------------------------------
+/**
+ * \defgroup Camera Camera
+ * @{
+ */
+
+enum CameraType
+{
+	PERSPECTIVE,
+	ORTHOGRAPHIC
+};
+
+//! sets which camera will be a listener (for sound engine)
+proto native void SetListenerCamera(int camera);
+
+/*!
+Changes camera position
+\param cam Index of camera
+\param origin	position
+\param angle	orientation
+*/
+proto native void SetCamera(int cam, vector origin, vector angle);
+
+//! Changes camera matrix
+proto native void SetCameraEx(int cam, const vector mat[4]);
+
+//!Returns current camera transformation
+proto native void GetCamera(int cam, out vector mat[4]);
+
+proto native void SetCameraVerticalFOV(int cam, float fovy);
+proto native void SetCameraFarPlane(int cam, float farplane);		//default 160000 units
+proto native void SetCameraNearPlane(int cam, float nearplane);	//default 5 units
+
+proto native void SetCameraType(int cam, CameraType type);
+
+/*! 
+\brief Post-process effect type.
+\attention Keep enum names in synch with post-process effect material class names. Postfix "Effect" is appended automatically.
+*/
+enum PostProcessEffectType
+{
+	None,
+	UnderWater,
+	SSAO,
+	DepthOfField,
+	HBAO,
+	RotBlur,
+	GodRays,
+	Rain,
+	FilmGrain,
+	RadialBlur,
+	ChromAber,
+	WetDistort,
+	DynamicBlur,
+	ColorGrading,
+	Colors,
+	Glow,
+	SMAA,
+	FXAA,
+	Median,//unused?
+	SunMask,
+	GaussFilter,
+	SSR //not available
+};
+/*!
+set postprocess effect to camera
+To disable effect in some prioroty ppEffect, just set effectName or name to NULL
+\param cam 		number of camera
+\param priority		priority of effect
+\param type	type of effect
+\param materialPath 		material
+*/
+proto native void SetCameraPostProcessEffect(int cam, int priority, PostProcessEffectType type, string materialPath);
+		
+//ent can be NULL for world-space coords
+proto vector	ProjectVector(int cam, IEntity ent, vector vec);
+proto vector	UnprojectVector(int cam, float x, float y, vector dir);
+
+//@}
+
+//----------------------------------------------
+/**
+ * \defgroup Light Light API
+ * @{
+ */
+
+//!Light handle
+typedef int[] HLIGHT;
+
+enum LightType
+{
+	POINT, //< point light, all directional light
+	SPOT,	//<	spot light, direction is determined by owner (entity)
+	DIRECTIONAL,
+	AMBIENT
+};
+
+enum LightFlags
+{
+/*!
+Dynamic light. There is limit 512 dynamic lights per world and
+32 per camera view. They are faster when moving and changing shape.
+Also they are always attached to owner entity
+*/
+	DYNAMIC, 
+	CASTSHADOW,
+//! for cheaper dynamic lights, like muzzle flashes (might use cheaper rendering method)
+	CHEAP
+};
+
+/*!
+creates light
+*/
+proto HLIGHT AddLight(IEntity owner, LightType type, LightFlags flags, float radius, vector color);
+//!removes light
+proto native bool RemoveLight(HLIGHT light);
+proto native bool SetLightEx(HLIGHT light, float radius, vector color);
+//!sets lookup texture for projection lights
+proto native bool SetLightTexture(HLIGHT light, string cubemap);
+proto native int SetLightFlags(HLIGHT light, LightFlags flags);
+proto native int ClearLightFlags(HLIGHT light, LightFlags flags);
+//!Sets light cone in degrees (for LightType.SPOT).
+proto native bool SetLightCone(HLIGHT light, float cone);
+
+/*!
+scene multiplicator of light (based on measured scene light levels) - preexposure of light
+*/
+proto native float GetSceneHDRMul(int camera);
+//@}
+
+
+
+//----------------------------------------------
+/**
+ * \defgroup WorldTrace Trace&Visibility API
+ * @{
+ */
+
+enum TraceFlags
+{
+	BONES, //< tests collision geometries around bones of animated objects
+	ENTS, //< tests entities
+	WORLD, //< tests world bounding box
+	ONLY_PHYSICS,
+	WATER, //< tests collision with water surface
+	PASSTRANSLUCENT,//< Do not intersects with entities with EntityFlags.TRANSLUCENT set
+	RAGDOLLS, //< tests ragdolls
+	VISTEST, //< performs visibility test first. Not necessary for entities receiving EntityEvent.VISIBLE, because there is a certainty that a camera will see them
+	NOTRACE,
+	TRANSPARENT_OCCLUDERS
+};
+
+enum TraceShape
+{
+  LINE,
+  BOX,
+  OBB,
+  SPHERE
+};
+
+//! collision and tracing
+//! WARNING: Non-managed, needs manual delete call, should not be ref'd
+class TraceContact
+{
+	float	Fraction;
+	int		Content;
+	int		Surfparm;
+	int		MaterialFlags;
+	int		Triangle;
+	int		SurfaceID;
+	owned string	MaterialName;
+	owned string	OriginalMaterialName;
+	float		Plane[4];
+	vector	Point;
+}
+
+proto native bool TraceLineToEntity(IEntity ent, vector start, vector end, out TraceContact contact);
+
+//bool FilterCallback(Class target [, vector rayorigin, vector raydirection])
+
+class TraceParam: Managed
+{
+	vector		Start;
+	vector		End;
+	int			LayerMask = 0xffffffff;
+	TraceFlags	Flags;
+	IEntity		Exclude;
+	
+};
+
+class TraceSphere: TraceParam
+{
+	float			Radius;	
+};
+
+class TraceBox: TraceParam
+{
+	vector		Mins;
+	vector		Maxs;
+};
+
+class TraceOBB: TraceBox
+{
+	vector		Mat[3];
+};
+
+/*!
+traces line start->end, return 0..1 if trace was sucessfull.
+// It take bboux from ent
+// flag like in P2PVisibilityEx will be added
+//OUTPUT:
+\param cent		[out] traced entity
+\param plane	[out] traced polygon plane (X,Y,Z,D)
+\param surfparm	 [out] traced surface parameters
+\returns	value 0...1, percentage of a path traveled
+*/
+proto volatile float TraceMove(TraceParam param, out IEntity cent, out float plane[4], out int surfparm, func filtercallback);
+
+
+/*!
+tests visibility
+\param from
+\param to
+\param flags
+//TraceFlags.VISTEST	- 
+//TraceFlags.DETAIL		- test agains detail brushes
+//TraceFlags.ENT			- test against brush entities
+//TraceFlags.NOTRACE	- doesn't test geometry (has meaning in conjuction with s TraceFlags.VISTEST)
+\returns		true is visible/false not visibel
+*/
+proto native int P2PVisibilityEx(vector from, vector to,int flags);
+
+//! finds all entities in a radius
+proto int SphereQuery(vector origin, float radius, out IEntity visents[], int ents, int fmask);
+
+/*!tests if bbox is visible according to view-frustum and PVS
+\param flags & 1 - test also PVS
+\returns true/false is/isn't visible
+*/
+proto native bool IsBoxVisible(vector mins, vector maxs, int flags);
+
+/*!finds all visible entities (rought, according to a visibility. It is convinient for entitie selection where we want to do more precise visibility test)
+\param origin		-		position it is looked from
+\param look		-		look direction
+\param angle		-		view angle (usuably 90). -1 if we do not care about the view angle
+\param ents		-		array to which entities will be stored
+\param maxents	-		length of the array (prevents overflowing the array)
+\param fmask		-		flag mask (SetFlags()). Entity must have all flags set.
+						it is possible to use reserved flags like EntityFlags.USER1, EntityFlags.USER2, EntityFlags.USER6 for fast finding of entities in custom categories
+*/
+proto int		VisEntities(vector origin, vector look, float angle, float radius, out IEntity ents[2], int maxents, int fmask);
+
+/*!
+Object that handles visibility on GPU. Used for coronas etc.
+*/
+class OcclusionQuery
+{
+	proto private void ~OcclusionQuery();
+
+	/*!
+	return Query result
+	\returns  -1 result is not ready yet, try it later.
+  >0 point is visible
+ ==0 point is not visible
+	*/
+	proto native int GetResult();
+
+	//!Sets world position
+	proto native void SetPosition(vector pos);
+	//!Destroys the object
+	proto native void Destroy();
+};
+
+//@}
+
+//----------------------------------------------
+/**
+ * \defgroup Decals Decals API
+ * @{
+ */
+typedef int[] hDecal;
+
+/*!
+Creates single visual mark, e.g. from shots
+//when lifetime=0, pointer to decal is returned, that can be removed by RemoveDecal then
+\param entity		entity where the landmark should be created
+\param origin		first point of the decal, nothing is done now
+\param project	projection direction (length is far clipping distance)
+\param nearclip	near clipping distance
+\param materialName Material used for decal
+\param lifetime	Lifetime in seconds
+\param flags Not used ATM
+\return Decal pointer or null
+*/
+proto native hDecal CreateDecal(IEntity entity, vector origin, vector project, float nearclip, float angle, float size, string materialName, float lifetime, int flags);
+
+proto native void RemoveDecal(hDecal decal);
+
+/*!
+Creates continous visual mark, e.g. from wheel when a car is moving on the ground
+\param entity		entity where the landmark should be created (only terrain is supported ATM)
+\param origin		first point of the decal, nothing is done now
+\param normal		normal of surface
+\param edgesize	Edge size of decal
+\param lifetime	Lifetime in seconds
+\param materialName Material used for decal
+\param prev			Previous decal, we are connecting to
+\param alpha		translucency of point
+\return Decal pointer or null
+*/
+proto native hDecal CreateLandMarkDecal(IEntity entity, vector origin, vector normal, float edgeSize, float lifeTime, string materialName, hDecal prevDecal, float alpha);
+
+
+/*!
+is it possible to add new point to landmark decal?
+\param lmDecal		entity to add new landmark point
+\param entity		entity to add new landmark point
+\param mat			material of decal
+\param newpoint 	new point to add
+\return
+	LMD_ERROR 	= error when adding new point (invalid decal)
+	LMD_VALID 	= can add new point
+	LMD_DIFF_ENT 	= new point is on different entity
+	LMD_TOO_FAR	= new point is too far from previous point
+*/
+proto native int CanAddToLandMarkDecal(hDecal lmDecal, IEntity entity, string mat, vector newPoint);
+
+/*!
+add new point to decal, internally, new point is added when previous point is in some
+distance or the angle is more than some threshold
+\param lmDecal		entity to add new landmark point
+\param point		contact point
+\param normal		normal of contact
+\param alpha		translucency in point
+\return true if everything was OK, false if not. In this case, the application MUST not used later the pointer to decal, it's finalized internally !
+*/
+proto native bool AddPointToLandMarkDecal(hDecal lmDecal, vector point, vector normal, float alpha);
+
+/*!
+finalize landmark adding, e.g. when entity lose contact with ground -> the pointer to decal
+should have only world and entity if it has something to render, otherwise it's destroyed here
+\param lmDecal		entity to add new landmark point
+\param addAlpha	if to add last point with transition to zero alpha
+\param alphaDist	distance to add last point
+*/
+proto native void FinalizeLandMarkDecal(hDecal lmDecal, bool addAlpha, float alphaDist);
+
+/*!
+return if landmark was finalized
+\param lmDecal		decal to test
+*/
+proto native bool IsLandMarkFinalized(hDecal lmDecal);
+
+/*!
+return last landmark point or -65535.0 in all components
+\param lmDecal		decal to test
+*/
+proto native vector GetLastLandMarkPoint(hDecal lmDecal);
+
+/*!
+set global parameters for landmark generation
+\param minSegmentLength		minimum length segment, when new point is added (4 default), when is less, just the end position is on the fly updated
+\param maxSegmentLength		maximum segment length, when length is bigger, the path is finished
+\param degAngle				angle in degrees, when is more, the path is finished
+*/
+proto native void SetGlobalLandMarkParams(float minSegmentLength, float maxSegmentLength, float degAngle);
+
+
+//@}
+
+
+//----------------------------------------------
+/**
+ * \defgroup Ocean Ocean API
+ * @{
+ */
+
+/*!
+Is ocean availabled
+*/
+proto native bool IsOcean();
+
+/*!
+Get water ocean height at given point
+\param worldX		world x position
+\param worldZ		world z position
+*/
+proto native float GetOceanHeight(float worldX, float worldZ);
+
+
+/*!
+Get water ocean height and displacement at given point, returns vector(displaceX, height, displaceZ)
+\param worldX		world x position
+\param worldZ		world z position
+*/
+proto native vector GetOceanHeightAndDisplace(float worldX, float worldZ);
+
+
+
+//@}
+
+
+
+//@}
+ 

scripts/1_Core/DayZ/proto/Serializer.c

@@ -0,0 +1,112 @@
+//-----------------------------------------------------------------------------
+/**
+ \brief Serialization general interface. Serializer API works with:
+	- primitive types: int, float, string, bool, vector
+	- dynamic containers: array, set, map
+	- static arrays
+	- complex types: classes
+ \note Serializer provides deep serialization (it serialize class memebers and their members etc). To avoid serialization of certain class variable, use NonSerialized attribute.
+ \par usage:
+ @code
+	class MyData
+	{
+		int m_id;
+		autoptr map<string, float> m_values;
+	
+		[NonSerialized()]
+		string m_dbg; // I don't want to serialize this variable
+	}
+
+	void Serialize(Serializer s)
+	{
+		int statArray[4] = {6,9,2,3};
+		array<int> dynArray = {8,5,6,4};
+		autoptr MyData data = new MyData();
+	
+		data.m_id = 965;
+		data.m_values = map<string, float>;
+		data.m_values.Insert("value1", 5.98);
+		data.m_values.Insert("value2", 4.36);
+	
+		s.Write(10);
+		s.Write("Hello");
+		s.Write(statArray);
+		s.Write(dynArray);
+		s.Write(data);
+	}
+
+	void Deserialize(Serializer s)
+	{
+		int statArray[4];
+		array<int> dynArray;
+		MyData data;
+		int someInt;
+		string someString;	
+	
+		s.Read(someInt);
+		s.Read(someString);
+		s.Read(statArray);
+		s.Read(dynArray);
+		s.Read(data);
+	}
+ 
+ @endcode
+ */
+class Serializer: Managed
+{
+	proto bool Write(void value_out);
+	proto bool Read(void value_in);
+
+	proto native bool CanWrite();
+	proto native bool CanRead();
+	
+	protected void Serializer() {}
+	protected void ~Serializer() {}
+};
+
+/**
+ \brief Serializer API implementation for File IO. See Serializer for more info.
+ \n usage:
+ @code
+void TestSave()
+{
+	FileSerializer file = new FileSerializer();
+	string names[3] = {"alpha", "beta", "gama"};
+	
+	if (file.Open("test.save", FileMode.WRITE))
+	{
+		file.Write(10);
+		file.Write("lalala");
+		file.Write(name);
+		file.Close();
+	}
+}
+	
+void TestLoad()
+{
+	FileSerializer file = new FileSerializer();
+	int intVal;
+	string stringVal;
+	string names[3];
+		
+	if (file.Open("test.save", FileMode.READ))
+	{
+		file.Read(intVal);
+		file.Read(stringVal);
+		file.Read(names);
+		file.Close();
+	}
+}	
+ 
+ @endcode
+ */
+class FileSerializer: Serializer
+{
+	void FileSerializer() {}
+	void ~FileSerializer() {}
+	
+	proto native bool Open(string path, FileMode mode = FileMode.READ);
+	proto native bool IsOpen();
+	proto native void Close();
+}
+	

scripts/1_Core/DayZ/proto/proto.c

@@ -0,0 +1,390 @@
+/** @file */
+
+
+/*
+Function/method modifiers:
+proto	- prototyping of internal function (C++ side)
+native - native call convention of internal function (C++ side)
+volatile - internal function that may call back to script (hint for
+  compiler that context need to be saved on stack)
+private - function may not be called from script
+event - hint for tools that the function should be exposed as
+ Entity script event.
+
+Variable modifiers:
+owned - modifier for returing internal functions. Tells to script-VM,
+that returning variable (string or array) must not be released
+out - modifier for function parameters. It tells that variable will
+ be changed by function call (used mainly by internal functions)
+inout - modifier for function parameters. It tells that variable will
+ be used and then changed by function call (used mainly by internal functions)
+
+const - constants. May not be modified.
+reference - hint for tools (Material editor), that the variable may be used
+ as parameter in material
+*/
+
+
+/*===================================================================*/
+/*							Enforce engine API						 */
+/*===================================================================*/
+
+//placeholder
+class AnimEvent
+{
+	int type;
+	int slot;
+};
+
+class SoundEvent
+{
+	int type;
+	int handle;
+};
+
+
+typedef int[] vobject;
+
+class vobject
+{
+	proto native IEntitySource ToEntitySource();
+}
+
+#ifdef ENF_DONE
+
+//------------------------------------------
+// SOUND API
+//------------------------------------------
+//TODO:
+typedef int[] HSOUND;
+
+//flags
+//!Play once and invoke EntityEvent.SOUNDEND event
+//SFX_ONCE
+//!Music. Has separate volume control, can be replaced by custom music
+//SFX_MUSIC
+//!Ambient, not positional sound
+//SFX_AMBIENT
+//!Positional sound
+//SFX_3D
+//!Don't even start if not hearable. Valid only together with SFX_3D!
+//SFX_DISCARDABLE
+//!Sound is positional. XSoundSource::GetSoundOrientation is called. Valid only together with SFX_3D!
+//SFX_DIRECTIONAL
+////!Sound is moveable. XSoundSource::GetSoundVelocity is called. Valid only together with SFX_3D!
+//SFX_DOPPLER
+//!Position is not changing, XSoundSource::GetSoundPosition/GetSoundOrientation is called only once upon start! Valid only together with SFX_3D!
+//SFX_STATIC
+//!Don't test hearability. Valid only together with SFX_3D!
+//SFX_NOTEST
+
+//proto volatile HSOUND PlaySound(int soundScene, IEntity source, string sshader, int flags);
+proto volatile native void EndSound(HSOUND snd);
+
+//volume 0...1. Logaritmic scale
+proto native int SetSoundVolume(HSOUND sound, float volume)
+proto native int SetSoundFrequency(HSOUND sound, int freq)
+
+
+//returns 0, if soundid is not valid
+proto native int GetSoundLength(HSOUND sound)
+
+//returns -1, if soundid is not valid
+proto native int GetSoundPosition(HSOUND sound)
+
+//defaultne se pouziva EAX prostredi nadefinovane v mape, ale lze ho prebit touto fci.
+// Mohou se michat dve ruzna prostredi v pomeru danem hodnotou fade (fade==0 -> 100% env1, fade==1 -> 100% env2).
+//pokud chceme michat aktualni prostredi s nejakym jinym, lze pouzit zastupny nazev "$current".
+//Tim lze dosahnout nafadovani vlastniho prostredi, kdyz fci postupne volame napr. takto:
+//SetEAXEnvironment("$current", "Drugged", fade)
+//pricemz hodnota fade postupne narusta od nuly do jedne
+//proto native bool SetEAXEnvironment(string env1, string env2, float fade)
+#endif
+
+class PacketOutputAdapter
+{
+	proto native void WriteBool(bool value);			//size: 1 byte
+	proto native void WriteInt(int value);				//size: 4 bytes
+	proto native void WriteFloat(float value);		//size: 4 bytes
+	proto native void WriteString(string value);		//size: n bytes (string length)
+	proto native void WriteVector(vector value);		//size: 12 bytes
+	proto native void WriteMatrixAsQuaternionVector(vector mat[4]);	//size: 28 bytes
+	proto native void WriteIntAsByte(int value);		//write int in range <-128, 127>			size: 1 byte
+	proto native void WriteIntAsUByte(int value);	//write int in range <0, 255>				size: 1 byte
+	proto native void WriteIntAsHalf(int value);		//write int in range <-32768, 32768>	size: 2 bytes
+	proto native void WriteIntAsUHalf(int value);	//write int in range <0, 65535>			size: 2 bytes
+	proto native void WriteFloatAsByte(float value, float min, float max);	//					size: 1 byte
+	proto native void WriteFloatAsHalf(float value, float min, float max);	//					size: 2 bytes
+};
+
+class PacketInputAdapter
+{
+	proto native bool ReadBool();
+	proto native int ReadInt();
+	proto native float ReadFloat();
+	proto string ReadString();
+	proto native vector ReadVector();
+	proto void ReadMatrixAsQuaternionVector(vector mat[4]);
+	proto native int ReadIntAsByte();
+	proto native int ReadIntAsUByte();
+	proto native int ReadIntAsHalf();
+	proto native int ReadIntAsUHalf();
+	proto native float ReadFloatAsByte(float min, float max);
+	proto native float ReadFloatAsHalf(float min, float max);
+};
+
+/*!
+makes screenshot and stores it in to a DDS format file
+if the name begins with '$' the screenshot in stored in the fullpath according to the name parameter
+otherwise the screenshot is stored in "$profile:ScreenShotes/DATE TIME-NAME.dds" where DATE, TIME AND NAME are replaced by actual values
+\param name name of the screenshot
+*/
+proto native void MakeScreenshot(string name);
+
+/*!
+Returns actual fps (average in last 10 frames)
+*/
+proto native int GetFPS();
+
+//----------------------------------------------
+/** \name SkyDome API */
+//@{
+
+/*!
+load all sky presets from xml file
+\param presetFile	name of XML file with presets
+*/
+proto native int LoadSkyPresets(string presetsFile);
+
+/*!
+initialize sky with preset, must be called to set the global planets setting
+\param presetName	name of preset to be set (one of presets from file loaded using LoadSkyPresets)
+*/
+proto native int InitSky(string presetName);
+
+/*!
+set sky preset to day time and stormy parameter
+\param presetName	name of preset to be set (one of presets from file loaded using LoadSkyPresets)
+\param stormy		stormy parameter <0, 1>
+\param dayTime		day of time <0, 1>
+*/
+proto native int SetSkyPreset(string presetName, float stormy, float dayTime);
+
+/*!
+lerp two sky presets and set the result using day time
+\param presetName1	name of preset1 to be set (one of presets from file loaded using LoadSkyPresets)
+\param presetName2	name of preset2 to be set (one of presets from file loaded using LoadSkyPresets)
+\param dayTime		day of time <0, 1>
+\param stormy1		stormy parameter for preset1 <0, 1>
+\param stormy2		stormy parameter for preset2 <0, 1>
+\param lerpVal		lerp value between two presets
+*/
+proto native int LerpSkyPreset(string presetName1, string presetName2, float dayTime, float stormy1, float stormy2, float lerpVal);
+
+/*!
+lerp three sky presets using barycentric coordinates and set the result using day time
+\param presetName1	name of preset1 to be set (one of presets from file loaded using LoadSkyPresets)
+\param presetName2	name of preset2 to be set (one of presets from file loaded using LoadSkyPresets)
+\param presetName2	name of preset3 to be set (one of presets from file loaded using LoadSkyPresets)
+\param dayTime		day of time <0, 1>
+\param stormy1		stormy parameter for preset1 <0, 1>
+\param stormy2		stormy parameter for preset2 <0, 1>
+\param stormy3		stormy parameter for preset3 <0, 1>
+\param w1		weight for preset1
+\param w2		weight for preset2
+\param w3		weight for preset3
+*/
+proto native int LerpSkyPreset3(string presetName1, string presetName2, string presetName3, float dayTime, float stormy1, float stormy2, float stormy3, float w1, float w2, float w3);
+
+/*!
+user can set planets to its own positions on skydome using SetSkyPresetPlanet function,
+if disabled, the planets are positioned automatically using sky preset setting
+\param enabled 	enable/disable
+*/
+proto native void SetSkyUserPlanets(bool enabled);
+
+/*!
+set planet position
+\param index		index of planet, 0 = sun usually
+\param azimuthDeg	azimuth position in degrees
+\param zenithDeg	zenith position in degrees
+*/
+proto native bool SetSkyPlanet(int index, float azimuthDeg, float zenithDeg);
+
+/*!
+set planet size in degrees
+\param index		index of planet, 0 = sun usually
+\param angleDeg		angle size in degrees
+*/
+proto native bool SetSkyPlanetSize(int index, float angleDeg);
+
+/*!
+set UTC time for real time stars
+\param year
+\param month
+\param day
+\param hour
+\param minute
+\param sec
+\param offsetSec	to take into account time difference between Greenwich and local time (position dependency, summer/winter time)
+*/
+proto native void SetStarsObserverTime(int year, int month, int day, int hour, int minute, float sec, int offsetSec);
+
+/*!
+set observer position
+\param latitudeDeg	latitude in degrees
+\param longitudeDeg	longitude in degrees
+*/
+proto native void SetStarsObserverPosition(float latitudeDeg, float longitudeDeg);
+
+/*!
+update of stars
+\param update 	true = automatic stars update, false = update is on user by SetStarsRotMatrix
+*/
+proto native void  SetRealStarAutoUpdate(bool update);
+
+
+/*!
+night sky layer rotation matrix
+\param mat	rotation matrix
+*/
+proto native void SetNightLayerRotMatrix(vector mat[3]);
+
+/*!
+stars rotation matrix, is different from night rotation matrix
+because we don't know the time when night layers was captured
+\param mat	rotation matrix
+*/
+proto native void SetStarsRotMatrix(vector mat[3]);
+
+//@}
+
+//----------------------------------------------
+/** \name Materials API */
+//@{
+typedef int[] Material;
+
+class Material
+{
+	/*!
+	set parametr of material by string name
+	\param paramName	name of parameter
+	\param value		value
+	*/
+	proto bool SetParam(string propertyName, void value);
+
+	/*!
+	reset parametr of material to default value
+	\param paramName	name of parameter
+	*/
+	proto native void ResetParam(string propertyName);
+
+	/*!
+	set parametr index for faster access to material properties
+	\param paramName	name of parameter
+	\return parameter index
+	*/
+	proto native int GetParamIndex(string paramName);
+
+	/*!
+	set parametr of material by index
+	\param paramName	name of parameter
+	\param value		value
+	*/
+	proto void SetParamByIndex(int paramIndex, void value);
+};
+//@}
+
+int VectortoRGBA( vector vec, float h)
+{
+float x,y,z;
+int r,g,b,a,rgba;
+
+	x = vec[0];
+	y = vec[1];
+	z = vec[2];
+
+	x = x * 127.0 + 128.0;
+	y = y * 127.0 + 128.0;
+	z = z * 127.0 + 128.0;
+	h = h * 255.0;
+
+	a = (int)h << 24;
+	r = (int)x << 16;
+	g = (int)y << 8;
+	b = z;
+
+	return r | g | b | a;
+}
+
+
+//-----------------------------------------------------------------
+int ARGB(int a, int r, int g, int b)
+{
+	a = a << 24;
+	r = r << 16;
+	g = g << 8;
+	return a | r | g | b;
+}
+
+//-----------------------------------------------------------------
+//! Converts <0.0, 1.0> ARGB into color
+int ARGBF(float fa, float fr, float fg, float fb)
+{
+	return ARGB((float)(fa * 255.0), (float)(fr * 255.0), (float)(fg * 255.0), (float)(fb * 255.0));
+}
+
+//-----------------------------------------------------------------
+int AWHITE(int a)
+{
+	return a << 24 | 0xffffff;
+}
+
+//-----------------------------------------------------------------
+int LerpARGB(int c1, int c2)
+{
+	int cb1, cb2;
+	const int cmask = 0x00ff00ff;
+
+	cb1 = c1 >> 8 & cmask;
+	cb2 = c2 >> 8 & cmask;
+	cb1 = cb1 + cb2 >> 1;
+
+	c1 = c1 & cmask;
+	c2 = c2 & cmask;
+	c1 = c1 + c2 >> 1;
+
+	return cb1 << 8 | c1;
+}
+
+//-------------------------------------------------------------------------
+class Link<Class T>
+{
+	proto private native void Init(T init);
+	proto private native Object Get();	
+
+	void Release()
+	{
+		T obj = Get();
+		if(obj)
+			obj.Release();
+	}	 
+	void Link(T init)
+	{
+		Init(init);
+	}
+	
+	T Ptr()
+	{
+		return Get();
+	}
+
+	bool IsNull()
+	{
+		if(!Get())
+			return true;
+		
+		return false;
+	}
+};
+

scripts/1_Core/DayZ/script.c

@@ -0,0 +1,12 @@
+//some example "reference" variables for use in material editor
+reference float g_testVariable1;
+reference float g_testVariable2;
+reference float g_testVariable3;
+
+class TestClass
+{
+	//some example "reference" variables for use in material editor
+	reference float testVar1;
+	reference float testVar2;
+	reference float testVar3;
+}

scripts/1_Core/DayZ/workbenchApi.c

@@ -0,0 +1,151 @@
+typedef int[] WBModuleDef;
+typedef int[] ScriptEditor;
+typedef int[] ResourceBrowser;
+typedef int[] WorldEditor;
+
+class Workbench
+{
+	static proto native WBModuleDef GetModule(string type);
+	static proto native bool OpenModule(string type);
+	static proto native bool CloseModule(string type);
+	static proto native void Dialog(string caption, string text);
+	static proto int ScriptDialog(string caption, string text, Class data);
+	static proto bool SearchResources(string filter, func callback);
+	static proto native int RunCmd(string command, bool wait = false);
+	static proto void GetCwd(out string currentDir);
+	static proto bool GetAbsolutePath(string relativePath, out string absPath);
+};
+
+class WBModuleDef
+{
+	proto native external bool SetOpenedResource(string filename);
+	proto native external int GetNumContainers();
+	proto native external BaseContainer GetContainer(int index = 0);
+	proto external bool GetCmdLine(string name, out string value);
+	proto native external bool Save();
+	proto native external bool Close();
+};
+
+class ScriptEditor: WBModuleDef
+{
+	proto external bool GetCurrentFile(out string filename);
+	proto native external int GetCurrentLine();
+};
+
+class ResourceBrowser: WBModuleDef
+{
+	proto external bool GetCurrentFile(out string filename);
+};
+
+class WorldEditor: WBModuleDef
+{
+	proto native external WorldEditorAPI GetAPI();
+};
+
+class WorldEditorAPI
+{
+	proto native bool BeginTerrainAction(string historyPointName = "", string historyPointIcon = "");
+	proto native void EndTerrainAction(string historyPointName = "");
+	proto native bool BeginEntityAction(string historyPointName = "", string historyPointIcon = "");	//begin of logical edit action
+	proto native bool EndEntityAction(string historyPointName = "");	//end of edit action
+	proto native bool IsDoingEditAction();	//true, if code stay betwen BeginEntityAction() and EndEntityAction()
+	proto native bool UndoOrRedoIsRestoring();		//true, if editor is restoring undo or redo state
+	proto native bool IsModifyingData();
+	proto native IEntity SourceToEntity(IEntitySource entSrc);
+	proto native IEntitySource EntityToSource(IEntity ent);
+	proto native IEntitySource FindEntityByName(string name);
+	
+	proto native external void SetEntitySelection(IEntity ent);
+	proto native external void AddToEntitySelection(IEntity ent);
+	proto native void ClearEntitySelection();
+	proto native void RemoveFromEntitySelection(IEntity ent);
+	proto native void SetPropertySelection(string id);
+	
+	proto native external bool ModifyEntityKey(IEntity ent, string key, string value);
+	proto native external bool ModifyEntityTemplateKey(IEntitySource tmpl, string key, string value);
+		
+	proto native external IEntity CreateEntity(string className, string name, int layerId, vector coords, vector angles);
+	proto native external IEntity CreateClonedEntity(IEntity ent, string name);
+	proto native external bool DeleteEntity(IEntity ent);
+	proto native bool DeleteEntities(out array<IEntity> ents);
+	proto native IEntity GetEntityUnderCursor();
+	
+	proto native external bool TraceWorldPos(int x, int y, int traceFlags, out vector traceStart, out vector traceEnd, out vector traceDir);
+
+	proto native int GetSelectedEntitiesCount();
+	proto native IEntity GetSelectedEntity(int n = 0);
+	
+	private void WorldEditorAPI() {}
+	private void ~WorldEditorAPI() {}	
+};
+
+class WorldEditorTool
+{
+	//! Filled by workbench
+	WorldEditorAPI m_API;
+	
+	void OnKeyPressEvent(int key) {}
+	void OnKeyReleaseEvent(int key) {}
+	void OnEnterEvent() {}
+	void OnLeaveEvent() {}
+	void OnMouseMoveEvent(float x, float y) {}
+	void OnMouseDoubleClickEvent(float x, float y) {}
+	void OnMousePressEvent(float x, float y) {}
+	void OnMouseReleaseEvent(float x, float y) {}
+	void OnWheelEvent(int delta) {}
+	
+	private void WorldEditorTool() {}
+	private void ~WorldEditorTool() {}
+};
+
+class WorkbenchPlugin
+{
+	void Run() {}
+	void RunCommandline() {}
+	void Configure() {}
+};
+
+class ButtonAttribute
+{
+	string m_Label;
+	bool m_Focused;
+	
+	void ButtonAttribute(string label = "ScriptButton", bool focused = false)
+	{
+		m_Label = label;
+		m_Focused = focused;
+	}
+};
+
+/*!
+Attribute for Workbench plugin definition:
+	name - ui name in Script Tools menu
+	description - tooltip
+	shortcut - shortcut in simple text form e.g. "ctrl+g"
+	icon - relative path to icon file (32x32 png)
+	wbModules - list of strings representing Workbench modules where this tool should be avalaible (e.g. {"ResourceManager", "ScriptEditor"}). Leave null or empty array for any module.
+*/
+class WorkbenchPluginAttribute
+{
+	string m_Name;
+	string m_Icon;
+	string m_Shortcut;
+	string m_Description;
+	ref array<string> m_WBModules;
+		
+	void WorkbenchPluginAttribute(string name, string description = "", string shortcut = "", string icon = "", array<string> wbModules = null)
+	{
+		m_Name = name;
+		m_Icon = icon;
+		m_Shortcut = shortcut;
+		m_Description = description;
+		m_WBModules = wbModules;
+	}
+};
+
+/*!
+Attribute for Workbench tool definition
+*/
+class WorkbenchToolAttribute: WorkbenchPluginAttribute
+{
+}

scripts/2_GameLib/DayZ/components/gameLibComponents.c

@@ -0,0 +1,276 @@
+#ifdef COMPONENT_SYSTEM
+//Generic components from GameLib (script side of c++ classes)
+
+typedef int[] IEntityComponentSource;
+class IEntityComponentSource: BaseContainer
+{
+};
+
+//!Entity touch event types
+enum TouchEvent
+{
+	ON_ENTER,
+	ON_STAY,
+	ON_EXIT
+};
+
+//!Builtin component types
+//TypeID MeshObjectTypeID;
+//TypeID HierarchyTypeID;
+//TypeID RigidBodyTypeID;
+//TypeID SphereGeometryTypeID;
+//TypeID BoxGeometryTypeID;
+
+
+class GenericComponent : Managed
+{
+	/**
+	* Gets current eventmask of the component.
+	* \return Returns bitmask of events the component accepts
+	*/
+	proto native int GetEventMask();
+	
+	/**
+	* Sets eventmask. Component accepts only events which has set bits in eventmask.
+	* Bits are or'ed with existing bitmask. See enf::EntityEvents.
+	* When this method is called in the constructor of the component, it will not properly set the eventmask to the parent entity. You may consider OnComponentInsert event.
+	* \param mask Mask of those bits, which will be set.
+	* \return Returns bitmask of events the component accepts (result of mask|GetEventMask())
+	*/
+	proto native int SetEventMask(IEntity owner, int mask);
+	
+	/**
+	* Clears bitmask. Component accepts only events which has set bits in eventmask.
+	* Only bits set in the mask are cleared. See enf::EntityEvents
+	* \param mask Mask of those bits, which will be cleared.
+	* \return returns these bits that were set before and now are cleared.
+	*/
+	proto native int ClearEventMask(IEntity owner, int mask);
+
+	/**
+	* Activate component and calls EOnActivate().
+	*/
+	proto native void Activate(IEntity owner);
+
+	/**
+	* Deactivate component and calls EOnDectivate().
+	*/
+	proto native void Deactivate(IEntity owner);
+
+	/**
+	* Returns activity state.
+	* \return Returns true, if component is active.
+	*/
+	proto native bool IsActive();
+	
+	//! Constructor
+	protected void GenericComponent(IEntityComponentSource src, IEntity ent);	
+}
+
+class GenericComponentClass
+{
+	bool DependsOn(typename otherClass, TypeID otherTypeID) {}
+}
+
+/**
+* Parent class for all components created in script.
+* Every ScriptComponent is being created in Entity's constructor and may receive following events
+* 1. OnComponentInsert is being called when component is created. This is last event Workbench sends in World Editor edit mode.
+* 2. EOnInit is being called after all components have been inserted and if the component registered event mask EV_INIT
+* 3. EOnActivate is being called if the entity was flagged as TFL_ACTIVE and if the component is active. The component is active by default.
+* 4. EOnXXXs are being called base on event mask component registered
+* 5. EOnDeactivate is being called when Deactivate is called or when the component is being to be removed. Component must be active to be deactivated.
+* 6. OnComponentRemove is being called after a component is removed.
+* 7. EOnDelete is being called after entity is going to be destroyed.
+*/
+class ScriptComponent : GenericComponent
+{
+	/*
+	Event when owner entity is touched
+	\param owner
+	Touched entity
+	\param extra
+	Bitmask of touch types TODO
+	*/
+	protected void EOnTouch(IEntity owner, int extra);
+
+	/*!
+	Event after component is initialized. At this point all entity's components have recieved OnComponentInsert.
+	\param owner
+	\param extra
+	Number of entity
+	*/
+	protected void EOnInit(IEntity owner, int extra);
+
+	/*!
+	Extra event of various functional extensions. ATM it's used
+	by Trigger when some insider is leaving
+	\param owner
+	owner actor of event
+	\param extra
+	Extra value of event
+	*/
+	protected void EOnExtra(IEntity owner, int extra);
+
+	/*!
+	Event when we are out of visibility
+	\param owner
+	\param extra
+	Frame number
+	*/
+	protected void EOnNotVisible(IEntity owner, int extra);
+
+	/*!
+	Event when we are visible
+	\param owner
+	\param extra
+	Frame number
+	*/
+	protected void EOnVisible(IEntity owner, int extra);
+
+	/*!
+	Event every frame
+	\param owner
+	\param timeSlice
+	Time passed since last frame
+	*/
+	protected void EOnFrame(IEntity owner, float timeSlice);
+
+	/*!
+	Even after physics update
+	\param owner
+	\param extra
+	Frame number
+	*/
+	protected void EOnPostFrame(IEntity owner, int extra);
+
+	/*!
+	Event from animation system
+	\param owner
+	\param extra
+	extra data
+	*/
+	protected void EOnAnimEvent(IEntity owner, AnimEvent extra);
+
+	/*!
+	Event from sound system
+	\param owner
+	\param extra
+	extra data
+	*/
+	protected void EOnSoundEvent(IEntity owner, SoundEvent extra);
+
+	/*!
+	Event after simulated by physics engine (once per frame)
+	\param owner
+	\param timeslice
+	Time slice of simulation step
+	*/
+	protected void EOnPostSimulate(IEntity owner, float timeslice);
+
+	/*!
+	Event before simulated by physics engine (called from sub-iterations!
+	\param owner
+	\param timeslice
+	Time slice of simulation step
+	*/
+	protected void EOnSimulate(IEntity owner, float timeslice);
+
+	/*!
+	Event when joint attached to RigidBody of this entity is broken
+	\param owner
+	owner Entity attached to the joint
+	\param extra
+	Not used ATM
+	*/
+	protected void EOnJointBreak(IEntity owner, int extra);
+	/*!
+	Event when physics engine has moved with this Entity
+	\param owner
+	World Entity
+	\param extra
+	Not used ATM
+	*/
+	protected void EOnPhysicsMove(IEntity owner, int extra);
+
+	/*!
+	Event when physics engine registered contact with owner RigidBody
+	\param owner
+	\param contact
+	Structure describing the contact
+	*/
+	protected void EOnContact(IEntity owner, Contact extra);
+
+	/**
+    * Event when component is activated.
+    */
+    protected void EOnActivate(IEntity owner);
+
+    /**
+    * Event when component is deactivated.
+    */
+    protected void EOnDeactivate(IEntity owner);
+
+	/*!
+	Event when a component is created and added to Entity.
+	\param owner Entity into which component is added
+	\param other Component which is being added into Entity
+	*/
+	protected void OnComponentInsert(IEntity owner, ScriptComponent other);
+
+	/*!
+	Event when a component is being removed from Entity.
+	\param owner Entity from which component is being removed
+	\param other Component which is being removed from the Entity
+	*/
+	protected void OnComponentRemove(IEntity owner, ScriptComponent other);
+
+	/*!
+	Called when Entity is being to be destroyed (deleted) or component to be deleted (see Game::DeleteScriptComponent).
+	\param owner Entity which owns the component
+	*/
+	protected void OnDelete(IEntity owner);
+}
+
+typedef int[] SoundHandle;
+
+class SignalInput
+{
+	string m_name;
+	float m_value;
+	
+	void SignalInput()
+	{
+		m_value = 0;
+	}
+};	
+
+class BaseSoundComponent : GenericComponent
+{
+	/* Get list of 'events'. */
+	proto native int GetEventNames(out array<string> events);
+	/* Get list of 'signals. '*/
+	proto native int GetSignalNames(out array<string> signals);
+	/* Convert signal name to index. */
+	proto native int GetSignalIndex(string name);
+	/* Set signal value by 'name'. */
+	proto native void SetSignalValueName(string signal, float value);
+	/* Set signal value by 'index'. */
+	proto native void SetSignalValue(int index, float value);
+	/* Play 'event'. */
+	proto native SoundHandle Play(string name);
+	/* Play sounds based on triggers. */
+	proto native SoundHandle Update();
+	/* Terminate 'sound'. */
+	proto native void Terminate(SoundHandle handle);
+	/* Check if 'sound' is played. */
+	proto native bool IsPlayed(SoundHandle handle);
+	/* Validate handle. */
+	proto native bool IsHandleValid(SoundHandle handle);
+	/* Set sound position. */
+	proto native void SetTransform(vector[] transf);
+	/* Enable debug mode. */
+	proto native void SetDebug(bool value);
+};
+
+#endif

scripts/2_GameLib/DayZ/entities/RenderTarget.c

@@ -0,0 +1,79 @@
+#ifdef GAME_TEMPLATE
+
+[EditorAttribute("box", "GameLib/Scripted", "Render target", "-0.25 -0.25 -0.25", "0.25 0.25 0.25", "255 0 0 255")]
+class RenderTargetClass
+{
+
+}
+
+RenderTargetClass RenderTargetSource;
+
+class RenderTarget: GenericEntity
+{
+	[Attribute("0", "slider", "Camera index", "0 31 1")]
+	int CameraIndex;
+	[Attribute("0", "editbox", "Position X <0, 1>")]
+	float X;
+	[Attribute("0", "editbox", "Position Y <0, 1>")]
+	float Y;
+	[Attribute("1", "editbox", "Render target width <0, 1>")]
+	float Width;
+	[Attribute("1", "editbox", "Render target height <0, 1>")]
+	float Height;
+	[Attribute("-1", "editbox", "Sort index (the lesser the more important)")]
+	int Sort;
+	[Attribute("0", "combobox", "Autoinit", "", { ParamEnum("No", "0"), ParamEnum("Yes", "1") } )]
+	int AutoInit;
+	[Attribute("0", "combobox", "Forcing creation of render target for camera #0 in Workbench", "", { ParamEnum("No", "0"), ParamEnum("Yes", "1") } )]
+	bool ForceCreation;
+	bool m_Show = true; // when autoinit, wait with showing the render target after all entities are created (EOnInit)
+	ref RenderTargetWidget m_RenderWidget;
+	
+	void RenderTarget(IEntitySource src, IEntity parent)
+	{
+		SetFlags(EntityFlags.ACTIVE, false);
+
+		if (AutoInit)
+		{
+			m_Show = false;
+			SetEventMask(EntityEvent.INIT);
+			Init();
+		}
+	}
+
+	void ~RenderTarget()
+	{
+		delete m_RenderWidget;
+	}
+	
+	void Init()
+	{
+		#ifdef WORKBENCH // Workbench is using its own renderer for main camera, it is not using render target widget.
+			if (!ForceCreation && CameraIndex == 0)
+				return;
+		#endif
+
+		int screenW, screenH;
+		GetScreenSize(screenW, screenH);
+
+		int posX = (float)(screenW * X);
+		int posY = (float)(screenH * Y);
+		int widthPix = (float)(screenW * Width);
+		int heightPix = (float)(screenH * Height);
+		if (Class.CastTo(m_RenderWidget, GetGame().GetWorkspace().CreateWidget(RenderTargetWidgetTypeID, posX, posY, widthPix, heightPix, WidgetFlags.VISIBLE | WidgetFlags.HEXACTSIZE | WidgetFlags.VEXACTSIZE | WidgetFlags.HEXACTPOS | WidgetFlags.VEXACTPOS, 0xffffffff, Sort)))
+		{	
+			m_RenderWidget.Show(m_Show);	
+			SetWidgetWorld(m_RenderWidget, GetGame().GetWorldEntity(), CameraIndex);
+		}
+	}
+	override void EOnInit(IEntity other, int extra) //!EntityEvent.INIT
+	{
+		if (m_RenderWidget)
+		{
+			m_Show = true;
+			m_RenderWidget.Show(m_Show);
+		}
+	}
+}
+
+#endif

scripts/2_GameLib/DayZ/entities/ScriptCamera.c

@@ -0,0 +1,172 @@
+#ifdef GAME_TEMPLATE
+
+[EditorAttribute("box", "GameLib/Scripted", "Script camera", "-0.25 -0.25 -0.25", "0.25 0.25 0.25", "255 0 0 255")]
+class ScriptCameraClass
+{
+
+}
+
+ScriptCameraClass ScriptCameraSource;
+
+class ScriptCamera: GenericEntity
+{
+	[Attribute("60", "slider", "Field of view", "0 180 1")]
+	float FOV;
+	[Attribute("1", "editbox", "Near plane clip")]
+	float NearPlane;
+	[Attribute("4000", "editbox", "Far plane clip")]
+	float FarPlane;
+	
+	[Attribute("1", "combobox", "Projection type", "", ParamEnumArray.FromEnum(CameraType) )]
+	int Type;
+	[Attribute("5", "slider", "Camera speed", "0 20 1")]
+	float Speed;
+	[Attribute("1", "combobox", "Free Fly", "", ParamEnumArray.FromEnum(EBool) )]
+	bool FreeFly;
+	[Attribute("0", "combobox", "Invert vertical", "", ParamEnumArray.FromEnum(EBool) )]
+	bool Inverted;
+	[Attribute("0", "slider", "Camera index", "0 31 1")]
+	int Index;
+	float m_MouseSensitivity = 0.001; // should be somewhere else.
+	float m_GamepadSensitivity = 0.2; // should be somewhere else.
+	int m_GamepadFreeFly;
+
+	// debug variables
+	int m_DbgListSelection = 0;
+	ref array<string> m_DbgOptions = {"Perspective", "Orthographic"};
+
+	void ScriptCamera(IEntitySource src, IEntity parent)
+	{
+		SetFlags(EntityFlags.ACTIVE, false);
+		SetEventMask(EntityEvent.FRAME);
+
+		SetCameraVerticalFOV(Index, FOV);
+		SetCameraFarPlane(Index, FarPlane);
+		SetCameraNearPlane(Index, NearPlane);
+		SetCameraType(Index, Type);
+		m_DbgListSelection = Type - 1;
+		SetCamera(Index, GetOrigin(), GetYawPitchRoll());
+
+		vector camMat[4];
+		GetTransform(camMat);
+		SetCameraEx(Index, camMat);
+		m_GamepadFreeFly = FreeFly;
+	}
+
+	override protected void EOnFrame(IEntity other, float timeSlice) //EntityEvent.FRAME
+	{
+		GetGame().GetInputManager().ActivateContext("ScriptCameraContext");
+		
+		if (GetGame().GetInputManager().GetActionTriggered("CamFreeFly"))
+		{
+			FreeFly = !FreeFly;
+		}
+		
+		if (FreeFly)
+		{
+			FreeFly(timeSlice);
+		}
+		else
+		{
+			vector camMat[4]; // matrix can be set outside the class
+			GetTransform(camMat);
+			SetCameraEx(Index, camMat);
+		}
+		
+		if (GameSettings.Debug)
+		{
+			DebugInfo();
+		}
+	}
+
+	protected void FreeFly(float timeSlice)
+	{
+		vector camPosition = GetOrigin();
+		vector angles = GetYawPitchRoll();
+		vector camMat[4];
+		GetTransform(camMat);	
+		InputManager imanager = GetGame().GetInputManager();
+		imanager.ActivateContext("ScriptCameraFreeFlyContext");
+		
+		// get input
+		float turnX 		= imanager.LocalValue("CamTurnRight") * 20.0 * timeSlice;
+		float turnY 		= imanager.LocalValue("CamTurnUp") * 20.0 * timeSlice;
+		float turnZ			= imanager.LocalValue("CamRotate") * 20.0 * timeSlice;
+		float moveForward	= imanager.LocalValue("CamForward");
+		float moveRight 	= imanager.LocalValue("CamRight");
+		float moveAscend 	= imanager.LocalValue("CamAscend");
+		float speedDelta   	= imanager.LocalValue("CamSpeedDelta") * timeSlice;
+		bool speedBoostHigh   	= imanager.GetActionTriggered("CamSpeedBoostHigh");
+		bool speedBoostLow  = imanager.GetActionTriggered("CamSpeedBoostLow");
+
+		Speed = Math.Clamp(Speed + speedDelta * Speed * 0.25, 0.1, 1000.0);
+		
+		float finalSpeed = Speed;
+		if (speedBoostLow)
+			finalSpeed *= 25;
+		else if (speedBoostHigh)
+			finalSpeed *= 5;
+
+		// rotation
+		angles[0] = turnX + angles[0];
+		if (Inverted)
+			angles[1] = turnY + angles[1];
+		else
+			angles[1] = -turnY + angles[1];
+
+		angles[2] = turnZ + angles[2];
+		
+		// movement
+		vector move = vector.Zero;
+		vector forward = camMat[2];
+		vector up = camMat[1];
+		vector side = camMat[0];
+		
+		move += forward * moveForward;
+		move += side    * moveRight;
+		move += up      * moveAscend;
+		
+		// ------------		
+		camPosition = (move * timeSlice * finalSpeed) + camPosition;
+		
+		Math3D.YawPitchRollMatrix(angles, camMat);
+		camMat[3] = camPosition;
+		SetTransform(camMat);
+		SetCameraEx(Index, camMat);
+	}
+
+	protected void DebugInfo()
+	{
+		InputManager imanager = GetGame().GetInputManager();
+		DbgUI.Begin(String("Camera #" + Index.ToString()), 0, Index * 300);
+
+		DbgUI.Text(String("Position : " + GetOrigin().ToString()));
+		DbgUI.Text(String("Orientation (Y, P, R): " + GetYawPitchRoll().ToString()));
+		DbgUI.Text(String("Speed : " + Speed.ToString()));
+		DbgUI.Text(String("Mouse sensitivity : " + (2000 - (1 / m_MouseSensitivity)).ToString()));
+		DbgUI.Check("Select Free fly", FreeFly);
+		DbgUI.List("Camera type", m_DbgListSelection, m_DbgOptions);
+		if (m_DbgListSelection + 1 != Type)
+		{
+			Type = m_DbgListSelection + 1;
+			SetCameraType(Index, Type);
+		}
+		
+		float sensitivity = 2000 - (1 / m_MouseSensitivity);
+		DbgUI.SliderFloat("Mouse sensitivity", sensitivity, 1, 1999);
+		m_MouseSensitivity = 1 / (2000 - sensitivity);
+		
+		DbgUI.Text("CamTurnRight: " + imanager.LocalValue("CamTurnRight"));
+		DbgUI.Text("CamTurnUp: " + imanager.LocalValue("CamTurnUp"));
+		DbgUI.Text("CamSpeedDelta: " + imanager.LocalValue("CamSpeedDelta"));
+		DbgUI.Text("CamForward: " + imanager.LocalValue("CamForward"));
+		DbgUI.Text("CamRight: " +imanager.LocalValue("CamRight"));
+		DbgUI.Text("CamAscend: " + imanager.LocalValue("CamAscend"));
+		DbgUI.Text("CamSpeedBoostHigh: " + imanager.GetActionTriggered("CamSpeedBoostHigh"));
+		DbgUI.Text("CamSpeedBoostLow:" + imanager.GetActionTriggered("CamSpeedBoostLow"));		
+		
+		DbgUI.End();
+	}
+}
+
+#endif

scripts/2_GameLib/DayZ/entities/ScriptLight.c

@@ -0,0 +1,40 @@
+#ifdef GAME_TEMPLATE
+
+[EditorAttribute("box", "GameLib/Scripted", "Script light", "-0.25 -0.25 -0.25", "0.25 0.25 0.25", "255 0 0 255")]
+class ScriptLightClass
+{
+
+}
+
+ScriptLightClass ScriptLightSource;
+
+class ScriptLight: GenericEntity
+{
+	[Attribute("1", "flags", "Flags", "", { ParamEnum("Point", "1"), ParamEnum("Spot", "2"), ParamEnum("Directional", "4") } )]
+	int Flags;
+	[Attribute("1", "combobox", "Type", "", { ParamEnum("Point", "1"), ParamEnum("Spot", "2"), ParamEnum("Directional", "3") } )]
+	int Type;
+	[Attribute("1", "editbox", "Radius", "", NULL )]
+	float Radius;
+	[Attribute("1 1 1", "color", "Color", "", NULL )]
+	vector Color;
+	[Attribute("1", "editbox", "Intensity", "", NULL )]
+	float Intensity;
+	HLIGHT m_light;
+	
+	void ScriptLight(IEntitySource src, IEntity parent)
+	{
+		//SetFlags(this, EntityFlags.ACTIVE | EntityFlags.SOLID | EntityFlags.VISIBLE);
+		m_light = AddLight(this, LightType.POINT, LightFlags.DYNAMIC|LightFlags.CASTSHADOW, Radius, Color * Intensity);
+	}
+
+	void ~ScriptLight()
+	{
+		if(m_light)
+		{
+			RemoveLight(m_light);
+		}
+	}
+}
+
+#endif

scripts/2_GameLib/DayZ/entities/ScriptModel.c

@@ -0,0 +1,62 @@
+#ifdef GAME_TEMPLATE
+
+[EditorAttribute("box", "GameLib/Scripted", "Script model", "-0.25 -0.25 -0.25", "0.25 0.25 0.25", "255 0 0 255", "0 0 0 0", true, true, true)]
+class ScriptModelClass
+{
+
+}
+
+ScriptModelClass ScriptModelSource;
+
+class ScriptModel: GenericEntity
+{
+	[Attribute("", "resourceNamePicker", "Model", "xob")]
+	string Model;
+	[Attribute("1", "combobox", "Physics", "", { ParamEnum("None", "2"), ParamEnum("Static", "1"), ParamEnum("Dynamic", "0") } )]
+	int Type;
+
+	void ScriptModel(IEntitySource src, IEntity parent)
+	{
+		if (Model== "")
+			return;
+
+		SetFlags(EntityFlags.ACTIVE | EntityFlags.SOLID | EntityFlags.VISIBLE, false);
+		
+		vobject vobj = GetObject(Model);
+		SetObject(vobj, "");
+		ReleaseObject(vobj, false);
+
+		if (Type == 1)
+		{
+			dBodyCreateStatic(this, 0xffffffff); // todo - defines for layer mask			
+		}
+		else if (Type == 0)
+		{
+			if(!dBodyCreateDynamic(this, 1.0, 0xffffffff))
+			{
+				//create implicit box
+				vector mins, maxs;
+				GetBounds(mins, maxs);
+				vector center = (mins + maxs) * 0.5;
+				vector size = maxs - mins;
+								
+				PhysicsGeomDef geoms[] = {PhysicsGeomDef("", dGeomCreateBox(size), "material/default", 0xffffffff)};
+				dBodyCreateDynamicEx(this, center, 1, geoms);
+			}
+			if(dBodyIsSet(this))
+			{
+				dBodySetMass(this, 1.0);
+				dBodyActive(this, ActiveState.ACTIVE);
+				dBodyDynamic(this, true);
+			}
+		}
+	}
+
+	void ~ScriptModel()
+	{
+		if(dBodyIsSet(this))
+			dBodyDestroy(this);
+	}
+}
+
+#endif

scripts/2_GameLib/DayZ/entities/WorldsMenu.c

@@ -0,0 +1,97 @@
+#ifdef GAME_TEMPLATE
+
+[EditorAttribute("box", "GameLib/Scripted", "Worlds menu", "-0.25 -0.25 -0.25", "0.25 0.25 0.25", "255 0 0 255")]
+class WorldsMenuClass
+{
+
+}
+
+WorldsMenuClass WorldsMenuSource;
+
+class WorldsMenu: GenericEntity
+{
+	int m_DbgListSelection = 0;
+	int m_WorldsCount = 0;
+	string DEFAULT_WORLD = "worlds/default.ent";
+	ref array<string> m_DbgOptions = {};
+	ref ImageWidget m_MouseWidget;
+	
+	void WorldsMenu(IEntitySource src, IEntity parent)
+	{
+		SetFlags(EntityFlags.ACTIVE, false);
+		SetEventMask(EntityEvent.POSTFRAME);
+		
+		Class.CastTo(m_MouseWidget, GetGame().GetWorkspace().CreateWidgets("gui/layouts/mouse.layout"));
+		m_MouseWidget.SetSort(1024);
+		SetCursorWidget(m_MouseWidget);
+		
+		LoadWorlds();
+	}
+	
+	void ~WorldsMenu()
+	{
+		delete m_MouseWidget;
+	}
+
+	array<string> GetWorldList()
+	{
+		return m_DbgOptions;
+	}
+
+	override void EOnPostFrame(IEntity other, int extra) //EntityEvent.POSTFRAME
+	{
+		InputManager im = GetGame().GetInputManager();
+		im.ActivateContext("MenuContext");
+		bool menuSelect = im.GetActionTriggered("MenuSelect");
+		bool menuBack = im.GetActionTriggered("MenuBack");
+		
+		DbgUI.Begin("Load world", 400, 100);
+
+		DbgUI.Text("Select world to load from worlds directory");
+
+		if (m_DbgOptions.Count() > 0)
+		{
+			DbgUI.List("Worlds", m_DbgListSelection, m_DbgOptions);
+			if (DbgUI.Button("Start") || menuSelect)
+			{
+				string worldToLoad = m_DbgOptions.Get(m_DbgListSelection);
+				GetGame().SetWorldFile(worldToLoad, true);
+			}
+		}
+		if (DbgUI.Button("Exit") || menuBack)
+		{
+			GetGame().RequestClose();
+		}		
+		DbgUI.End();
+	}
+
+	void LoadWorlds()
+	{
+		string fileName;
+		FileAttr fileAttr;
+		FindFileHandle worlds = FindFile("worlds/*.ent", fileName, fileAttr, 0);
+		
+		if (!worlds)
+			return;
+
+		InsertWorldToList(fileName);
+
+		while(FindNextFile(worlds, fileName, fileAttr))
+		{
+			InsertWorldToList(fileName);
+		}
+
+		CloseFindFile(worlds);
+
+		m_WorldsCount = m_DbgOptions.Count();
+	}
+
+	void InsertWorldToList(string fileName)
+	{
+		string path = String("worlds/" + fileName);
+		if (path != DEFAULT_WORLD)
+			m_DbgOptions.Insert(String(path));
+	}
+}
+
+#endif

scripts/2_GameLib/DayZ/entities/gameLibEntities.c

@@ -0,0 +1,141 @@
+//Generic entities from GameLib (script side of c++ classes)
+
+#ifdef COMPONENT_SYSTEM
+class GenericEntity extends IEntity
+{
+	//native method implemented on c++ side
+	proto native void Show(bool show);
+	
+	/*!
+	Finds first occurance of the coresponding component.
+	\param typeName type of the component
+	*/
+	proto native GenericComponent FindComponent(typename typeName);
+	
+	/*!
+	inserts instance of the script component to the entity.
+	Calls OnComponentInsert on all entity's components to inform that this new component was inserted. The new instance have to FindScriptComponents in order to work with them.
+	Calls EOnInit on the component if component sets EV_INIT mask.
+	Calls EOnActivate on the component if the component is active (default)
+	\param component instance
+	*/
+	proto native void InsertComponent(GenericComponent component);
+	
+	/*!
+	Removes component from entity. Doesn't delete the entity.
+	Calls EOnDeactivate on the component.
+	Calls OnComponentRemove on all entity's components to inform that this new component was removed.
+	\param component instance
+	*/
+	proto native void RemoveComponent(GenericComponent component);
+	
+	/*!
+	Removes and deletes component from entity.
+	Calls EOnDeactivate on the component.
+	Calls OnComponentRemove on all entity's components to inform that this new component was removed.
+	Calls OnDelete on the component.
+	\param component instance
+	*/
+	proto native void DeleteComponent(GenericComponent component);
+
+#ifdef WORKBENCH
+	/*!
+	Called after updating world in Workbench. The entity must be selected.
+	*/
+	void _WB_AfterWorldUpdate(float timeSlice) {};
+#endif
+}
+
+class GenericWorldEntity extends GenericEntity
+{
+}
+
+class GenericTerrainEntity extends GenericEntity
+{
+}
+
+class LightEntity extends GenericEntity
+{
+	/*!
+	Sets diffuse part of light.
+	\param color Color of light
+	*/
+	proto native external void SetDiffuseColor(int color);
+	proto native external int GetDiffuseColor();
+	
+	proto native external void SetRadius(float radius);
+	proto native external float GetRadius();
+	
+	/*!
+	Sets cone of light. It's meaningful for LT_SPOT only!
+	\param angle
+	*/
+	proto native external void SetConeAngle(float angle);
+	/*!
+	Gets cone of light. It's meaningful for LT_SPOT only!
+	\return Cone of light
+	*/
+	proto native external float GetConeAngle();
+	
+	proto native external void SetCastShadow(bool enable);
+	proto native external bool IsCastShadow(bool enable);
+}
+
+class GenericWorldLightEntity extends GenericEntity
+{
+}
+
+class GenericWorldFogEntity extends GenericEntity
+{
+}
+
+class BasicEntity extends GenericEntity
+{
+}
+
+class WorldEntityClass
+{
+}
+
+class WorldEntity extends GenericWorldEntity
+{
+}
+
+class ModelEntity extends BasicEntity
+{
+}
+
+enum CharacterMovement
+{
+	MOVEMENTTYPE_IDLE,
+	MOVEMENTTYPE_WALK,
+	MOVEMENTTYPE_RUN,
+	MOVEMENTTYPE_SPRINT
+};
+
+enum CharacterStance
+{
+	STANCE_ERECT,
+	STANCE_CROUCH,
+	STANCE_PRONE,
+	STANCE_ERECT_RAISED,
+	STANCE_CROUCH_RAISED,
+	STANCE_PRONE_RAISED
+};
+
+class CharacterEntity extends BasicEntity
+{
+	proto native void Teleport(vector transform[4]);
+	proto native CharacterMovement GetCurrentMovement();
+	proto native CharacterStance GetCurrentStance();
+}
+
+class BasicCamera extends BasicEntity
+{
+}
+
+class VRHandEntity extends GenericEntity
+{
+}
+
+#endif

scripts/2_GameLib/DayZ/gameLib.c

@@ -0,0 +1,158 @@
+#ifdef GAME_TEMPLATE
+Game g_Game;
+
+Game GetGame()
+{
+	return g_Game;
+}
+
+class Game
+{
+	ScriptModule GameScript;
+	
+	ScriptModule GetScriptModule()
+	{
+		return GameScript;
+	}
+	
+	void SetDebug(bool isDebug) {}
+	//! 
+	/**
+  	\brief Called when some system event occur.
+  	@param eventTypeId event type.
+	@param params Param object, cast to specific param class to get parameters for particular event.
+	*/
+	void OnEvent(EventType eventTypeId, Param params)
+	{
+		Print("OnEvent");
+	}
+
+	/**
+	\brief Called after full initialization of Game instance
+	*/
+	void OnAfterInit()
+	{
+		Print("OnAfterInit");
+	}
+	
+	/**
+  	\brief Called on World update
+	@param timeslice time elapsed from last call
+	*/
+	void OnUpdate(float timeslice) 
+	{
+
+	}
+
+	/**
+  	\brief Sets world file to be loaded. Returns false if file doesn't exist.
+	@param path Path to the ent file
+	@param reload Force reload the world
+	*/
+	proto native bool SetWorldFile(string path, bool reload);
+
+	/**
+  	\brief Returns path of world file loaded
+	*/
+	proto native owned string GetWorldFile();
+
+	/**
+  	\brief Event which is called right before game starts (all entities are created and initialized). Returns true if the game can start.
+	*/
+	bool OnGameStart()
+	{
+		return true;
+	}
+
+	/**
+  	\brief Event which is called right before game end.
+	*/
+	void OnGameEnd()
+	{
+	}
+
+	/**
+  	\brief Creates loading screen
+	*/
+	void ShowLoadingAnim()
+	{
+	}
+
+	/**
+  	\brief Hides loading screen
+	*/
+	void HideLoadingAnim()
+	{
+	}
+
+	/**
+  	\brief Used for updating the loading screen
+	@param timeslice
+	@param progress loading progress between 0 and 1
+	*/
+	void UpdateLoadingAnim(float timeslice, float progress)
+	{
+	}
+
+	/**
+	\brief Safely instantiate the entity and calls EOnInit if the entity sets event mask EntityEvent.INIT.
+	@param typename Name of entity's type to instantiate.
+	@return instantiated entity
+	*/
+	proto native IEntity SpawnEntity(typename typeName);
+
+	/**
+	\brief Safely instantiate the entity from template (with all components) and calls EOnInit if the entity sets event mask EntityEvent.INIT.
+	@param templateResource Template resource of the entity to instantiate.
+	@return instantiated entity
+	*/
+	proto native IEntity SpawnEntityTemplate(vobject templateResource);
+
+	/**
+	\brief Safely instantiate the component from template, insert it to entity and calls EOnInit if the component sets event mask EntityEvent.INIT.
+	@param owner Entity which will own the component
+	@param templateResource Template resource of the component to instantiate.
+	@return instantiated component
+	*/
+	proto native GenericComponent SpawnComponentTemplate(IEntity owner, vobject templateResource);
+
+	proto native IEntity FindEntity(string name);
+
+	proto native WorkspaceWidget GetWorkspace();
+
+	/**
+	\brief Setting request flag for engine to exit the game
+	*/
+	proto native void RequestClose();
+
+	/**
+	\brief Setting request flag for the engine to reinitialize the game
+	* Doesn't do anything in Workbench
+	*/
+	proto native void RequestReload();
+
+	/**
+	\brief Returns version of the game
+	*/
+	proto native owned string GetBuildVersion();
+
+	/**
+	\brief Returns date and time when the game was built
+	*/
+	proto native owned string GetBuildTime();
+
+	/**
+  	\brief Returns World entity when in game or in play mode in WE. NULL otherwise.
+	*/
+	proto native GenericWorldEntity GetWorldEntity();
+	
+	proto native InputManager GetInputManager();
+	proto native MenuManager GetMenuManager();
+	proto native int GetTickCount();
+}
+
+void GameLibInit()
+{
+
+}
+#endif

scripts/2_GameLib/DayZ/inputManager.c

@@ -0,0 +1,46 @@
+#ifdef GAME_TEMPLATE
+
+enum InputTrigger
+{
+	UP, 			///< call listener when button/key is released
+	DOWN,		 	///< call listener when button/key is pressed
+	PRESSED, 		///< call listener in each tick when button/key is pressed
+	VALUE		 	///< call listener in each tick with current value
+};
+
+class ActionManager
+{
+	void ActionManager(ActionManager parent);
+	proto native external bool RegisterAction(string actionName);
+	proto native external bool RegisterContext(string contextName);
+	
+	proto native external float LocalValue(string actionName);
+	proto native external bool GetActionTriggered(string actionName);
+	
+	proto native external bool ActivateAction(string actionName, int duration = 0);	
+	proto native external bool IsActionActive(string actionName);
+	
+	proto native external bool ActivateContext(string contextName, int duration = 0);	
+	proto native external bool IsContextActive(string contextName);
+	
+	proto external void AddActionListener(string actionName, InputTrigger trigger,  func callback);
+	
+	proto native external void SetContextDebug(string contextName, bool bDebug);
+	
+	proto native void SetParent(ActionManager parent);
+	proto native void SetDebug(bool bDebug);
+};
+
+class InputManager: ActionManager
+{
+	private void InputManager(ActionManager parent) {};
+	private void ~InputManager() {};
+	
+	proto native external void ResetAction(string actionName);
+	proto native void SetCursorPosition(int x, int y);
+	proto native external bool RegisterActionManager(ActionManager pManager);
+	proto native external bool UnregisterActionManager(ActionManager pManager);
+};
+
+#endif
+

scripts/2_GameLib/DayZ/menuManager.c

@@ -0,0 +1,95 @@
+#ifdef GAME_TEMPLATE
+
+enum DialogPriority
+{
+	INFORMATIVE,
+	WARNING,
+	CRITICAL	
+};
+
+enum DialogResult
+{
+	PENDING,
+	OK,
+	YES,
+	NO,
+	CANCEL,
+};
+
+enum ScriptMenuPresetEnum
+{
+	
+};
+
+class MenuManager
+{
+	proto native MenuBase OpenMenu(ScriptMenuPresetEnum preset, int userId = 0, bool unique = false);
+	proto native MenuBase OpenDialog(ScriptMenuPresetEnum preset, int priority = DialogPriority.INFORMATIVE, int iUserId = 0, bool unique = false);
+	proto native MenuBase FindMenuByPreset(ScriptMenuPresetEnum preset);
+	proto native MenuBase FindMenuByUserId(int userId);
+	proto native MenuBase GetTopMenu();
+	
+	proto native bool IsAnyMenuOpen();	
+	proto native bool IsAnyDialogOpen();
+
+	proto native bool CloseMenuByPreset(ScriptMenuPresetEnum preset);
+	proto native bool CloseMenuByUserId(int userId);
+	proto native bool CloseMenu(MenuBase menu);
+	
+	protected void MenuManager();
+	protected void ~MenuManager();
+};
+
+class MenuBindAttribute
+{
+	string m_MenuItemName;
+	
+	void MenuBindAttribute(string menuItemName = "")
+	{
+		m_MenuItemName = menuItemName;
+	}
+}
+
+class MenuBase: ScriptedWidgetEventHandler
+{
+	proto native int GetUserId();
+	proto native Widget GetRootWidget();
+	proto external MenuBase BindItem(string menuItemName, func callback);
+	proto native MenuBase SetLabel(string menuItemName, string text);
+	proto native Widget GetItemWidget(string menuItemName);
+	proto native MenuManager GetManager();
+	proto native void Close();
+	
+	void	OnMenuFocusGained() {}
+	void	OnMenuFocusLost() {}
+	void	OnMenuShow() {}
+	void	OnMenuHide() {}
+	void	OnMenuOpen() {}
+	void	OnMenuClose() {}
+	void	OnMenuInit() {}
+	void	OnMenuUpdate(float tDelta) {}
+	void	OnMenuItem(string menuItemName, bool changed, bool finished) {}
+	
+	protected void MenuBase();
+	protected void ~MenuBase();
+};
+
+class MessageBox: MenuBase
+{
+	[MenuBindAttribute()]
+	void Ok()
+	{
+		Close();
+	}
+}
+
+#ifdef PLATFORM_WINDOWS
+class WorldEditorIngame: MenuBase
+{
+	proto native bool LoadWorld(string worldFilePath);
+	proto native bool SaveWorld();
+};
+#endif
+
+#endif
+

scripts/2_GameLib/DayZ/settings.c

@@ -0,0 +1,38 @@
+#ifdef GAME_TEMPLATE
+
+class Settings
+{
+	static void		OnChange(string variableName) {}
+	static void 	OnAnyChange() {}	
+	static void 	OnLoad() {}
+	static void 	OnSave() {}
+	static void 	OnReset() {}
+	static void 	OnRevert() {}
+	static void 	OnApply() {}
+	
+	private void Settings() {}
+	private void ~Settings() {}
+};
+
+class GameSettings: Settings
+{
+	[Attribute("false", "checkbox", "Is debug mode enabled")]
+	static bool Debug;
+	
+	override static void OnAnyChange() 
+	{
+		GetGame().SetDebug(Debug);
+	}
+}
+
+class SettingsMenu: MenuBase
+{
+	proto native external bool AddSettings(typename settingsClass);	
+	proto native void Save();	
+	proto native void Reset();
+	proto native void Revert();
+	proto native void Apply();
+	proto native void Back();
+};
+#endif
+

scripts/2_GameLib/DayZ/tools.c

@@ -0,0 +1,216 @@
+/**
+ \brief ScriptCallQueue Class provide "lazy" calls - when we don't want to execute function immediately but later during frame update (used mainly in UI)
+ \n usage:
+ @code
+	class Arkanoid extends Game
+	{
+		ref ScriptCallQueue m_CallQueue = new ScriptCallQueue();
+	
+		ScriptCallQueue GetCallQueue() { 
+			return m_CallQueue;
+		}
+	
+		override void OnUpdate(float timeslice)
+		{
+			m_CallQueue.Tick(timeslice);
+			...
+		}
+		...
+	}
+
+	class MyObject
+	{
+		int m_cnt = 0;
+	
+		void Hello(int p1, string p2)
+		{
+			Print("Hello( " + p1 + " , " + p2 + ")");
+		}
+	
+		void Test()
+		{
+			Print(m_cnt);
+			m_cnt++;
+			
+			if (m_cnt > 10)
+			{
+				ScriptCallQueue queue = GetGame().GetCallQueue();
+				queue.Remove(Test);
+			}
+		}
+	}
+
+	void Test(MyObject obj)
+	{
+		ScriptCallQueue queue = GetGame().GetCallQueue(); 
+		queue.CallLater(obj.Hello, 5000, false, 65, "world"); // adds call 'obj.Hello(65, "world")' into queue, and it will be executed once after 5s
+		queue.CallLater(obj.Test, 3000, true); // adds call 'obj.Test()' into queue, and it will be executed each 3s
+		queue.Call(obj.Hello, 72, "world 2"); // adds call 'obj.Hello(72, "world 2")' into queue, and it will be executed next frame (on next call of ScriptCallQueue.Tick)
+	}
+ @endcode
+ */
+class ScriptCallQueue
+{
+	//! executes calls on queue if their time is already elapsed, if 'repeat = false' call is removed from queue
+	proto native void Tick(float timeslice);
+	//! adds call into the queue with given parameters and arguments (arguments are held in memory until the call is executed/removed or ScriptCallQueue is destroyed)
+	proto void Call(func fn, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+	//! adds call into the queue with given parameters and arguments (arguments are held in memory until the call is executed/removed or ScriptCallQueue is destroyed)
+	proto void CallByName(Class obj, string fnName , Param params = NULL);
+	//! adds call into the queue with given parameters and arguments (arguments are held in memory until the call is executed/removed or ScriptCallQueue is destroyed)
+	proto void CallLater(func fn, int delay = 0, bool repeat = false, void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);	
+	//! adds call into the queue with given parameters and arguments (arguments are held in memory until the call is executed/removed or ScriptCallQueue is destroyed)
+	proto void CallLaterByName(Class obj, string fnName, int delay = 0, bool repeat = false, Param params = NULL);	
+	//! remove specific call from queue	
+	proto void Remove(func fn);
+	//! return Remaining time to the call execution (in miliseconds)
+	proto int GetRemainingTime(func fn);
+	//! remove specific call from queue	
+	proto void RemoveByName(Class obj, string fnName);
+	//! return Remaining time to the call execution (in miliseconds)
+	proto int GetRemainingTimeByName(Class obj, string fnName);
+	//! remove all calls from queue
+	proto native void Clear();
+};
+
+/**
+ \brief ScriptInvoker Class provide list of callbacks
+ \n usage:
+ @code
+	class Player
+	{
+		ref ScriptInvoker m_DeathInvoker	= new ScriptInvoker();
+	
+		void OnKilled()
+		{
+			m_DeathInvoker.Invoke(this);		
+		}
+	}
+
+	void LogPlayerDeath(p)
+	{
+		Print("RIP " + p);
+	}		
+
+	class Game
+	{
+		void RemovePlayer(Player p)
+		{
+		}
+
+		void GameOver()
+		{
+		}
+	}
+
+	void OnPlayerSpaned(Player p)
+	{
+		Game game = GetGame();
+		p.m_DeathInvoker.Insert(LogPlayerDeath);
+		p.m_DeathInvoker.Insert(game.RemovePlayer);
+		p.m_DeathInvoker.Insert(game.GameOver);
+	}
+ @endcode
+ */
+class ScriptInvoker
+{
+	//! invoke call on all inserted methods with given arguments
+	proto void Invoke(void param1 = NULL, void param2 = NULL, void param3 = NULL, void param4 = NULL, void param5 = NULL, void param6 = NULL, void param7 = NULL, void param8 = NULL, void param9 = NULL);
+	//! insert method to list
+	proto bool Insert(func fn, int flags = EScriptInvokerInsertFlags.IMMEDIATE);	
+	//! remove specific call from list
+	proto bool Remove(func fn, int flags = EScriptInvokerRemoveFlags.ALL);
+	//! count how many times this fn is actively present in the Invoker
+	proto int Count(func fn);
+	//! remove all calls from list
+	proto native void Clear();
+};
+
+enum EScriptInvokerInsertFlags
+{
+	NONE,
+	/**
+	\brief It gets added in immediately, which means that when called while an invoker is running, it will call this newly added call in the same run
+		\note Default flag, as that is the original behaviour, although it might cause endless Insert chain now... (still better than undefined behaviour)
+		\note In case of "Possible endless Insert detected" VME, either create an exit, remove the IMMEDIATE flag or make the insert UNIQUE
+		\note The Endless Insert is detected by seeing if "amount of calls > initial size + 128"
+	*/
+	IMMEDIATE,
+	/**
+	\brief Only one call to this instance+method is ever expected
+		\note Will throw a VME when a second one is attempted to be added
+		\note If it was already added without the flag, it will also throw a VME and keep the first of all previously inserted
+	*/
+	UNIQUE,
+}
+
+enum EScriptInvokerRemoveFlags
+{
+	NONE,
+	/**
+	\brief Default flag
+		\note Don't use this if you want it to remove only the last insert instead of all of them
+	*/
+	ALL,
+}
+
+/**
+ \brief Designed to hold 1 valid call
+*/
+class ScriptCaller
+{
+	//! ScriptCaller is meant to be created through Create
+	private void ScriptCaller();
+	//! Creates a ScriptCaller
+	static proto ScriptCaller Create(func fn);
+	//! Replaces the current registered func with the new one, throws errors if unsuccessful
+	proto void Init(func fn);	
+	//! Invoke call on the registered func, throws errors if unsuccessful
+	proto void Invoke(void param1 = null, void param2 = null, void param3 = null, void param4 = null, void param5 = null, void param6 = null, void param7 = null, void param8 = null, void param9 = null);
+
+	//! Checks if the ScriptCaller is valid
+	proto bool IsValid();
+
+	/**
+	\brief Compares this script caller against another script caller
+		\note May return true even if either one is invalid
+
+	@code
+		class SomeClass
+		{
+			void SomeMethod()
+			{
+			}
+		}
+
+		void Test()
+		{
+			SomeClass instanceA = new SomeClass();
+			SomeClass instanceB = new SomeClass();
+
+			ScriptCaller callerA;
+			ScriptCaller callerB;
+
+			//! Two methods that are to the same instance
+			callerA = ScriptCaller.Create(instanceA.SomeMethod);
+			callerB = ScriptCaller.Create(instanceA.SomeMethod);
+
+			Print(callerA.Equals(callerB)); //! "1"
+			Print(callerA == callerB); //! "0"
+			Print(callerA); //! "ScriptCaller callerA = ScriptCaller<87bc2d40>"
+			Print(callerB); //! "ScriptCaller callerB = ScriptCaller<87bc3600>"
+
+			//! Two methods belonging to different instances
+			callerA = ScriptCaller.Create(instanceA.SomeMethod);
+			callerB = ScriptCaller.Create(instanceB.SomeMethod);
+
+			Print(callerA.Equals(callerB)); //! "0"
+			Print(callerA == callerB); //! "0"
+			Print(callerA); //! "ScriptCaller callerA = ScriptCaller<87bc3c40>"
+			Print(callerB); //! "ScriptCaller callerB = ScriptCaller<87bc2d40>"
+		}
+	@endcode
+	*/
+	proto bool Equals(notnull ScriptCaller other);
+
+};

scripts/3_Game/DayZ/AI/AIAgent.c

@@ -0,0 +1,8 @@
+class AIAgent : Managed
+{
+	private void AIAgent();
+	private void ~AIAgent();
+	
+	proto native void SetKeepInIdle(bool enable);
+	proto native AIGroup GetGroup();
+}

scripts/3_Game/DayZ/AI/AIGroup.c

@@ -0,0 +1,15 @@
+class AIGroup : Managed
+{
+	private void AIGroup();
+	private void ~AIGroup();
+	
+	/*!
+	Manual group management - add / remove agents from group.
+	Don't forget to remove agent from old group.
+	Caution! Empty groups are deleted on the next frame.
+	*/
+ 	proto native void AddAgent(notnull AIAgent agent);
+ 	proto native void RemoveAgent(notnull AIAgent agent);
+	
+	proto native AIGroupBehaviour GetBehaviour();
+};

scripts/3_Game/DayZ/AI/AIGroupBehaviour.c

@@ -0,0 +1,32 @@
+class AIGroupBehaviour : Managed
+{
+	private void AIGroupBehaviour();
+	private void ~AIGroupBehaviour();
+}
+
+class BehaviourGroupInfectedPackWaypointParams
+{
+	vector m_CenterPosition;
+	float m_Radius;
+	
+	void BehaviourGroupInfectedPackWaypointParams(vector pos, float radius)
+	{
+		m_CenterPosition = pos;
+		m_Radius = radius;
+	}
+}
+
+class BehaviourGroupInfectedPack : AIGroupBehaviour
+{
+	/*!
+	Group waypoints initialization
+	/param 	[in] 	waypointDefaultIndex 		Starting waypoint. Index to array of waypoints specified by waypointParams. Acceptable range is [0, waypointParams.Count() - 1]
+	/param 	[in]	forwardDirection			Waypoints traverse order.
+	/param 	[in]	loop						Specifies what happens after last waypoint is reached. true - cycle waypoints, false - patrol waypoints
+	*/
+	proto native void SetWaypoints(array<ref BehaviourGroupInfectedPackWaypointParams> waypointParams, int waypointDefaultIndex, bool forwardDirection, bool loop);
+
+	proto native void SetWaypointsTraverseDirection(bool forwardDirection);
+	proto native void SetWaypointsLoop(bool loop);
+	proto native void SetCurrentWaypoint(int waypointIndex);
+}

scripts/3_Game/DayZ/AI/AIWorld.c

@@ -0,0 +1,123 @@
+enum PGPolyFlags
+{
+	NONE,
+
+	WALK,			// Ability to walk (ground, grass, road)
+	DISABLED,		// Disabled polygon
+	DOOR,			// Ability to move through doors
+	INSIDE,			// Ability to move inside buildings
+
+	SWIM,			// Ability to swim (water)
+	SWIM_SEA,		// Ability to swim (sea water)
+
+	LADDER,			// Ability to climb on ladders
+	JUMP_OVER,		// Ability to do jumps overs
+	JUMP_DOWN,		// Ability to jump down
+	CLIMB,			// Ability to climb up
+	CRAWL,			// Ability to crawl
+	CROUCH,			// Ability to crouch
+
+	UNREACHABLE,
+
+	ALL,
+
+	JUMP,			// JUMP_OVER | JUMP_DOWN
+	SPECIAL			// JUMP | CLIMB | CRAWL | CROUCH
+}
+
+enum PGAreaType
+{
+	NONE,
+
+	TERRAIN,
+
+	WATER,
+	WATER_DEEP,
+	WATER_SEA,
+	WATER_SEA_DEEP,
+	OBJECTS_NOFFCON,
+
+	OBJECTS,
+	BUILDING,
+	ROADWAY,
+	TREE,
+	ROADWAY_BUILDING,
+
+	DOOR_OPENED,
+	DOOR_CLOSED,
+
+	LADDER,
+	CRAWL,
+	CROUCH,
+	FENCE_WALL,
+	JUMP
+}
+
+/*!
+Filter for FindPath, RaycastNavMesh, SampleNavmeshPosition
+*/
+class PGFilter : Managed
+{
+	// Uses PGPolyFlags bitmasks
+	proto native int GetIncludeFlags();
+	proto native int GetExcludeFlags();
+	proto native int GetExlusiveFlags();
+	proto native void SetFlags(int includeFlags, int excludeFlags, int exclusiveFlags);
+
+	proto native void SetCost(PGAreaType areaType, float cost);
+}
+
+class AIWorld : Managed
+{
+	private void AIWorld();
+	private void ~AIWorld();
+
+	/*!
+	Creates group with group behaviour specified by templateName param.
+	AIGroups lifetime is managed by AIWorld, e.g. empty groups are deleted automatically.
+	*/
+	proto native AIGroup CreateGroup(string templateName);
+	/*!
+	Creates group with no group behaviour
+	*/
+	proto native AIGroup CreateDefaultGroup();
+	/*!
+	Destroys group and all AIAgents attached
+	*/
+	proto native void DeleteGroup(notnull AIGroup group);
+	
+	/*!
+	Finds path on navmesh using path graph filter. 
+	
+	/param 	[in]	from 			starting position
+	/param 	[in] 	to 				ending position
+	/param 	[in] 	pgFilter 		filter used for searching
+	/param 	[out] 	waypoints		waypoints array including starting and ending position
+	/returns	true - if path has been found
+	*/
+	proto native bool FindPath(vector from, vector to, PGFilter pgFilter, out TVectorArray waypoints);
+	
+	/*!
+	Raytest in navmesh
+	
+	/param 	[in]	from 			starting position
+	/param 	[in] 	to 				ending position
+	/param 	[in] 	pgFilter 		filter used for searching
+	/param 	[out] 	hitPos			hit position
+	/param 	[out] 	hitNormal		hit normal
+	/returns	true - if ray hits navmesh edge
+	*/
+	proto native bool RaycastNavMesh(vector from, vector to, PGFilter pgFilter, out vector hitPos, out vector hitNormal);
+	
+	/*!
+	Finds closest point on navmesh within maxDistance radius using path graph filter. 
+	
+	/param 	[in]	position 			position wanted
+	/param 	[in] 	maxDistance 		search radius
+	/param 	[in] 	pgFilter 		filter used for searching
+	/param 	[out] 	sampledPosition		closest position on navmesh to position
+	/returns	true - function succeedes and found position is written to output paramter "sampledPosition"
+	/returns	false - function failed to find position on navmesh within given radius, output paramter is left intact
+	*/
+	proto native bool SampleNavmeshPosition(vector position, float maxDistance, PGFilter pgFilter, out vector sampledPosition);	
+}

scripts/3_Game/DayZ/AIBehaviour.c

@@ -0,0 +1,147 @@
+/** @file 
+
+  this file is interface to AI Behaviour
+
+*/
+
+/*
+class AIMessage: Managed
+
+{
+	Param m_Parameters;
+	int m_CrcMessage;
+	Param GetParameters();
+	int GetTypeNameCRC();
+}
+
+class AIMessageTest : AIMessage
+{
+	int GetTypeNameCRC() {return testCRC;}
+	//static int testCRC = 5;	
+}
+
+*/
+
+
+class AIBehaviourHLData
+{
+	private void AIBehaviourHLData() {}
+	private void ~AIBehaviourHLData() {}
+	
+	//void ParseConfig(ParamEntryPar param, AIWorld* world, AIAgentTemplate* agentTemplate) {};
+	void OnParseConfig();	
+	
+	//Can be use only inside OnParseConfig function
+	proto native void ParseBehaviourSlot(string name);
+	proto native void ParseAlertLevel(string name);
+	proto native float ReadParamValue(string paramName, float defValue);
+	
+}
+
+
+class AIBehaviourHL
+{
+	private void AIBehaviourHL() {}
+	private void ~AIBehaviourHL() {}
+	
+	proto native AIBehaviourHLData GetTemplateData();
+	
+	void OnInit(){};
+	//private void AIBehaviourHL_script() {};
+	//private void ~AIBehaviourHL_script() {};
+
+	void Simulate (float timeDelta)
+	{
+		//time = time + timeDelta; 
+		//Print("A2");
+	}
+	
+	
+	//void OnNoise(AINoiseInfo noise, EntityAI source){}
+	void OnDamage(float damage, EntityAI source){}
+
+	void OnDamageInflicted(){}
+	void OnAnimationEvent(int nameCrc){}
+	//void OnMessage(AIMessage message){}
+	//void OnBehaviourSwitched(AIBehaviour* behaviour){}
+	proto native void SetNextBehaviour(int BehaviourCrc);
+	proto native void SwitchToNextBehaviour();
+	
+	static proto void RegAIBehaviour(string behname,typename behClass, typename behClassData);
+};
+
+
+class AIBehaviourHLZombie2 : AIBehaviourHL
+{
+	//AIBehaviourHLDataZombie2 data;
+	//int state;
+	//float time;
+	AIBehaviourHLDataZombie2 GetData()
+	{
+		return AIBehaviourHLDataZombie2.Cast( GetTemplateData() );
+	}
+	
+	private void AIBehaviourHLZombie2() {}
+	private void ~AIBehaviourHLZombie2() {}
+	
+	override void OnInit()
+	{
+		SetNextBehaviour(0x7b9a4ee9);
+		SwitchToNextBehaviour();
+		//Print("OnInit");
+		//data = GetData();
+		//float a = data.m_fDamageToCrawl;
+		//Print(a);
+	}
+	
+	override void Simulate (float timeDelta)
+	{
+		//time = time + timeDelta; 
+		//Print("B2");
+	}
+	
+	void ShowDebugInfo() 
+	{
+		//Print(time);
+	};
+	
+	//void OnMessage(AIMessage message)
+	//{
+		//int ID = message.GetTypeNameCRC();
+		//Print(ID);
+		
+	//}
+};
+
+class AIBehaviourHLDataZombie2 : AIBehaviourHLData
+{
+	float m_fDamageToCrawl;
+	float m_fCrawlProbability;
+
+	private void AIBehaviourHLDataZombie2() {}
+	private void ~AIBehaviourHLDataZombie2() {}
+	
+	override void OnParseConfig()
+	{
+		Print("zombie data parse config start");
+		
+		ParseBehaviourSlot("Calm");
+		ParseBehaviourSlot("Attracted");
+		ParseBehaviourSlot("Disturbed");
+		ParseBehaviourSlot("Alerted");
+		
+		ParseAlertLevel("Calm");
+		ParseAlertLevel("Disturbed");
+		ParseAlertLevel("Attracted");
+		ParseAlertLevel("Alerted");
+		
+		m_fDamageToCrawl = ReadParamValue("damageToCrawl",0.01);
+		m_fCrawlProbability = ReadParamValue("crawlProbability",0.01);
+		
+		Print("zombie data parse config end");
+	}
+};
+
+//NewNPC(model,behname,....)
+
+

scripts/3_Game/DayZ/AmmoCamParams.c

@@ -0,0 +1,17 @@
+class AmmoCamParams
+{
+	void Load(string ammoType)
+	{
+		string cfgPath = "CfgAmmo " + ammoType + " Effects" + " CameraShake ";
+		
+		m_Radius				= GetGame().ConfigGetFloat(cfgPath + "radius");
+		m_Strength				= GetGame().ConfigGetFloat(cfgPath + "strength");
+		m_ModifierClose			= GetGame().ConfigGetFloat(cfgPath + "modifierClose");
+		m_ModifierFar			= GetGame().ConfigGetFloat(cfgPath + "modifierFar");
+	}
+	
+	float m_Radius = 40;//the max distance at which the cam shake is triggered
+	float m_Strength = 4;//strength of the cam shake
+	float m_ModifierClose = 1;//shake 'strength' modifier when the player is at distance 0 from the source of explosion
+	float m_ModifierFar = 0;//shake 'strength' modifier when the player is at distance 'radius' from the source of explosion
+}

scripts/3_Game/DayZ/AmmoEffects.c

@@ -0,0 +1,137 @@
+/**
+\brief Static data holder for certain ammo config values
+	\note Kept the names similar to what is in config, but it might be a little deceiving as this is mainly used for explosives
+*/
+class AmmoEffects
+{	
+	//! Key: Ammo class name; Data: ParticleList ID
+	static ref map<string, int> m_AmmoParticles;
+	
+	//! Key: Ammo class name; Data: ParticleList ID
+	static ref map<string, typename> m_AmmoEffects;
+	
+	
+	
+	/** \name Ammo particles
+ 		Methods regarding getting/playing ammo particle
+	*/
+	//@{
+	
+	//! Get the ParticleList ID for the particle for this ammoType
+	static int GetAmmoParticleID(string ammoType)
+	{
+		int particleID;
+		
+		// Search for it in the static map
+		if ( !m_AmmoParticles.Find(ammoType, particleID) )
+		{
+			// Load it in when we can't find it
+			string particleFileName;
+			GetGame().ConfigGetText(string.Format("cfgAmmo %1 particle", ammoType), particleFileName);
+			
+			// If we found a valid entry, try looking for it in ParticleList
+			if ( particleFileName != "" )
+			{
+				particleID = ParticleList.GetParticleIDByName(particleFileName);
+			}
+			
+			// Store it for next search
+			m_AmmoParticles.Insert(ammoType, particleID);
+		}
+		
+		return particleID;
+	}
+	
+	//! Attempt to play the ammo particle at pos if found, returns true on success
+	static bool PlayAmmoParticle(string ammoType, vector pos)
+	{
+		int particleID = GetAmmoParticleID(ammoType);
+		
+		if (ParticleList.IsValidId(particleID))
+		{
+			return ParticleManager.GetInstance().PlayInWorld(particleID, pos) != null;
+		}
+		
+		return false;
+	}
+	
+	//@}
+	
+	
+	
+	/** \name Ammo effects
+ 		Methods regarding getting/playing ammo effect
+	*/
+	//@{
+	
+	//! Get the typename for the effect for this ammoType
+	static typename GetAmmoEffectTypename(string ammoType)
+	{
+		typename typeName;
+		
+		// Search for it in the static map
+		if ( !m_AmmoEffects.Find(ammoType, typeName) )
+		{
+			// Load it in when we can't find it
+			string effectName;
+			GetGame().ConfigGetText(string.Format("cfgAmmo %1 effect", ammoType), effectName);
+			
+			// If we found a valid entry, try looking for it in ParticleList
+			if ( effectName != "" )
+			{
+				typeName = effectName.ToType();
+			}
+			
+			// Store it for next search
+			m_AmmoEffects.Insert(ammoType, typeName);
+		}
+		
+		return typeName;
+	}
+	
+	//! Attempt to play the ammo effect at pos if found, returns true on success
+	static bool PlayAmmoEffect(string ammoType, vector pos)
+	{
+		typename typeName = GetAmmoEffectTypename(ammoType);
+		
+		if ( typeName )
+		{
+			Effect eff = Effect.Cast(typeName.Spawn());
+			
+			if ( eff )
+			{
+				eff.SetAutodestroy(true);
+				return SEffectManager.PlayInWorld( eff, pos );
+			}
+		}
+		
+		return false;
+	}
+	
+	//@}
+	
+	
+	
+	/** \name Lifetime
+ 		Creation and cleanup
+	*/
+	//@{
+	
+	//! Initialize the containers: this is done this way, to have these not exist on server
+	static void Init()
+	{
+		m_AmmoParticles = new map<string, int>();
+		m_AmmoEffects = new map<string, typename>();
+	}
+	
+	//! Clean up the data
+	static void Cleanup()
+	{
+		/* These ain't containing no refs, so whatever
+		m_AmmoParticles.Clear();
+		m_AmmoEffects.Clear();
+		*/
+	}
+	
+	//@}
+}

scripts/3_Game/DayZ/Analytics/AnalyticsManagerClient.c

@@ -0,0 +1,180 @@
+class AnalyticsManagerClient
+{
+	static const int GEAR_COUNT = 3; 
+	static string m_FullGear[GEAR_COUNT] = {"Shoulder","Melee","Back"};
+	
+	void RegisterEvents()
+	{
+		ClientData.SyncEvent_OnEntityKilled.Insert(Event_OnEntityKilled);
+		ClientData.SyncEvent_OnPlayerIgnitedFireplace.Insert(Event_OnPlayerIgnitedFireplace);
+	}
+	
+	void UnregisterEvents()
+	{
+		ClientData.SyncEvent_OnEntityKilled.Remove(Event_OnEntityKilled);
+		ClientData.SyncEvent_OnPlayerIgnitedFireplace.Remove(Event_OnPlayerIgnitedFireplace);
+	}
+	
+	//===================================
+	// OnActionEat
+	//===================================
+	void OnActionEat()
+	{
+		Achievements.OnActionEat();
+	}
+	
+	//===================================
+	// OnActionDrink
+	//===================================
+	void OnActionDrink()
+	{
+		Achievements.OnActionDrink();
+	}
+	
+	//===================================
+	// OnActionCookedSteak - not implemented
+	//===================================
+	void OnActionCookedSteak()
+	{
+		Achievements.OnCookedSteak();
+	}
+	
+	//===================================
+	// OnActionFinishedShaveSelf
+	//===================================
+	void OnActionFinishedShaveSelf()
+	{
+		Achievements.OnActionShave();
+	}
+	
+	//===================================
+	// OnActionFinishedGutDeer
+	//===================================
+	void OnActionFinishedGutDeer()
+	{
+		Achievements.OnActionGutDeer();
+	}
+	
+	//===================================
+	// OnActionRestrain
+	//===================================
+	void OnActionRestrain()
+	{		
+		Achievements.OnActionHandcuff();
+	}
+	
+	//===================================
+	// OnActionBandageTarget
+	//===================================
+	void OnActionBandageTarget()
+	{	
+		Achievements.OnActionMedsSurvivor();
+	}
+	
+	//===================================
+	// OnItemAttachedAtPlayer
+	//===================================
+	void OnItemAttachedAtPlayer(EntityAI item, string slot_name)
+	{
+		bool weapon_present;
+		bool melee_present;
+		bool backpack_present;
+		HumanInventory inventory;
+
+		if ( GetDayZGame().GetGameState() != DayZGameState.IN_GAME )
+		{
+			return;
+		}
+		
+		Man player = GetGame().GetPlayer();
+		if (!player)
+		{
+			return;
+		}
+		
+		inventory = player.GetHumanInventory();
+			
+		if ( player && inventory )
+		{
+			for ( int i = 0; i < GEAR_COUNT; ++i )
+			{
+				int slot_id = InventorySlots.GetSlotIdFromString(m_FullGear[i]);
+				EntityAI att_item = inventory.FindAttachment( slot_id ); // Boris V [27.2.2019]: Consider using player.GetItemOnSlot(m_FullGear[i]) instead.
+					
+				if ( !att_item )
+				{
+					//Print("index: "+ i +" slot_id: "+ slot_id +" = "+ att_item + " EMPTY");
+					continue;
+				}
+				
+				//checks for firearm
+				if (att_item.IsWeapon())
+					weapon_present = true;
+				//checks for melee weapon
+				else if (!att_item.IsWeapon() && att_item.GetInventory().HasInventorySlot(InventorySlots.GetSlotIdFromString("Melee")))
+					melee_present = true;
+				//checks for backpack
+				else if (!att_item.IsWeapon() && att_item.GetInventory().HasInventorySlot(InventorySlots.GetSlotIdFromString("Back")))
+					backpack_present = true;
+				//Print("index: "+ i +" slot_id: "+ slot_id +" = "+ att_item + " ATTACHED");
+			}
+				
+			//separate check for hand slot; TODO remove duplicates
+			att_item = inventory.GetEntityInHands();
+			if ( att_item )
+			{
+				//checks for firearm
+				if (att_item.IsWeapon())
+					weapon_present = true;
+				//checks for melee weapon
+				else if (!att_item.IsWeapon() && att_item.GetInventory().HasInventorySlot(InventorySlots.GetSlotIdFromString("Melee")) )
+					melee_present = true;
+				//checks for backpack
+				else if (!att_item.IsWeapon() && att_item.GetInventory().HasInventorySlot(InventorySlots.GetSlotIdFromString("Back")))
+					backpack_present = true;
+			}
+				
+			if (weapon_present && melee_present && backpack_present)
+			{
+				//Print("---EAchievementActionId.ACTION_EQUIP_GEAR");
+				Achievements.OnEquippedFullGear();
+			}
+		}
+	}
+	
+	//===================================
+	// Event_OnPlayerIgnitedFireplace
+	//===================================
+	void Event_OnPlayerIgnitedFireplace( EFireIgniteType ignite_type )
+	{
+		switch ( ignite_type )
+		{
+			case EFireIgniteType.Matchbox:
+			{
+				Achievements.OnActionIgniteMatchbox();
+				break;
+			}
+			case EFireIgniteType.Roadflare:
+			{
+				Achievements.OnActionIgniteRoadflare();
+				break;
+			}
+			case EFireIgniteType.HandDrill:
+			{
+				Achievements.OnActionIgniteDrill();
+				break;
+			}
+		}
+	}
+	
+	//===================================
+	// Event_OnEntityKilled
+	//===================================
+	void Event_OnEntityKilled(EntityAI victim, EntityAI killer, EntityAI source, bool is_headshot)
+	{
+		if ( killer != null && killer.IsPlayer() && killer.GetID() == GetGame().GetPlayer().GetID() )
+		{
+			Achievements.OnPlayerKilled(victim, killer, source, is_headshot);
+		}
+	}
+}

scripts/3_Game/DayZ/Analytics/AnalyticsManagerServer.c

@@ -0,0 +1,73 @@
+class AnalyticsManagerServer
+{
+	const string STAT_DISTANCE 				= "dist";
+	const string STAT_PLAYTIME 				= "playtime";
+	const string STAT_PLAYERS_KILLED 		= "players_killed";
+	const string STAT_INFECTED_KILLED 		= "infected_killed";
+	const string STAT_LONGEST_SURVIVOR_HIT 	= "longest_survivor_hit";
+	
+	void OnPlayerConnect(Man player)
+	{
+		player.StatRegister(STAT_DISTANCE);
+		player.StatRegister(STAT_PLAYTIME);
+		player.StatRegister(STAT_PLAYERS_KILLED);
+		player.StatRegister(STAT_INFECTED_KILLED);
+		player.StatRegister(STAT_LONGEST_SURVIVOR_HIT);
+	}
+		
+	void OnPlayerDisconnect(Man player)
+	{
+		player.StatUpdateByPosition(STAT_DISTANCE);
+		player.StatUpdateByTime(STAT_PLAYTIME);
+	}
+	
+	//Entity-Entity hit
+	void OnEntityHit(EntityAI source, Man target)
+	{
+		if (source)
+		{
+			Man survivor = source.GetHierarchyRootPlayer();
+			if (survivor && source.IsWeapon())
+				OnPlayerToPlayerHit(survivor, target);
+		}
+	}
+	
+	protected void OnPlayerToPlayerHit(Man shooter, Man target)
+	{
+		float longestHitDistance = shooter.StatGet(STAT_LONGEST_SURVIVOR_HIT);
+		float currentDistance = vector.Distance(shooter.GetPosition(), target.GetPosition());
+		float distanceUpdate;
+		
+		if (longestHitDistance < currentDistance)
+			distanceUpdate = currentDistance - longestHitDistance;
+		
+		shooter.StatUpdate(STAT_LONGEST_SURVIVOR_HIT, distanceUpdate);
+	}
+	
+	//Entity-Entity kill
+	void OnEntityKilled(Object killer, EntityAI target)
+	{
+		EntityAI killerEntity = EntityAI.Cast(killer);
+		if (killerEntity)
+		{
+			Man killerSurvivor = killerEntity.GetHierarchyRootPlayer();
+			if (killerSurvivor)
+			{
+				if (target.IsPlayer())
+					OnPlayerKilled(killerSurvivor, target);
+				else if (target.IsZombie())
+					OnInfectedKilled(killerSurvivor, target);
+			}
+		}
+	}
+	
+	protected void OnPlayerKilled(Man killer, EntityAI target)
+	{
+		killer.StatUpdate(STAT_PLAYERS_KILLED, 1);
+	}
+	
+	protected void OnInfectedKilled(Man killer, EntityAI target)
+	{
+		killer.StatUpdate(STAT_INFECTED_KILLED, 1);
+	}
+}

scripts/3_Game/DayZ/Analytics/ScriptAnalytics.c

@@ -0,0 +1,176 @@
+// class binded to engine
+class StatsEventMeasuresData
+{
+	string m_CharacterId;		//!< character ID
+	int m_TimeInterval;			//!< amount of real time in seconds covered by this event
+	int m_DaytimeHour;			//!< current daytime in gameplay (hour in 24h format)
+	vector m_PositionStart;		//!< player world position at the start of interval
+	vector m_PositionEnd;		//!< player world position at the end of interval
+	float m_DistanceOnFoot;		//!< traveled distance on foot (meters) during interval
+	
+	float m_DistanceVehicle;	//!< traveled distance (meters) in vehicle during interval
+	float m_TimeVONIn;			//!< amount of time in seconds with inbound VON during interval
+	float m_TimeVONOut;			//!< amount of time in seconds with outbound VON during interval
+	int m_CntLootAny;			//!< count of any loot collected during interval
+	int m_CntLootFood;			//!< count of any food or consumables collected during interval
+	int m_CntLootCloth;			//!< count of cloth collected during interval
+	int m_CntLootFirearm;		//!< count of firearms collected during interval
+	int m_CntLootAmmo;			//!< count of ammo collected during interval
+	int m_CntKillInfected;		//!< count of infected kills during interval
+	int m_CntConsumedFood;		//!< count of consumed food during interval
+	int m_CntConsumedWater;		//!< count of consumed water during interval
+	int m_HealthRestored;		//!< number of health point restored during interval
+	int m_CntFiredAmmo;			//!< firearm rounds fired during interval
+	int m_CntCraftedItem;		//!< number of items crafted during interval
+	
+	// listStatus				// state metric of health, hunger, thirst, etc... when event is created/send
+	int m_HealthStatus;			//!< state of health (current state)
+	int m_BloodStatus;			//!< state of blood (current state)
+	int m_SicknessStatus;		//!< state of sickness (current state)
+	int m_TemperatureStatus;	//!< state of temperature (current state)
+	int m_FoodStatus;			//!< state of food (hunger) (current state)
+	int m_HydrationStatus;		//!< state of hydration (thirst) (current state)
+};
+
+// class binded to engine
+class StatsEventDeathData
+{
+	string		m_CharacterId;			//!< character ID
+	int			m_CharacterLifetime;	//!< lifetime of character in seconds
+	string		m_Cause;				//!< cause of death (hunger, sickness, player-killed, zombie-killed...)
+	string		m_WeaponName;			//!< name of weapon which caused death
+	float		m_Distance;				//!< distance in meters (rounded) from spawn position to death position
+	vector		m_Position;				//!< position of player when died
+	
+	int			m_ListDamages[5];		//!< list of damages (5 values) during last n sec. For example: {20, 80, 0, 0, 0}
+};
+
+// class binded to engine
+class StatsEventScoredKillData
+{
+	string		m_CharacterId;		//!< character ID
+	string		m_WeaponName;		//!< name of weapon which killed player (victim)
+	int			m_KillDistance;		//!< distance in meters (rounded) between killer and victim
+	vector		m_PositionKiller;	//!< position of killer
+	vector		m_PositionVictim;	//!< position of victim
+};
+
+// class binded to engine
+class StatsEventDisconnectedData
+{
+	string		m_CharacterId;	//!< character ID
+	string		m_Reason;		//!< reason of disconnect (quit, kick, ban, sign-out...)
+};
+
+// class binded to engine
+class StatsEventSpawnedData
+{
+	string		m_CharacterId;	//!< character ID
+	int			m_Lifetime;		//!< lifetime of character in seconds
+	vector		m_Position;		//!< position of spawn
+	int			m_Population;	//!< population of current gameplay (server)
+	int			m_DaytimeHour;	//!< current time in hour (hour in 24h)
+};
+
+// class binded to engine
+class StatsEventData
+{
+	void StatsEventData(string eventName)
+	{
+		m_eventName = eventName;
+		m_valuesBool = new map<string, int>();
+		m_valuesInt = new map<string, int>();
+		m_valuesFloat = new map<string, float>();
+		m_valuesString = new map<string, string>();
+		m_valuesVector = new map<string, vector>();
+	}
+	
+	void AddBool(string key, bool value)
+	{
+		m_valuesBool.Insert(key, (int)value);
+	}
+	
+	void AddInt(string key, int value)
+	{
+		m_valuesInt.Insert(key, value);
+	}
+	
+	void AddFloat(string key, float value)
+	{
+		m_valuesFloat.Insert(key, value);
+	}
+	
+	void AddString(string key, string value)
+	{
+		m_valuesString.Insert(key, value);
+	}
+	
+	void AddVector(string key, vector value)
+	{
+		m_valuesVector.Insert(key, value);
+	}
+	
+	private string m_eventName;
+	private autoptr map<string, int> m_valuesBool;//TODO: use bool instead of int (problem with engine type binding)
+	private autoptr map<string, int> m_valuesInt;
+	private autoptr map<string, float> m_valuesFloat;
+	private autoptr map<string, string> m_valuesString;
+	private autoptr map<string, vector> m_valuesVector;
+}
+
+
+class ScriptAnalytics
+{
+	//! send event about death to statistic DB
+	static proto native void SendPlayerDeath(StatsEventDeathData data);
+	
+	//! send event about kill to statistic DB
+	static proto native void SendPlayerScoredKill(StatsEventScoredKillData data);
+	
+	//! send event to statistic DB
+	static proto native void SendPlayerDisconnected(StatsEventDisconnectedData data);
+	
+	//! send event about player status to statistic DB
+	static proto native void SendPlayerMeasures(StatsEventMeasuresData data);
+	
+	//! send event about spawning to statistic DB
+	static proto native void SendPlayerSpawned(StatsEventSpawnedData data);
+	
+	//! universal analytics event
+	static proto native void SendEvent(StatsEventData data);
+};
+
+
+
+class Analytics
+{
+	// send stats data with log
+	static void PlayerDeath(StatsEventDeathData data)
+	{
+		ScriptAnalytics.SendPlayerDeath(data);
+	}
+	
+	// send stats data with log
+	static void PlayerScoredKill(StatsEventScoredKillData data)
+	{
+		ScriptAnalytics.SendPlayerScoredKill(data);
+	}
+	
+	// send stats data with log
+	static void PlayerDisconnected(StatsEventDisconnectedData data)
+	{
+		ScriptAnalytics.SendPlayerDisconnected(data);
+	}
+	
+	// send stats data with log
+	static void PlayerMeasures(StatsEventMeasuresData data)
+	{
+		ScriptAnalytics.SendPlayerMeasures(data);
+	}
+	
+	// send stats data with log
+	static void PlayerSpawned(StatsEventSpawnedData data)
+	{
+		ScriptAnalytics.SendPlayerSpawned(data);
+	}
+}

scripts/3_Game/DayZ/Anim/AnimCommand.c

@@ -0,0 +1,35 @@
+//! base class of all commands exposed to script to provide common functionality over animations
+class AnimCommandBase
+{
+	// These would be private if not for the scripted commands
+	// As other commands lifetime are handled internally
+	protected void AnimCommandBase() {}
+	protected void ~AnimCommandBase() {}
+	
+	//! returns entity that this command is bount to
+	proto native IEntity GetEntity();
+
+	//! called when command starts
+	void OnActivate() {}
+
+	//! called when command ends
+	void OnDeactivate() {}
+
+	//! called before any animation is processed
+	//! here change animation values, add animation commands
+	void PreAnimUpdate(float pDt) {}
+
+	//! after animation is processed, before physics is processed
+	//! here you can listen to various events
+	void PrePhysUpdate(float pDt) {}
+
+	//! functions usable only from OnActivate or PreAnimUpdate
+	proto native void PreAnim_CallCommand(int pCommand, int pParamInt, float pParamFloat);
+	proto native void PreAnim_SetFloat(int pVar, float pFlt);
+	proto native void PreAnim_SetInt(int pVar, int pInt);
+	proto native void PreAnim_SetBool(int pVar, bool pBool);
+
+	//! functions usable in PrePhysUpdate
+	proto native bool PrePhys_IsEvent(int pEvent);
+	proto native bool PrePhys_IsTag(int pTag);
+}

scripts/3_Game/DayZ/BillboardSet.c

@@ -0,0 +1,120 @@
+class BillboardSetHandler
+{
+	protected bool 							m_BillboardSetIndex 	= -1;
+	protected ref array<ref BillboardSet> 	m_BillboardSets;
+	protected static const string 			ROOT_CLASS = "BillboardPresets";
+	protected static int 					m_SetIndexCached = -1;//once we resolve the name into an index, we cache it(this disallows dynamic index swapping during mission's runtime)
+	
+	string GetTextureByType(string type)
+	{
+		if (m_BillboardSetIndex == -1)
+			return "";
+		BillboardSet bbset = m_BillboardSets.Get(m_BillboardSetIndex);
+		return bbset.GetTextureByType(type);
+	}
+
+	void OnRPCIndex(int index)
+	{
+		if (!m_BillboardSets)
+			LoadBillboardConfigs();
+						
+		if (m_BillboardSets && m_BillboardSets.IsValidIndex(index))
+		{
+			m_BillboardSetIndex = index;
+		}
+	}
+	
+	protected bool LoadBillboardConfigs()
+	{
+		m_BillboardSets = new array<ref BillboardSet>();
+		
+		int setCount = g_Game.ConfigGetChildrenCount(ROOT_CLASS);
+
+		for (int setIndex = 0; setIndex < setCount; setIndex++)
+		{
+			string setName;
+			GetGame().ConfigGetChildName(ROOT_CLASS, setIndex, setName);
+			string path = ROOT_CLASS + " " + setName;
+			m_BillboardSets.Insert(new BillboardSet(path));
+		}
+		
+		return true; 
+	}
+	
+	static bool ActivateBillboardSet(string setClassName, PlayerIdentity identity)
+	{
+		if (!g_Game)
+			return false;
+		
+		if (m_SetIndexCached == -1)
+		{
+			int setCount = g_Game.ConfigGetChildrenCount(ROOT_CLASS);
+			for (int setIndex = 0; setIndex < setCount; setIndex++)
+			{
+				string setName;
+				GetGame().ConfigGetChildName(ROOT_CLASS, setIndex, setName);
+				
+				if (setName == setClassName)
+				{
+					m_SetIndexCached = setIndex;
+					break
+				}
+			}
+		}
+		
+		if (m_SetIndexCached != -1)
+		{
+			auto param = new Param1<int>(m_SetIndexCached);
+			GetGame().RPCSingleParam( identity.GetPlayer(), ERPCs.RPC_SET_BILLBOARDS, param, true, identity );
+			return true;
+		}
+		return false;
+	}
+}
+
+
+class BillboardSet
+{
+	protected ref map<string, string> m_TypeTextureMapping = new map<string, string>();
+	
+	void BillboardSet(string path)
+	{
+		LoadConfig(path);
+	}
+	
+	string GetTextureByType(string type)
+	{
+		return m_TypeTextureMapping.Get(type);
+	}
+
+	protected void LoadConfig(string path)
+	{
+		int count = g_Game.ConfigGetChildrenCount(path);
+		for ( int i = 0; i < count; i++ )
+		{
+			string itemName;
+			GetGame().ConfigGetChildName(path, i, itemName);
+			
+			string typesPath = path + " " + itemName + " types";
+			string texturePath = path + " " + itemName + " texture";
+			
+			if (GetGame().ConfigIsExisting(typesPath) && GetGame().ConfigIsExisting(texturePath))
+			{
+				TStringArray types = new TStringArray();
+				string texture;
+				GetGame().ConfigGetText(texturePath, texture);
+				GetGame().ConfigGetTextArray(typesPath, types);
+				
+				foreach (string s: types)
+				{
+					m_TypeTextureMapping.Insert(s,texture);
+				}
+			}
+			else
+			{
+				ErrorEx("Billboard set incorrect configuration, type or texture param missing: " + path);
+			}
+			
+		}
+	}
+}

scripts/3_Game/DayZ/BleedChanceData.c

@@ -0,0 +1,131 @@
+typedef map<int,float> BleedChanceMaxMap; //<bloodDamageReceived,chanceMax>
+
+//! Static data of bleeding chance probabilities; currently used for melee only
+class BleedChanceData : Managed
+{
+	private static const float BLOOD_HITPOINTS_UNIVERSAL = 100.0;
+	
+	private static ref map<string, ref BleedChanceMaxMap> m_DamageTypeMap;
+	
+	static void InitBleedChanceData()
+	{
+		m_DamageTypeMap = new map<string,ref BleedChanceMaxMap>();
+		
+		InitMeleeChanceMap();
+		InitInfectedChanceMap();
+	}
+	
+	static void InitMeleeChanceMap()
+	{
+		if (m_DamageTypeMap.Contains("Melee"))
+			ErrorEx("'Melee' damage type bleed chances already initialized!");
+		
+		BleedChanceMaxMap bleedChanceMaxMap = new BleedChanceMaxMap();
+		
+		//keys have to be integers, recalculated later
+		bleedChanceMaxMap.Set(0,0.0);
+		bleedChanceMaxMap.Set(10,5.0);
+		bleedChanceMaxMap.Set(20,15.0);
+		bleedChanceMaxMap.Set(30,23.4);
+		bleedChanceMaxMap.Set(40,31.2);
+		bleedChanceMaxMap.Set(50,39.0);
+		bleedChanceMaxMap.Set(60,46.8);
+		bleedChanceMaxMap.Set(70,54.6);
+		bleedChanceMaxMap.Set(80,62.4);
+		bleedChanceMaxMap.Set(90,70.2);
+		bleedChanceMaxMap.Set(BLOOD_HITPOINTS_UNIVERSAL,100.0);
+		
+		m_DamageTypeMap.Set("Melee",bleedChanceMaxMap);
+	}
+	
+	static void InitInfectedChanceMap()
+	{
+		if (m_DamageTypeMap.Contains("Infected"))
+			ErrorEx("'Infected' damage type bleed chances already initialized!");
+		
+		BleedChanceMaxMap bleedChanceMaxMap = new BleedChanceMaxMap();
+		
+		//keys have to be integers, recalculated later
+		bleedChanceMaxMap.Set(0,0.0);
+		bleedChanceMaxMap.Set(10,5.0);
+		bleedChanceMaxMap.Set(20,15.0);
+		bleedChanceMaxMap.Set(30,27.5);
+		bleedChanceMaxMap.Set(40,40.0);
+		bleedChanceMaxMap.Set(50,55.0);
+		bleedChanceMaxMap.Set(60,60.0);
+		bleedChanceMaxMap.Set(70,70.0);
+		bleedChanceMaxMap.Set(80,75.0);
+		bleedChanceMaxMap.Set(90,85.0);
+		bleedChanceMaxMap.Set(BLOOD_HITPOINTS_UNIVERSAL,100.0);
+		
+		m_DamageTypeMap.Set("Infected",bleedChanceMaxMap);
+	}
+	
+	static void Cleanup()
+	{
+		delete m_DamageTypeMap;
+	}
+	
+	//! returns 'false' when damageType is unhandled
+	static bool CalculateBleedChance(string damageType, float bloodDamage, float bleedThreshold, out float bleedChance)
+	{
+		map<int,float> bleedChanceMap = m_DamageTypeMap.Get(damageType);
+		if (!bleedChanceMap)
+			return false;
+		
+		float armor = bloodDamage / BLOOD_HITPOINTS_UNIVERSAL;
+		float valueHigher = Math.Max(bleedThreshold,armor) * BLOOD_HITPOINTS_UNIVERSAL;
+		float valueLower = Math.Min(bleedThreshold,armor) * BLOOD_HITPOINTS_UNIVERSAL;
+		
+		#ifdef DEVELOPER
+		if (LogManager.IsBleedingChancesLogEnable())
+		{	
+			Debug.BleedingChancesLog(armor.ToString(), "BleedChanceData" , "n/a", "armor:");
+			Debug.BleedingChancesLog(bleedThreshold.ToString(), "BleedChanceData" , "n/a", "bleedThreshold:");
+		}
+		#endif
+		
+		//unexpected values, unhandled
+		if (valueLower > BLOOD_HITPOINTS_UNIVERSAL)
+		{
+			bleedChance = 1.0;
+			
+			#ifdef DEVELOPER
+			if (LogManager.IsBleedingChancesLogEnable())
+			{	
+				Debug.BleedingChancesLog(bleedChance.ToString(), "BleedChanceData" , "n/a", "Unhandleed values, default bleeding chance used:");
+			}
+			#endif
+			
+			return true;
+		}
+		
+		if (bleedChanceMap.Contains(valueLower))
+		{
+			bleedChance = bleedChanceMap.Get(valueLower) * valueHigher / 10000;
+		}
+		else
+		{
+			float chanceMaxActual;
+			
+			float floor = Math.Floor(valueLower / 10) * 10;
+			float ceil = Math.Ceil(valueLower / 10) * 10;
+			float pos = Math.InverseLerp(floor,ceil,valueLower);
+			
+			float chanceMin = bleedChanceMap.Get(floor);
+			float chanceMax = bleedChanceMap.Get(ceil);
+			
+			chanceMaxActual = Math.Lerp(chanceMin,chanceMax,pos);
+			bleedChance = valueHigher * chanceMaxActual / 10000;
+		}
+		
+		#ifdef DEVELOPER
+		if (LogManager.IsBleedingChancesLogEnable())
+		{	
+			Debug.BleedingChancesLog(bleedChance.ToString(), "BleedChanceData" , "n/a", "bleeding chance:");
+		}
+		#endif
+		
+		return true;
+	}
+}

scripts/3_Game/DayZ/CE/CentralEconomy.c

@@ -0,0 +1,768 @@
+
+/** @file */
+
+// -------------------------------------------------------------------------
+// object (SF) Spawn Flags (use to setup behavior and/ or trigger functionality)
+//
+const int ECE_NONE							= 0;
+	
+const int ECE_SETUP							= 2;	// process full entity setup (when creating NEW entity)
+const int ECE_TRACE							= 4;	// trace under entity when being placed (from the point of creation)
+const int ECE_CENTER						= 8;	// use center from shape (model) for placement
+
+const int ECE_UPDATEPATHGRAPH				= 32;	// update navmesh when object placed upon it
+
+const int ECE_ROTATIONFLAGS					= 512;	// enable rotation flags for object placement
+const int ECE_CREATEPHYSICS					= 1024;	// create collision envelope and related physics data (if object has them)
+const int ECE_INITAI						= 2048; // init ai
+const int ECE_AIRBORNE						= 4096;	// create flying unit in the air
+
+const int ECE_EQUIP_ATTACHMENTS				= 8192;		// equip with configured ATTACHMENTS
+const int ECE_EQUIP_CARGO					= 16384;	// equip with configured CARGO
+const int ECE_EQUIP							= 24576;	// equip with configured (ATTACHMENTS + CARGO)
+const int ECE_EQUIP_CONTAINER				= 2097152;	// populate DE/ group CONTAINER during spawn
+const int ECE_LOCAL							= 1073741824; // create object locally
+
+const int ECE_NOSURFACEALIGN				= 262144;	// do not align object on surface/ terrain
+const int ECE_KEEPHEIGHT					= 524288;	// keep height when creating object (do not use trace or placement on surface)
+
+const int ECE_NOLIFETIME					= 4194304;	// do not set lifetime when creating the object
+const int ECE_NOPERSISTENCY_WORLD			= 8388608;	// do not save this object in world
+const int ECE_NOPERSISTENCY_CHAR			= 16777216;	// do not save this object in character
+const int ECE_DYNAMIC_PERSISTENCY			= 33554432;	// spawns in without persistency, once player takes it, persistency will be enabled if available
+
+// note: use predefined combination when not solving something specific
+//
+const int ECE_IN_INVENTORY					= 787456;	// ECE_CREATEPHYSICS|ECE_KEEPHEIGHT|ECE_NOSURFACEALIGN
+const int ECE_PLACE_ON_SURFACE				= 1060;		// ECE_CREATEPHYSICS|ECE_UPDATEPATHGRAPH|ECE_TRACE
+const int ECE_OBJECT_SWAP					= 787488;	// ECE_CREATEPHYSICS|ECE_UPDATEPATHGRAPH|ECE_KEEPHEIGHT|ECE_NOSURFACEALIGN
+
+const int ECE_FULL							= 25126;	// ECE_SETUP|ECE_TRACE|ECE_ROTATIONFLAGS|ECE_UPDATEPATHGRAPH|ECE_EQUIP
+
+// -------------------------------------------------------------------------
+// object (RF) Rotation Flags (use to force and/ or invoke placement rotation)
+//
+const int	RF_NONE					= 0;
+
+const int	RF_FRONT				= 1;	// front side placement
+const int	RF_TOP					= 2;	// top side placement
+const int	RF_LEFT					= 4;	// left side placement
+const int	RF_RIGHT				= 8;	// right side placement
+const int	RF_BACK					= 16;	// back side placement
+const int	RF_BOTTOM				= 32;	// bottom side placement
+
+const int	RF_ALL					= 63;	// RF_FRONT|RF_TOP|RF_LEFT|RF_RIGHT|RF_BACK|RF_BOTTOM
+
+const int	RF_IGNORE				= 64;	// ignore placement RF flags - object will spawn as model was created
+
+const int	RF_TOPBOTTOM			= 34;	// RF_TOP|RF_BOTTOM
+const int	RF_LEFTRIGHT			= 12;	// RF_LEFT|RF_RIGHT
+const int	RF_FRONTBACK			= 17;	// RF_FRONT|RF_BACK
+
+const int	RF_RANDOMROT			= 64;	// allow random rotation around axis when placing
+const int	RF_ORIGINAL				= 128;	// use default placement setuped on object in config
+const int	RF_DECORRECTION			= 256;	// angle correction when spawning InventoryItem at Building angle
+const int	RF_DEFAULT				= 512;	// use default placement setuped on object in config
+
+// -------------------------------------------------------------------------
+//! Categories for CEApi.EconomyLog
+class EconomyLogCategories
+{
+	private void EconomyLogCategories();
+	private void ~EconomyLogCategories();
+	
+	const string Economy				= "economy";
+	const string EconomyRespawn			= "economy_respawn";
+	const string RespawnQueue			= "respawn_queue";
+	const string Container				= "container";
+	const string Matrix					= "matrix";
+	const string UniqueLoot				= "uniqueloot";
+	const string Bind					= "bind";
+	const string SetupFail				= "setupfail";
+	const string Storage				= "storage";
+	const string Classes				= "class";
+	const string Category				= "category";
+	const string Tag					= "tag";
+	const string SCategory				= "s_category";
+	const string STag					= "s_tag";
+	const string SAreaflags				= "s_areaflags";
+	const string SCrafted				= "s_crafted";
+	const string MapGroup				= "map_group";
+	const string MapComplete			= "map_complete";
+	const string InfectedZone			= "infected_zone";
+}
+
+// -------------------------------------------------------------------------
+//! Special strings for CEApi.EconomyMap
+class EconomyMapStrings
+{
+	private void EconomyMapStrings();
+	private void ~EconomyMapStrings();
+	
+	/**
+	\brief Generates string that will make CEApi.EconomyMap use all items with this category
+	\note This is refering to the CE categories of loot defined in cfglimitsdefinition.xml
+	\warning This is persistent per session, when you set it, it will persist until it is set to something else
+		\param category \p string The desired loot category
+		\return \p string The string to pass into CEApi.EconomyMap
+	@code
+		GetCEApi().EconomyMap(EconomyMapStrings.Category("food"));
+	@endcode
+	*/
+	static string Category(string category)
+	{
+		return string.Format("category:%1", category);
+	}
+	
+	/**
+	\brief Generates string that will make CEApi.EconomyMap use all items with this tag
+	\note This is refering to the CE tags of loot defined in cfglimitsdefinition.xml
+	\warning This is persistent per session, when you set it, it will persist until it is set to something else
+		\param category \p string The desired loot tag
+		\return \p string The string to pass into CEApi.EconomyMap
+	@code
+		GetCEApi().EconomyMap(EconomyMapStrings.Tag("floor"));
+	@endcode
+	*/
+	static string Tag(string tag)
+	{
+		return string.Format("tag:%1", tag);
+	}
+
+	
+	
+	//! Everything
+	const string ALL_ALL = "all:all";
+	//! All loot
+	const string ALL_LOOT = "all:loot";
+	//! All vehicles
+	const string ALL_VEHICLE = "all:vehicle";
+	//! All infected
+	const string ALL_INFECTED = "all:infected";
+	//! All animals
+	const string ALL_ANIMAL = "all:animal";
+	//! All players
+	const string ALL_PLAYER = "all:player";
+	//! All proxies
+	const string ALL_PROXY = "all:proxy";
+	//! All static loot spawns
+	const string ALL_PROXY_STATIC = "all:proxystatic";
+	//! All dynamic loot spawns
+	const string ALL_PROXY_DYNAMIC = "all:proxydynamic";
+	//! All abandoned loot spawns
+	const string ALL_PROXY_ABANDONED = "all:proxyabandoned";
+}
+
+// -------------------------------------------------------------------------
+//! Special strings for CEApi.EconomyOutput
+class EconomyOutputStrings
+{
+	private void EconomyOutputStrings();
+	private void ~EconomyOutputStrings();
+	
+	/**
+	\brief Lists stats regarding which loot spawn) that are linked together and how many there are
+		\note In logs: "[linked_groups]"
+	*/
+	const string LINKS = "links";
+	/**
+	\brief Lists loot spawns that have more loot than their maximum + 4
+		\note In logs: "[autotest:ListSuspiciousGroups]"
+	*/
+	const string SUSPICIOUS = "suspicious";
+	/**
+	\brief Lists DE spawns that have positions that are within supplied range (< fRange, not equal)
+		\note In logs: "[ClosePosition]"
+	*/
+	const string DE_CLOSE_POINT = "declosepoint";
+	/**
+	\brief Lists loot spawns that have been marked as abandoned
+		\note In logs: "[autotest:ListAbandonedGroups]"
+	*/ 
+	const string ABANDONED = "abandoned";
+	/**
+	\brief Lists loot spawns that are not abandoned but have no loot
+		\note In logs: "[autotest:ListEmptyGroups]"
+	*/  
+	const string EMPTY = "empty";
+	/**
+	\brief Lists loot spawns that are not abandoned and within the supplied range  (< fRange, not equal)
+		\note In logs: "[autotest:ListCloseGroups]"
+		\note Is the same as CEApi.ListCloseProxy
+	*/
+	const string CLOSE = "close";
+	/**
+	\brief Lists the number of objects inside of categories
+		\note In logs: "[autotest:ProcessDebugLog]"
+	*/
+	const string WORLD = "world";
+	/**
+	\brief Lists overall CE stats
+		\note In logs: "[autotest:OverallStatus]"
+	*/
+	const string STATUS = "status";
+	/**
+	\brief Lists the maxlootsize of all CE items
+		\note In logs: "[autotest:ListLootSize]"
+	*/
+	const string LOOT_SIZE = "lootsize";
+}
+
+// -------------------------------------------------------------------------
+enum ESpawnVolumeVis
+{
+	OFF = 0,
+	ADAPTIVE,
+	VOLUME,
+	OCCUPIED,
+}
+
+// -------------------------------------------------------------------------
+/**
+	\brief API to interact with Central Economy
+	\note Accessible through GetCEApi, make sure to read the documentation for that as well
+	\note Any mention of 'storage/' means the '$mission:storage_#' folder
+*/
+class CEApi
+{
+	private void CEApi() {}
+	private void ~CEApi() {}
+	
+	/**
+	\brief Regenerates "storage/spawnpoints.bin" if necessary
+	\note Already happens automatically when server starts before it is loaded in
+	@code
+		GetCEApi().ExportSpawnData();
+	@endcode
+	*/
+	proto native void ExportSpawnData();
+	/**
+	\brief Generates "storage/export/mapgrouppos.xml"
+		\param vCenter \p vector Center of area to generate from
+			\note When using a zero vector, this will automatically get the world center
+		\param fRadius \p float Radius in meters of area to generate from
+			\note When 0, this will automatically get a radius covering the map
+	@code
+		// Export for whole map
+		GetCEApi().ExportProxyData();
+	@endcode
+	*/
+	proto native void ExportProxyData( vector vCenter = vector.Zero, float fRadius = 0 );
+	/**
+	\brief Generates "storage/export/mapgroupcluster.xml"
+	@code
+		GetCEApi().ExportClusterData();
+	@endcode
+	*/
+	proto native void ExportClusterData();
+	/**
+	\brief Generates "storage/export/mapgroupproto.xml"
+	@code
+		GetCEApi().ExportProxyProto();
+	@endcode
+	*/
+	proto native void ExportProxyProto();
+	/**
+	\brief Invalidates loot spawn points which are closer than the radius supplied
+		\note Will output a message indicating how many points were invalidated
+		\param fRadius \p float The minimum desired distance in meters between loot spawn points
+			\note When 0 it will use a radius of 0.5
+		\param bAllSelections \p bool When false, will only check the points within a container against each other, when true will against all points
+	@code
+		// Example: I want there to be a minimum distance of 0.3m between any loot spawn point
+		GetCEApi().MarkCloseProxy(0.3, true);
+	@endcode
+	*/
+	proto native void MarkCloseProxy( float fRadius, bool bAllSelections );
+	/**
+	\brief Removes all invalid points
+		\note Is best paired with a MarkCloseProxy call first to invalidate unwanted points
+		\note Will output a message indicating the amount of deleted points
+	@code
+		GetCEApi().RemoveCloseProxy();
+	@endcode
+	*/
+	proto native void RemoveCloseProxy();
+	/**
+	\brief Outputs a list of all loot points closer than specified radius
+	\note This will automatically be checking all points against all points
+	\note This is a better way of handling it than the above two methods, as it can be then be removed manually from the xmls
+	\note Is the same as CEApi.EconomyOutput(EconomyOutputStrings.CLOSE, fRadius)
+		\param fRadius \p float The minimum desired distance in meters between loot spawn points
+	@code
+		GetCEApi().ListCloseProxy(0.3);
+	@endcode
+	*/
+	proto native void ListCloseProxy( float fRadius );
+
+	/**
+	\brief Will emulate the spawning of the item which is being looked at and generate images (.tga) in storage/lmap and output logs
+	\note DEVELOPER/DIAG ONLY
+	\note This will only work if the loot spawner is active
+		\param sClassName \p string The class name of the desired item to analyze
+			\note When using "*" as class name, instead of generating images, it will generate a .csv in storage/log containing the output of all spawnable items
+		\return \p bool Whether the operation was successful, it might fail in certain scenarios if the CE doesn't update in time
+	@code
+		GetCEApi().SpawnAnalyze("FlatCap_Grey");
+	@endcode
+	*/
+	proto native bool SpawnAnalyze( string sClassName );
+
+	/**
+	\brief Subtracts the supplied value from the current lifetime of all items in the world
+	\note Uses RadiusLifetimeDecrease under the hood and then calculates the parameters to fit the world
+	\note Will automatically clamp result between min and max lifetime  [3, 316224000] (3 seconds to 10 years)
+		\param fShift \p float The value in seconds which will be subtracted from the current lifetimes
+	@code
+		// Shortens the lifetimes of all items in the world by 3 seconds
+		GetCEApi().TimeShift(3);
+	@endcode
+	*/
+	proto native void TimeShift( float fShift );
+	/**
+	\brief Fills in the Debug Lifetime, which will be used for any new DE spawned
+		\param fLifeTime \p float The lifetime for any DE spawned after this call
+			\note When this is set back to 0, it will stop using the Debug Lifetime
+	@code
+		// Any DE spawned after this call will have a lifetime of 300 seconds
+		GetCEApi().OverrideLifeTime(300);
+	@endcode
+	*/
+	proto native void OverrideLifeTime( float fLifeTime );
+
+	/**
+	\brief Force spawn specific prototype group + loot at position
+	\note DEVELOPER/DIAG ONLY
+	\note This can also spawn in other CE & DE related objects, but is best used exclusively for testing prototype groups
+		\param sGroupName \p string The group name to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fAngle \p float Angle to spawn the Entity with in degrees [0, 360]
+			\note When a negative value, will pick a random one
+		\return \p Entity The spawned Entity or null if unsuccessful
+	@code
+		GetCEApi().SpawnGroup("Land_Shed_M1", Vector(5, 10, 5));
+	@endcode
+	*/
+	proto native Entity SpawnGroup( string sGroupName, vector vPos, float fAngle = -1 );
+	/**
+	\brief Force spawn specific dynamic event
+	\note DEVELOPER/DIAG ONLY
+	\note Versatile, can be used for Animal, Infected, Static, Item and Vehicle
+	\note Is the only one capable of spawning DE's that have DE Groups
+	\note Is the same as the next one, but has ECE_FULL flags and a hidden flag which overrides herd limit
+	\note This is also FORCE spawn, so it will bypass any limit and avoidance checks
+		\param sEvName \p string The DE to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fAngle \p float Angle to spawn the Entity with in degrees [0, 360]
+			\note When a negative value, will pick a random one
+		\return \p bool Whether the spawn was successful
+	@code
+		GetCEApi().SpawnDE("StaticHeliCrash", Vector(5, 10, 5));
+	@endcode
+	*/
+	proto native void SpawnDE( string sEvName, vector vPos, float fAngle = -1 );
+	/**
+	\brief Force spawn specific dynamic event
+	\note DEVELOPER/DIAG ONLY
+	\note Is the same one as above but with the possibility of custom flags
+		\param sEvName \p string The DE to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fAngle \p float Angle to spawn the Entity with in degrees [0, 360]
+			\note When a negative value, will pick a random one
+		\param uFlags \p int ECE flags to apply while spawning the DE
+		\return \p bool Whether the spawn was successful
+	@code
+		GetCEApi().SpawnDEEx("StaticHeliCrash", Vector(5, 10, 5), ECE_FULL);
+	@endcode
+	*/
+	proto native void SpawnDEEx( string sEvName, vector vPos, float fAngle, int uFlags );
+	/**
+	\brief Spawn an item through CE
+	\note DEVELOPER/DIAG ONLY
+		\param sEvName \p string The DE to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fAngle \p float Angle to spawn the Entity with in degrees [0, 360]
+			\note When a negative value, will pick a random one
+		\param iCount \p int The amount of items
+		\param fRange \p float Circle radius
+			\note When iCount is larger than 1, changing this will make it so that they are spawned in a circle around vPos
+	@code
+		GetCEApi().SpawnLoot("Deagle", Vector(5, 10, 5), 0, 9, 1);
+	@endcode
+	*/
+	proto native void SpawnLoot( string sEvName, vector vPos, float fAngle, int iCount = 1, float fRange = 1 );
+
+	/**
+	\brief Spawn all entities with dynamic category through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Will print additional logs to RPT
+		\param vPos \p vector The position to spawn the Entities at
+			\note This will be the starting position, the items will be split into segments by CE BBox size (smallest to largest)
+		\param bShowCylinders \p bool Whether to draw the CE BBox with debug shapes
+			\note Red: Invalid BBox; Yellow: Not in DB; Green: All ok
+		\param fDefaultDistance \p float The default distance to use when the entity does not have a CE BBox
+			\note This means that all the ones with invalid CE BBoxes will be piled up at the starting position when this is 0
+	@code
+		GetCEApi().SpawnDynamic(Vector(5, 10, 5), true);
+	@endcode
+	*/
+	proto native void SpawnDynamic( vector vPos, bool bShowCylinders = true, float fDefaultDistance = 0 );
+	/**
+	\brief Spawn all entities with vehicles category through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Will print additional logs to RPT
+		\param vPos \p vector The position to spawn the Entities at
+			\note This will be the starting position, vehicles spawn with 20m spacing
+			\note Make sure you do it on a surface as flat and open as possible, they need a lot of space
+		\param bShowCylinders \p bool Does nothing for Vehicles, left for backwards compat
+		\param fDefaultDistance \p float The default distance to use when the entity does not have a CE BBox
+			\note This means that all the ones with invalid CE BBoxes will be piled up at the starting position when this is 0
+	@code
+		GetCEApi().SpawnVehicles(Vector(5, 10, 5));
+	@endcode
+	*/
+	proto native void SpawnVehicles( vector vPos, bool bShowCylinders = false, float fDefaultDistance = 20 );
+	/**
+	\brief Spawn all entities with building category through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Will print additional logs to RPT
+		\param vPos \p vector The position to spawn the Entities at
+			\note This will be the starting position, the items will be split into segments by CE BBox size (smallest to largest)
+		\param bShowCylinders \p bool Whether to draw the CE BBox with debug shapes
+			\note Red: Invalid BBox; Yellow: Not in DB; Green: All ok
+			\note These will most likely just always be red
+		\param fDefaultDistance \p float The default distance to use when the entity does not have a CE BBox
+			\note This means that all the ones with invalid CE BBoxes will be piled up at the starting position when this is 0
+	@code
+		GetCEApi().SpawnBuilding(Vector(5, 10, 5), true);
+	@endcode
+	*/
+	proto native void SpawnBuilding( vector vPos, bool bShowCylinders = false, float fDefaultDistance = 20 );
+
+	/**
+	\brief Spawn an entity through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Is similar to SpawnLoot, but works better on Animal/Infected/Vehicle
+		\param sClassName \p string The entity to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fRange \p float Circle radius
+			\note When iCount is larger than 1, changing this will make it so that they are spawned in a circle around vPos
+		\param iCount \p int The amount of items
+	@code
+		GetCEApi().SpawnEntity("Deagle", Vector(5, 10, 5), 1, 9);
+	@endcode
+	*/
+	proto native void SpawnEntity( string sClassName, vector vPos, float fRange, int iCount );
+	/**
+	\brief Spawn an entity through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Is the same as SpawnEntity, but spawns only one and returns the spawned Object
+		\param sClassName \p string The entity to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\return \p Object The spawned Object
+	@code
+		GetCEApi().SpawnSingleEntity("Deagle", Vector(5, 10, 5));
+	@endcode
+	*/
+	proto native Object SpawnSingleEntity( string sClassName, vector vPos );
+	/**
+	\brief Spawn an entity through CE
+	\note DEVELOPER/DIAG ONLY
+	\note Is the same as SpawnEntity, under the hood it just defaults to RF_ORIGINAL
+		\param sClassName \p string The entity to spawn
+		\param vPos \p vector The position to spawn the Entity at
+		\param fRange \p float Circle radius
+			\note When iCount is larger than 1, changing this will make it so that they are spawned in a circle around vPos
+		\param iCount \p int The amount of items
+		\param iFlags \p int The rotation flags to apply
+	@code
+		GetCEApi().SpawnRotation("Deagle", Vector(5, 10, 5), 1, 9, RF_ALL);
+	@endcode
+	*/
+	proto native void SpawnRotation( string sClassName, vector vPos, float fRange, int iCount, int iFlags );
+	/**
+	\brief Spawn an entity through CE, x amount of times in a grid
+	\note DEVELOPER/DIAG ONLY
+	\note The name may imply it does something else, but a profiler is needed to actually benchmark it
+	\note The position starts at 0 0 0
+		\param sClassName \p string The entity to spawn
+		\param iCount \p int The amount of items
+	@code
+		GetCEApi().SpawnPerfTest("Deagle", 30);
+	@endcode
+	*/
+	proto native void SpawnPerfTest( string sClassName, int iCount );
+	
+	/**
+	\brief Queue up the depleting of lifetime of everything in the world
+	\note DEVELOPER/DIAG ONLY
+	@code
+		GetCEApi().CleanMap();
+	@endcode
+	*/
+	proto native void CleanMap();
+
+	/**
+	\brief Outputs debug file to storage/log/*.csv
+	\note DEVELOPER/DIAG ONLY
+		\param sLogType \p string The type of log (EconomyLogCategories)
+	@code
+		GetCEApi().EconomyLog(EconomyLogCategories.Economy);
+	@endcode
+	*/
+	proto native void EconomyLog( string sLogType );
+	
+	/**
+	\brief Outputs debug file to storage/lmap/*.tga showing the current places this is spawned
+	\note DEVELOPER/DIAG ONLY
+	\note This works best when you have an image of the map to overlay the tga with afterwards
+		\param sMapType \p string The type of lmap, can be just a class name or a special string
+			\note There are several prefixes and sets of strings that can be passed in here, see EconomyMapStrings
+	@code
+		// To check only a specific item
+		GetCEApi().EconomyMap("Deagle");
+	@endcode
+	*/
+	proto native void EconomyMap( string sMapType );
+	/**
+	\brief Outputs debug logs into server log or rpt
+	\note DEVELOPER/DIAG ONLY
+		\param sOutputType \p string One of the strings specified in EconomyOutputStrings
+		\param fRange \p float Range parameter used for some of the options
+	@code
+		GetCEApi().EconomyOutput(EconomyOutputStrings.CLOSE, 3);
+	@endcode
+	*/
+	proto native void EconomyOutput( string sOutputType, float fRange );
+
+	/**
+	\brief Process lifetime increase within radius by value (sec)
+	\note Will automatically clamp result between min and max lifetime  [3, 316224000] (3 seconds to 10 years)
+		\param vCenter \p vector The center point
+		\param fRadius \p float The radius around the center point
+		\param fValue \p float The value to increase the lifetime by
+			\note When 0, this will reset it to default instead (but it's better to use RadiusLifetimeReset still)
+	@code
+		GetCEApi().RadiusLifetimeIncrease(Vector(500, 0, 500), 3, 500);
+	@endcode
+	*/
+	proto native void RadiusLifetimeIncrease( vector vCenter, float fRadius, float fValue );
+	/**
+	\brief Process lifetime decrease within radius by value (sec)
+	\note Will automatically clamp result between min and max lifetime  [3, 316224000] (3 seconds to 10 years)
+		\param vCenter \p vector The center point
+		\param fRadius \p float The radius around the center point
+		\param fValue \p float The value to decrease the lifetime by
+	@code
+		GetCEApi().RadiusLifetimeDecrease(Vector(500, 0, 500), 3, 500);
+	@endcode
+	*/
+	proto native void RadiusLifetimeDecrease( vector vCenter, float fRadius, float fValue );
+	/**
+	\brief Process lifetime reset to default value from DB within radius
+		\param vCenter \p vector The center point
+		\param fRadius \p float The radius around the center point
+	@code
+		GetCEApi().RadiusLifetimeReset(Vector(500, 0, 500), 3);
+	@endcode
+	*/
+	proto native void RadiusLifetimeReset( vector vCenter, float fRadius );
+	
+	
+	
+	/** \name Globals API
+		Get values from globals.xml
+	*/
+	//@{
+	
+	/**
+	\brief Get int from globals.xml
+	\note type="0"
+		\param varName \p string The name of the entry
+		\return \p int The value or int.MIN if not found/not an int
+	*/
+	proto native int GetCEGlobalInt(string varName);
+	/**
+	\brief Get float from globals.xml
+	\note type="1"
+		\param varName \p string The name of the entry
+		\return \p float The value or float.MIN if not found/not a float
+	*/
+	proto native float GetCEGlobalFloat(string varName);
+	/**
+	\brief Get string from globals.xml
+	\note type="2"
+		\param varName \p string The name of the entry
+		\return \p string The value or empty string if not found/not a string
+	*/
+	proto native string GetCEGlobalString(string varName);
+	
+	//@}
+	
+	
+	
+	/** \name Avoidance API
+		Optimized internal methods that the CE uses to avoid spawning DE within certain distances
+	*/
+	//@{
+	
+	/**
+	\brief Check if there is a player within a radius
+		\param vPos \p vector The center point
+		\param fDistance \p float The radius around the center point
+		\return \p bool Returns false when there is a player inside supplied area, true when it successfully avoided players
+	@code
+		GetCEApi().AvoidPlayer(Vector(500, 0, 500), 20);
+	@endcode
+	*/
+	proto native bool AvoidPlayer(vector vPos, float fDistance); // return false when there is a player
+	/**
+	\brief Check if there is a vehicle within a radius
+		\param vPos \p vector The center point
+		\param fDistance \p float The radius around the center point
+		\param sDEName \p string A specific DE to avoid, if left empty, will avoid all vehicles
+		\return \p bool Returns false when there is a vehicle inside supplied area, true when it successfully avoided vehicles
+	@code
+		GetCEApi().AvoidVehicle(Vector(500, 0, 500), 500, "VehicleCivilianSedan");
+	@endcode
+	*/
+	proto native bool AvoidVehicle(vector vPos, float fDistance, string sDEName = "");
+	/**
+	\brief Check if there is a vehicle within a radius
+		\param vPos \p vector The center point
+		\param fRange \p float The radius around the center point
+		\return \p int The amoutn of players inside supplied area
+	@code
+		GetCEApi().CountPlayersWithinRange(Vector(500, 0, 500), 500);
+	@endcode
+	*/
+	proto native int CountPlayersWithinRange(vector vPos, float fRange);
+	
+	//@}
+	
+	
+	
+	/** \name CE Debug menu Script API
+		DIAG ONLY: These options are available from the in-game debug menu on Diag exe (Game > Central Economy), documentation can be found on wiki
+	*/
+	//@{
+	
+	// "Loot Spawn Edit"
+	//{	
+		//! "Spawn Volume Vis"
+		proto native void LootSetSpawnVolumeVisualisation(ESpawnVolumeVis mode);
+		//! "Setup Vis"
+		proto native void LootToggleSpawnSetup(bool mode);
+		//! "Edit Volume"
+		proto native void LootToggleVolumeEditing(bool mode);
+		//! "Re-Trace Group Points"
+		proto native void LootRetraceGroupPoints();
+		//! "Export Group >>"
+		proto native void LootExportGroup();
+		//! "Export All Groups >>>>" / GetCEApi.ExportProxyProto();
+		proto native void LootExportAllGroups();
+		//! "<<< Export Map" / GetCEApi.ExportProxyData(vector.Zero, 0);
+		proto native void LootExportMap();
+		//! "<<< Export Clusters" / GetCEApi().ExportClusterData()
+		proto native void LootExportClusters();
+	//}
+
+	// "Loot Tool"
+	//{
+		//! "Deplete Lifetime"
+		proto native void LootDepleteLifetime();
+		//! "Set Damage = 1.0"
+		proto native void LootSetDamageToOne();
+		//! "Damage + Deplete"
+		proto native void LootDepleteAndDamage();
+	//}
+
+	// "Infected"
+	//{
+		//! "Infected Vis"
+		proto native void InfectedToggleVisualisation(bool mode);
+		//! "Infected Zone Info"
+		proto native void InfectedToggleZoneInfo(bool mode);
+		//! "Infected Spawn"
+		proto native void InfectedSpawn();
+		//! "Reset Cleanup"
+		proto native void InfectedResetCleanup();
+	//}
+
+	// "Animal"
+	//{
+		//! "Animal Vis"
+		proto native void AnimalToggleVisualisation(bool mode);
+		//! "Animal Spawn"
+		proto native void AnimalSpawn();
+		//! "Ambient Spawn"
+		proto native void AnimalAmbientSpawn();
+	//}
+
+	//! "Vehicle&Wreck Vis"
+	proto native void ToggleVehicleAndWreckVisualisation(bool mode);
+	//! "Loot Vis"
+	proto native void ToggleLootVisualisation(bool mode);
+	//! "Cluster Vis"
+	proto native void ToggleClusterVisualisation(bool mode);
+
+	//! "Dynamic Events Status"
+	proto native void ToggleDynamicEventStatus(bool mode);
+	//! "Dynamic Events Vis"
+	proto native void ToggleDynamicEventVisualisation(bool mode);
+	//! "Dynamic Events Spawn"
+	proto native void DynamicEventSpawn();
+	//! "Export Dyn Event >>"
+	proto native void DynamicEventExport();
+	
+	//! "Overall Stats"
+	proto native void ToggleOverallStats(bool mode);
+	
+	//@}
+	
+	
+	
+	/** \name DEPRECATED/LEGACY
+		These don't do anything anymore but are left for backwards compatibility
+	*/
+	//@{
+
+	proto native void PlatformStatTest();
+	
+	proto native void LootToggleProxyEditing(bool mode);
+	
+	proto native void OnUpdate();
+	
+	//@}
+};
+
+/**
+	\brief Get the CE API
+	\warning Only exists when the game has CE enabled
+	\note This means that this will work on anything which is running a mission with an initialized Hive
+	\note Client does not have Hive when connected to a server, only the server does if it was set up in the init.c
+*/
+proto native CEApi GetCEApi();
+
+// -------------------------------------------------------------------------
+class CEItemProfile
+{
+	private void CEItemProfile() {}
+	private void ~CEItemProfile() {}
+	
+	proto native int GetNominal(); // nominal - how many items should be aproximately in map
+	proto native int GetMin(); // min - minimal count should be available in map
+
+	proto native float GetQuantityMin(); // min quantity (0.0 - 1.0) (like ammobox - this determine how many bullets are there, or water bottle)
+	proto native float GetQuantityMax(); // max quantity (0.0 - 1.0) (like ammobox - this determine how many bullets are there, or water bottle)
+
+	proto native float GetQuantity(); // random quantity (0.0 - 1.0)
+
+	proto native float GetLifetime(); // maximum lifetime in (seconds) - what is the idle before item abandoned at ground gets deleted
+	proto native float GetRestock(); // restock is oposite of lifetime - idle before item is allowed to respawn when required
+
+	proto native int GetCost(); // cost of item determines its 'value' for players (this serve as priority during respawn and cleanup operation)
+
+	proto native int GetUsageFlags(); // area usage flags (each bit has assigned group - which as part of map overlay effectively affects spawning)
+	proto native int GetValueFlags(); // area value flags (each bit has assigned group - which as part of map overlay effectively affects spawning)
+};