Add BossHP

BossHP/scripting/CBoss.inc

@@ -0,0 +1,271 @@
+#if defined _class_cboss_
+  #endinput
+#endif
+#define _class_cboss_
+
+methodmap CBoss < Basic
+{
+	public CBoss()
+	{
+		Basic myclass = new Basic();
+
+		myclass.SetHandle("dConfig", INVALID_HANDLE);
+		myclass.SetBool("bActive", false);
+		myclass.SetBool("bShow", true);
+		myclass.SetInt("iTemplateNum", -1);
+		myclass.SetInt("iHealth", 0);
+		myclass.SetInt("iLastChange", 0);
+		myclass.SetFloat("fWaitUntil", 0.0);
+		myclass.SetFloat("fShowAt", 0.0);
+		myclass.SetFloat("fKillAt", 0.0);
+
+		return view_as<CBoss>(myclass);
+	}
+
+	property CConfig dConfig
+	{
+		public get()
+		{
+			return view_as<CConfig>(this.GetHandle("dConfig"));
+		}
+		public set(CConfig value)
+		{
+			this.SetHandle("dConfig", value);
+		}
+	}
+
+	property bool bActive
+	{
+		public get()
+		{
+			return this.GetBool("bActive");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bActive", value);
+		}
+	}
+
+	property bool bShow
+	{
+		public get()
+		{
+			return this.GetBool("bShow");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bShow", value);
+		}
+	}
+
+	property int iTemplateNum
+	{
+		public get()
+		{
+			return this.GetInt("iTemplateNum");
+		}
+		public set(int value)
+		{
+			this.SetInt("iTemplateNum", value);
+		}
+	}
+
+	property int iHealth
+	{
+		public get()
+		{
+			return this.GetInt("iHealth");
+		}
+		public set(int value)
+		{
+			this.SetInt("iHealth", value);
+		}
+	}
+
+	property int iLastChange
+	{
+		public get()
+		{
+			return this.GetInt("iLastChange");
+		}
+		public set(int value)
+		{
+			this.SetInt("iLastChange", value);
+		}
+	}
+
+	property float fWaitUntil
+	{
+		public get()
+		{
+			return this.GetFloat("fWaitUntil");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fWaitUntil", value);
+		}
+	}
+
+	property float fShowAt
+	{
+		public get()
+		{
+			return this.GetFloat("fShowAt");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fShowAt", value);
+		}
+	}
+
+	property float fKillAt
+	{
+		public get()
+		{
+			return this.GetFloat("fKillAt");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fKillAt", value);
+		}
+	}
+
+	property bool IsBreakable {
+		public get() {
+			return this.dConfig.IsBreakable;
+		}
+	}
+
+	property bool IsCounter {
+		public get() {
+			return this.dConfig.IsCounter;
+		}
+	}
+
+	property bool IsHPBar {
+		public get() {
+			return this.dConfig.IsHPBar;
+		}
+	}
+}
+
+methodmap CBossBreakable < CBoss
+{
+	public CBossBreakable()
+	{
+		CBoss myclass = new CBoss();
+
+		myclass.SetInt("iBreakableEnt", INVALID_ENT_REFERENCE);
+
+		return view_as<CBossBreakable>(myclass);
+	}
+
+	property int iBreakableEnt
+	{
+		public get()
+		{
+			return this.GetInt("iBreakableEnt");
+		}
+		public set(int value)
+		{
+			this.SetInt("iBreakableEnt", value);
+		}
+	}
+
+	property CConfigBreakable Config
+	{
+		public get()
+		{
+			return view_as<CConfigBreakable>(this.dConfig);
+		}
+		public set(CConfigBreakable value)
+		{
+			this.dConfig = value;
+		}
+	}
+}
+
+methodmap CBossCounter < CBoss
+{
+	public CBossCounter()
+	{
+		CBoss myclass = new CBoss();
+
+		myclass.SetInt("iCounterEnt", INVALID_ENT_REFERENCE);
+
+		return view_as<CBossCounter>(myclass);
+	}
+
+	property int iCounterEnt
+	{
+		public get()
+		{
+			return this.GetInt("iCounterEnt");
+		}
+		public set(int value)
+		{
+			this.SetInt("iCounterEnt", value);
+		}
+	}
+
+	property CConfigCounter Config
+	{
+		public get()
+		{
+			return view_as<CConfigCounter>(this.dConfig);
+		}
+		public set(CConfigCounter value)
+		{
+			this.dConfig = value;
+		}
+	}
+}
+
+methodmap CBossHPBar < CBossCounter
+{
+	public CBossHPBar()
+	{
+		CBoss myclass = new CBossCounter();
+
+		myclass.SetInt("iIteratorEnt", INVALID_ENT_REFERENCE);
+		myclass.SetInt("iBackupEnt", INVALID_ENT_REFERENCE);
+
+		return view_as<CBossHPBar>(myclass);
+	}
+
+	property int iIteratorEnt
+	{
+		public get()
+		{
+			return this.GetInt("iIteratorEnt");
+		}
+		public set(int value)
+		{
+			this.SetInt("iIteratorEnt", value);
+		}
+	}
+
+	property int iBackupEnt
+	{
+		public get()
+		{
+			return this.GetInt("iBackupEnt");
+		}
+		public set(int value)
+		{
+			this.SetInt("iBackupEnt", value);
+		}
+	}
+
+	property CConfigHPBar Config
+	{
+		public get()
+		{
+			return view_as<CConfigHPBar>(this.dConfig);
+		}
+		public set(CConfigHPBar value)
+		{
+			this.dConfig = value;
+		}
+	}
+}

BossHP/scripting/CConfig.inc

@@ -0,0 +1,321 @@
+#if defined _class_cconfig_
+  #endinput
+#endif
+#define _class_cconfig_
+
+enum eConfigMethod
+{
+	eConfigMethod_Invalid = 0,
+	eConfigMethod_Breakable = 1,
+	eConfigMethod_Counter = 2,
+	eConfigMethod_HPBar = 3
+}
+
+methodmap CConfig < Basic
+{
+	public CConfig()
+	{
+		Basic myclass = new Basic();
+
+		myclass.SetString("sName", "");
+		myclass.SetInt("iMethod", eConfigMethod_Invalid);
+		myclass.SetString("sTrigger", "");
+		myclass.SetString("sOutput", "");
+		myclass.SetFloat("fTriggerDelay", 0.0);
+		myclass.SetString("sShowTrigger", "");
+		myclass.SetString("sShowOutput", "");
+		myclass.SetFloat("fShowTriggerDelay", 0.0);
+		myclass.SetString("sKillTrigger", "");
+		myclass.SetString("sKillOutput", "");
+		myclass.SetFloat("fKillTriggerDelay", 0.0);
+		myclass.SetBool("bMultiTrigger", false);
+		myclass.SetBool("bNameFixup", false);
+		myclass.SetInt("iTimeout", -1);
+
+		return view_as<CConfig>(myclass);
+	}
+
+	public bool GetName(char[] buffer, int length)
+	{
+		return this.GetString("sName", buffer, length);
+	}
+
+	public void SetName(const char[] buffer)
+	{
+		this.SetString("sName", buffer);
+	}
+
+	property eConfigMethod iMethod
+	{
+		public get()
+		{
+			return view_as<eConfigMethod>(this.GetInt("iMethod"));
+		}
+		public set(eConfigMethod value)
+		{
+			this.SetInt("iMethod", view_as<int>(value));
+		}
+	}
+
+	public bool GetTrigger(char[] buffer, int length)
+	{
+		return this.GetString("sTrigger", buffer, length);
+	}
+
+	public void SetTrigger(const char[] buffer)
+	{
+		this.SetString("sTrigger", buffer);
+	}
+
+	public bool GetOutput(char[] buffer, int length)
+	{
+		return this.GetString("sOutput", buffer, length);
+	}
+
+	public void SetOutput(const char[] buffer)
+	{
+		this.SetString("sOutput", buffer);
+	}
+
+	property float fTriggerDelay
+	{
+		public get()
+		{
+			return this.GetFloat("fTriggerDelay");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fTriggerDelay", value);
+		}
+	}
+
+	public bool GetShowTrigger(char[] buffer, int length)
+	{
+		return this.GetString("sShowTrigger", buffer, length);
+	}
+
+	public void SetShowTrigger(const char[] buffer)
+	{
+		this.SetString("sShowTrigger", buffer);
+	}
+
+	public bool GetShowOutput(char[] buffer, int length)
+	{
+		return this.GetString("sShowOutput", buffer, length);
+	}
+
+	public void SetShowOutput(const char[] buffer)
+	{
+		this.SetString("sShowOutput", buffer);
+	}
+
+	property float fShowTriggerDelay
+	{
+		public get()
+		{
+			return this.GetFloat("fShowTriggerDelay");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fShowTriggerDelay", value);
+		}
+	}
+
+	public bool GetKillTrigger(char[] buffer, int length)
+	{
+		return this.GetString("sKillTrigger", buffer, length);
+	}
+
+	public void SetKillTrigger(const char[] buffer)
+	{
+		this.SetString("sKillTrigger", buffer);
+	}
+
+	public bool GetKillOutput(char[] buffer, int length)
+	{
+		return this.GetString("sKillOutput", buffer, length);
+	}
+
+	public void SetKillOutput(const char[] buffer)
+	{
+		this.SetString("sKillOutput", buffer);
+	}
+
+	property float fKillTriggerDelay
+	{
+		public get()
+		{
+			return this.GetFloat("fKillTriggerDelay");
+		}
+		public set(float value)
+		{
+			this.SetFloat("fKillTriggerDelay", value);
+		}
+	}
+
+	property bool bMultiTrigger
+	{
+		public get()
+		{
+			return this.GetBool("bMultiTrigger");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bMultiTrigger", value);
+		}
+	}
+
+	property bool bNameFixup
+	{
+		public get()
+		{
+			return this.GetBool("bNameFixup");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bNameFixup", value);
+		}
+	}
+
+	property int iTimeout
+	{
+		public get()
+		{
+			return this.GetInt("iTimeout");
+		}
+		public set(int value)
+		{
+			this.SetInt("iTimeout", value);
+		}
+	}
+
+
+
+
+	property bool IsBreakable {
+		public get() {
+			return (this.iMethod == eConfigMethod_Breakable);
+		}
+	}
+
+	property bool IsCounter {
+		public get() {
+			return (this.iMethod == eConfigMethod_Counter);
+		}
+	}
+
+	property bool IsHPBar {
+		public get() {
+			return (this.iMethod == eConfigMethod_HPBar);
+		}
+	}
+}
+
+methodmap CConfigBreakable < CConfig
+{
+	public CConfigBreakable()
+	{
+		CConfig myclass = new CConfig();
+
+		myclass.SetString("sBreakable", "");
+
+		myclass.iMethod = eConfigMethod_Breakable;
+
+		return view_as<CConfigBreakable>(myclass);
+	}
+
+	public bool GetBreakable(char[] buffer, int length)
+	{
+		return this.GetString("sBreakable", buffer, length);
+	}
+
+	public void SetBreakable(const char[] buffer)
+	{
+		this.SetString("sBreakable", buffer);
+	}
+}
+
+methodmap CConfigCounter < CConfig
+{
+	public CConfigCounter()
+	{
+		CConfig myclass = new CConfig();
+
+		myclass.SetString("sCounter", "");
+		myclass.SetBool("bCounterReverse", false);
+
+		myclass.iMethod = eConfigMethod_Counter;
+
+		return view_as<CConfigCounter>(myclass);
+	}
+
+	public bool GetCounter(char[] buffer, int length)
+	{
+		return this.GetString("sCounter", buffer, length);
+	}
+
+	public void SetCounter(const char[] buffer)
+	{
+		this.SetString("sCounter", buffer);
+	}
+
+	property bool bCounterReverse
+	{
+		public get()
+		{
+			return this.GetBool("bCounterReverse");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bCounterReverse", value);
+		}
+	}
+}
+
+methodmap CConfigHPBar < CConfigCounter
+{
+	public CConfigHPBar()
+	{
+		CConfigCounter myclass = new CConfigCounter();
+
+		myclass.SetString("sIterator", "");
+		myclass.SetString("sBackup", "");
+		myclass.SetBool("bIteratorReverse", false);
+
+		myclass.iMethod = eConfigMethod_HPBar;
+
+		return view_as<CConfigHPBar>(myclass);
+	}
+
+	public bool GetIterator(char[] buffer, int length)
+	{
+		return this.GetString("sIterator", buffer, length);
+	}
+
+	public void SetIterator(const char[] buffer)
+	{
+		this.SetString("sIterator", buffer);
+	}
+
+	public bool GetBackup(char[] buffer, int length)
+	{
+		return this.GetString("sBackup", buffer, length);
+	}
+
+	public void SetBackup(const char[] buffer)
+	{
+		this.SetString("sBackup", buffer);
+	}
+
+	property bool bIteratorReverse
+	{
+		public get()
+		{
+			return this.GetBool("bIteratorReverse");
+		}
+		public set(bool value)
+		{
+			this.SetBool("bIteratorReverse", value);
+		}
+	}
+}

BossHP/scripting/include/basic.inc

@@ -0,0 +1 @@
+../../../includes/basic.inc

BossHP/scripting/include/outputinfo.inc

@@ -0,0 +1 @@
+../../../includes/outputinfo.inc