Exported a ton of functions to mob

zone/lua_mob.cpp

@@ -1,11 +1,32 @@
 #ifdef LUA_EQEMU
 
 #include "masterentity.h"
+#include "lua_item.h"
+#include "lua_iteminst.h"
 #include "lua_mob.h"
 #include "lua_hate_entry.h"
 #include "lua_hate_list.h"
 #include "lua_client.h"
 
+Lua_Mob::Lua_Illusion::Lua_Illusion() {
+	in_race = 0;
+	in_gender = 255;
+	in_texture = 255;
+	in_helmtexture = 255;
+	in_haircolor = 255;
+	in_beardcolor = 255;
+	in_eyecolor1 = 255;
+	in_eyecolor2 = 255;
+	in_hairstyle = 255;
+	in_luclinface = 255;
+	in_beard = 255;
+	in_aa_title = 255;
+	in_drakkin_heritage = 4294967295;
+	in_drakkin_tattoo = 4294967295;
+	in_drakkin_details = 4294967295;
+	in_size = -1.0;
+}
+
 const char *Lua_Mob::GetName() {
 	Lua_Safe_Call_String();
 	return self->GetName();
@@ -178,27 +199,27 @@ void Lua_Mob::DoAnim(int anim_num, int type, bool ackreq, int filter) {
 
 void Lua_Mob::ChangeSize(double in_size) {
 	Lua_Safe_Call_Void();
-	self->ChangeSize(in_size);
+	self->ChangeSize(static_cast<float>(in_size));
 }
 
 void Lua_Mob::ChangeSize(double in_size, bool no_restriction) {
 	Lua_Safe_Call_Void();
-	self->ChangeSize(in_size, no_restriction);
+	self->ChangeSize(static_cast<float>(in_size), no_restriction);
 }
 
 void Lua_Mob::GMMove(double x, double y, double z) {
 	Lua_Safe_Call_Void();
-	self->GMMove(x, y, z);
+	self->GMMove(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
 }
 
 void Lua_Mob::GMMove(double x, double y, double z, double heading) {
 	Lua_Safe_Call_Void();
-	self->GMMove(x, y, z, heading);
+	self->GMMove(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(heading));
 }
 
 void Lua_Mob::GMMove(double x, double y, double z, double heading, bool send_update) {
 	Lua_Safe_Call_Void();
-	self->GMMove(x, y, z, heading, send_update);
+	self->GMMove(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(heading), send_update);
 }
 
 bool Lua_Mob::HasProcs() {
@@ -740,7 +761,7 @@ bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot, int mana_use
 
 void Lua_Mob::SpellEffect(Lua_Mob caster, int spell_id, double partial) {
 	Lua_Safe_Call_Void();
-	self->SpellEffect(caster, spell_id, partial);
+	self->SpellEffect(caster, spell_id, static_cast<float>(partial));
 }
 
 Lua_Mob Lua_Mob::GetPet() {
@@ -768,4 +789,763 @@ Lua_HateList Lua_Mob::GetHateList() {
 	return ret;
 }
 
+Lua_Mob Lua_Mob::GetHateTop() {
+	Lua_Safe_Call_Mob();
+	return Lua_Mob(self->GetHateTop());
+}
+
+Lua_Mob Lua_Mob::GetHateDamageTop(Lua_Mob other) {
+	Lua_Safe_Call_Mob();
+	return Lua_Mob(self->GetHateDamageTop(other));
+}
+
+Lua_Mob Lua_Mob::GetHateRandom() {
+	Lua_Safe_Call_Mob();
+	return Lua_Mob(self->GetHateRandom());
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other);
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other, int hate) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other, hate);
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other, int hate, int damage) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other, hate, damage);
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other, int hate, int damage, bool yell_for_help) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other, hate, damage, yell_for_help);
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other, int hate, int damage, bool yell_for_help, bool frenzy) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other, hate, damage, yell_for_help, frenzy);
+}
+
+void Lua_Mob::AddToHateList(Lua_Mob other, int hate, int damage, bool yell_for_help, bool frenzy, bool buff_tic) {
+	Lua_Safe_Call_Void();
+	self->AddToHateList(other, hate, damage, yell_for_help, frenzy, buff_tic);
+}
+
+void Lua_Mob::SetHate(Lua_Mob other) {
+	Lua_Safe_Call_Void();
+	self->SetHate(other);
+}
+
+void Lua_Mob::SetHate(Lua_Mob other, int hate) {
+	Lua_Safe_Call_Void();
+	self->SetHate(other, hate);
+}
+
+void Lua_Mob::SetHate(Lua_Mob other, int hate, int damage) {
+	Lua_Safe_Call_Void();
+	self->SetHate(other, hate, damage);
+}
+
+uint32 Lua_Mob::GetHateAmount(Lua_Mob target) {
+	Lua_Safe_Call_Int();
+	return self->GetHateAmount(target);
+}
+
+uint32 Lua_Mob::GetHateAmount(Lua_Mob target, bool is_damage) {
+	Lua_Safe_Call_Int();
+	return self->GetHateAmount(target, is_damage);
+}
+
+uint32 Lua_Mob::GetDamageAmount(Lua_Mob target) {
+	Lua_Safe_Call_Int();
+	return self->GetDamageAmount(target);
+}
+
+void Lua_Mob::WipeHateList() {
+	Lua_Safe_Call_Void();
+	self->WipeHateList();
+}
+
+bool Lua_Mob::CheckAggro(Lua_Mob other) {
+	Lua_Safe_Call_Bool();
+	return self->CheckAggro(other);
+}
+
+void Lua_Mob::Stun(int duration) {
+	Lua_Safe_Call_Void();
+	self->Stun(duration);
+}
+
+void Lua_Mob::UnStun() {
+	Lua_Safe_Call_Void();
+	self->UnStun();
+}
+
+bool Lua_Mob::IsStunned() {
+	Lua_Safe_Call_Bool();
+	return self->IsStunned();
+}
+
+void Lua_Mob::Spin() {
+	Lua_Safe_Call_Void();
+	self->Spin();
+}
+
+void Lua_Mob::Kill() {
+	Lua_Safe_Call_Void();
+	self->Kill();
+}
+
+bool Lua_Mob::CanThisClassDoubleAttack() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassDoubleAttack();
+}
+
+bool Lua_Mob::CanThisClassDualWield() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassDualWield();
+}
+
+bool Lua_Mob::CanThisClassRiposte() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassRiposte();
+}
+
+bool Lua_Mob::CanThisClassDodge() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassDodge();
+}
+
+bool Lua_Mob::CanThisClassParry() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassParry();
+}
+
+bool Lua_Mob::CanThisClassBlock() {
+	Lua_Safe_Call_Bool();
+	return self->CanThisClassBlock();
+}
+
+void Lua_Mob::SetInvul(bool value) {
+	Lua_Safe_Call_Void();
+	self->SetInvul(value);
+}
+
+bool Lua_Mob::GetInvul() {
+	Lua_Safe_Call_Bool();
+	return self->GetInvul();
+}
+
+void Lua_Mob::SetExtraHaste(int haste) {
+	Lua_Safe_Call_Void();
+	self->SetExtraHaste(haste);
+}
+
+int Lua_Mob::GetHaste() {
+	Lua_Safe_Call_Int();
+	return self->GetHaste();
+}
+
+int Lua_Mob::GetMonkHandToHandDamage() {
+	Lua_Safe_Call_Int();
+	return self->GetMonkHandToHandDamage();
+}
+
+int Lua_Mob::GetMonkHandToHandDelay() {
+	Lua_Safe_Call_Int();
+	return self->GetMonkHandToHandDelay();
+}
+
+void Lua_Mob::Mesmerize() {
+	Lua_Safe_Call_Void();
+	self->Mesmerize();
+}
+
+bool Lua_Mob::IsMezzed() {
+	Lua_Safe_Call_Bool();
+	return self->IsMezzed();
+}
+
+bool Lua_Mob::IsEnraged() {
+	Lua_Safe_Call_Bool();
+	return self->IsEnraged();
+}
+
+int Lua_Mob::GetReverseFactionCon(Lua_Mob other) {
+	Lua_Safe_Call_Int();
+	return self->GetReverseFactionCon(other);
+}
+
+bool Lua_Mob::IsAIControlled() {
+	Lua_Safe_Call_Bool();
+	return self->IsAIControlled();
+}
+
+float Lua_Mob::GetAggroRange() {
+	Lua_Safe_Call_Real();
+	return self->GetAggroRange();
+}
+
+float Lua_Mob::GetAssistRange() {
+	Lua_Safe_Call_Real();
+	return self->GetAssistRange();
+}
+
+void Lua_Mob::SetPetOrder(int order) {
+	Lua_Safe_Call_Void();
+	self->SetPetOrder(static_cast<Mob::eStandingPetOrder>(order));
+}
+
+int Lua_Mob::GetPetOrder() {
+	Lua_Safe_Call_Int();
+	return self->GetPetOrder();
+}
+
+bool Lua_Mob::IsRoamer() {
+	Lua_Safe_Call_Bool();
+	return self->IsRoamer();
+}
+
+bool Lua_Mob::IsRooted() {
+	Lua_Safe_Call_Bool();
+	return self->IsRooted();
+}
+
+bool Lua_Mob::IsEngaged() {
+	Lua_Safe_Call_Bool();
+	return self->IsEngaged();
+}
+
+void Lua_Mob::FaceTarget(Lua_Mob target) {
+	Lua_Safe_Call_Void();
+	self->FaceTarget(target);
+}
+
+void Lua_Mob::SetHeading(double in) {
+	Lua_Safe_Call_Void();
+	self->SetHeading(static_cast<float>(in));
+}
+
+double Lua_Mob::CalculateHeadingToTarget(double in_x, double in_y) {
+	Lua_Safe_Call_Real();
+	return self->CalculateHeadingToTarget(static_cast<float>(in_x), static_cast<float>(in_y));
+}
+
+bool Lua_Mob::CalculateNewPosition(double x, double y, double z, double speed) {
+	Lua_Safe_Call_Bool();
+	return self->CalculateNewPosition(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(speed));
+}
+
+bool Lua_Mob::CalculateNewPosition(double x, double y, double z, double speed, bool check_z) {
+	Lua_Safe_Call_Bool();
+	return self->CalculateNewPosition(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(speed),
+		check_z);
+}
+
+bool Lua_Mob::CalculateNewPosition2(double x, double y, double z, double speed) {
+	Lua_Safe_Call_Bool();
+	return self->CalculateNewPosition2(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(speed));
+}
+
+bool Lua_Mob::CalculateNewPosition2(double x, double y, double z, double speed, bool check_z) {
+	Lua_Safe_Call_Bool();
+	return self->CalculateNewPosition2(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(speed),
+		check_z);
+}
+
+float Lua_Mob::CalculateDistance(double x, double y, double z) {
+	Lua_Safe_Call_Real();
+	return self->CalculateDistance(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
+}
+
+void Lua_Mob::SendTo(double x, double y, double z) {
+	Lua_Safe_Call_Void();
+	self->SendTo(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
+}
+
+void Lua_Mob::SendToFixZ(double x, double y, double z) {
+	Lua_Safe_Call_Void();
+	self->SendToFixZ(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
+}
+
+void Lua_Mob::NPCSpecialAttacks(const char *parse, int perm) {
+	Lua_Safe_Call_Void();
+	self->NPCSpecialAttacks(parse, perm);
+}
+
+void Lua_Mob::NPCSpecialAttacks(const char *parse, int perm, bool reset) {
+	Lua_Safe_Call_Void();
+	self->NPCSpecialAttacks(parse, perm, reset);
+}
+
+void Lua_Mob::NPCSpecialAttacks(const char *parse, int perm, bool reset, bool remove) {
+	Lua_Safe_Call_Void();
+	self->NPCSpecialAttacks(parse, perm, reset, remove);
+}
+
+int Lua_Mob::GetResist(int type) {
+	Lua_Safe_Call_Int();
+	return self->GetResist(type);
+}
+
+bool Lua_Mob::Charmed() {
+	Lua_Safe_Call_Bool();
+	return self->Charmed();
+}
+
+int Lua_Mob::CheckAggroAmount(int spell_id) {
+	Lua_Safe_Call_Int();
+	return self->CheckAggroAmount(spell_id);
+}
+
+int Lua_Mob::CheckAggroAmount(int spell_id, bool is_proc) {
+	Lua_Safe_Call_Int();
+	return self->CheckAggroAmount(spell_id, is_proc);
+}
+
+int Lua_Mob::CheckHealAggroAmount(int spell_id) {
+	Lua_Safe_Call_Int();
+	return self->CheckHealAggroAmount(spell_id);
+}
+
+int Lua_Mob::CheckHealAggroAmount(int spell_id, uint32 heal_possible) {
+	Lua_Safe_Call_Int();
+	return self->CheckHealAggroAmount(spell_id, heal_possible);
+}
+
+int Lua_Mob::GetAA(int id) {
+	Lua_Safe_Call_Int();
+	return self->GetAA(id);
+}
+
+bool Lua_Mob::DivineAura() {
+	Lua_Safe_Call_Bool();
+	return self->DivineAura();
+}
+
+void Lua_Mob::SetOOCRegen(int regen) {
+	Lua_Safe_Call_Void();
+	self->SetOOCRegen(regen);
+}
+
+const char* Lua_Mob::GetEntityVariable(const char *name) {
+	Lua_Safe_Call_String();
+	return self->GetEntityVariable(name);
+}
+
+void Lua_Mob::SetEntityVariable(const char *name, const char *value) {
+	Lua_Safe_Call_Void();
+	self->SetEntityVariable(name, value);
+}
+
+bool Lua_Mob::EntityVariableExists(const char *name) {
+	Lua_Safe_Call_Bool();
+	return self->EntityVariableExists(name);
+}
+
+void Lua_Mob::Signal(uint32 id) {
+	Lua_Safe_Call_Void();
+	
+	if(self->IsClient()) {
+		self->CastToClient()->Signal(id);
+	} else if(self->IsNPC()) {
+		self->CastToNPC()->SignalNPC(id);
+	}
+}
+
+bool Lua_Mob::CombatRange(Lua_Mob other) {
+	Lua_Safe_Call_Bool();
+	return self->CombatRange(other);
+}
+
+void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage) {
+	Lua_Safe_Call_Void();
+	self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage);
+}
+
+void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage) {
+	Lua_Safe_Call_Void();
+	self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage);
+}
+
+void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override) {
+	Lua_Safe_Call_Void();
+	self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override);
+}
+
+void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time) {
+	Lua_Safe_Call_Void();
+	self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time);
+}
+
+void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time, 
+									bool hit_chance) {
+	Lua_Safe_Call_Void();
+	self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other, range_weapon);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_Item item) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other, range_weapon, item);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_Item item, int weapon_damage) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other, range_weapon, item, weapon_damage);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_Item item, int weapon_damage, int chance_mod) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other, range_weapon, item, weapon_damage, chance_mod);
+}
+
+void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_Item item, int weapon_damage, int chance_mod, 
+								  int focus) {
+	Lua_Safe_Call_Void();
+	self->DoThrowingAttackDmg(other, range_weapon, item, weapon_damage, chance_mod, focus);
+}
+
+void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill) {
+	Lua_Safe_Call_Void();
+	self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill));
+}
+
+void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod) {
+	Lua_Safe_Call_Void();
+	self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod);
+}
+
+void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus) {
+	Lua_Safe_Call_Void();
+	self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod, focus);
+}
+
+void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus, bool can_riposte) {
+	Lua_Safe_Call_Void();
+	self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod, focus, can_riposte);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other, range_weapon);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ItemInst ammo) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other, range_weapon, ammo);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ItemInst ammo, int weapon_damage) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other, range_weapon, ammo, weapon_damage);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ItemInst ammo, int weapon_damage, int chance_mod) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other, range_weapon, ammo, weapon_damage, chance_mod);
+}
+
+void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ItemInst ammo, int weapon_damage, int chance_mod, 
+								 int focus) {
+	Lua_Safe_Call_Void();
+	self->DoArcheryAttackDmg(other, range_weapon, ammo, weapon_damage, chance_mod, focus);
+}
+
+bool Lua_Mob::CheckLoS(Lua_Mob other) {
+	Lua_Safe_Call_Bool();
+	return self->CheckLosFN(other);
+}
+
+bool Lua_Mob::CheckLoSToLoc(double x, double y, double z) {
+	Lua_Safe_Call_Bool();
+	return self->CheckLosFN(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), 6.0f);
+}
+
+bool Lua_Mob::CheckLoSToLoc(double x, double y, double z, double mob_size) {
+	Lua_Safe_Call_Bool();
+	return self->CheckLosFN(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(mob_size));
+}
+
+double Lua_Mob::FindGroundZ(double x, double y) {
+	Lua_Safe_Call_Real();
+	return self->GetGroundZ(static_cast<float>(x), static_cast<float>(y));
+}
+
+double Lua_Mob::FindGroundZ(double x, double y, double z) {
+	Lua_Safe_Call_Real();
+	return self->GetGroundZ(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id);
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id, bool is_arrow) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id, is_arrow);
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id, bool is_arrow, double speed) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id, is_arrow, static_cast<float>(speed));
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id, bool is_arrow, double speed, double angle) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id, is_arrow, static_cast<float>(speed), static_cast<float>(angle));
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id, bool is_arrow, double speed, double angle, double tilt) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id, is_arrow, static_cast<float>(speed), static_cast<float>(angle), static_cast<float>(tilt));
+}
+
+void Lua_Mob::ProjectileAnimation(Lua_Mob to, int item_id, bool is_arrow, double speed, double angle, double tilt, double arc) {
+	Lua_Safe_Call_Void();
+	self->ProjectileAnimation(to, item_id, is_arrow, static_cast<float>(speed), static_cast<float>(angle), static_cast<float>(tilt), 
+		static_cast<float>(arc));
+}
+
+bool Lua_Mob::HasNPCSpecialAtk(const char *parse) {
+	Lua_Safe_Call_Bool();
+	return self->HasNPCSpecialAtk(parse);
+}
+
+void Lua_Mob::SendAppearanceEffect(uint32 parm1, uint32 parm2, uint32 parm3, uint32 parm4, uint32 parm5) {
+	Lua_Safe_Call_Void();
+	self->SendAppearanceEffect(parm1, parm2, parm3, parm4, parm5);
+}
+
+void Lua_Mob::SendAppearanceEffect(uint32 parm1, uint32 parm2, uint32 parm3, uint32 parm4, uint32 parm5, Lua_Client specific_target) {
+	Lua_Safe_Call_Void();
+	self->SendAppearanceEffect(parm1, parm2, parm3, parm4, parm5, specific_target);
+}
+
+void Lua_Mob::SetFlyMode(int in) {
+	Lua_Safe_Call_Void();
+	self->SetFlyMode(in);
+}
+
+void Lua_Mob::SetTexture(int in) {
+	Lua_Safe_Call_Void();
+	self->SendIllusionPacket(self->GetRace(), 0xFF, in);
+}
+
+void Lua_Mob::SetRace(int in) {
+	Lua_Safe_Call_Void();
+	self->SendIllusionPacket(in);
+}
+
+void Lua_Mob::SetGender(int in) {
+	Lua_Safe_Call_Void();
+	self->SendIllusionPacket(self->GetRace(), in);
+}
+
+void Lua_Mob::SendIllusionPacket(Lua_Mob::Lua_Illusion ill) {
+	Lua_Safe_Call_Void();
+	self->SendIllusionPacket(ill.in_race, ill.in_gender, ill.in_texture, ill.in_helmtexture, ill.in_haircolor, ill.in_beardcolor,
+		ill.in_eyecolor1, ill.in_eyecolor2, ill.in_hairstyle, ill.in_luclinface, ill.in_beard, ill.in_aa_title,
+		ill.in_drakkin_heritage, ill.in_drakkin_tattoo, ill.in_drakkin_details, static_cast<float>(ill.in_size));
+}
+
+void Lua_Mob::QuestReward(Lua_Client c) {
+	Lua_Safe_Call_Void();
+	self->QuestReward(c);
+}
+
+void Lua_Mob::QuestReward(Lua_Client c, uint32 silver) {
+	Lua_Safe_Call_Void();
+	self->QuestReward(c, silver);
+}
+
+void Lua_Mob::QuestReward(Lua_Client c, uint32 silver, uint32 gold) {
+	Lua_Safe_Call_Void();
+	self->QuestReward(c, silver, gold);
+}
+
+void Lua_Mob::QuestReward(Lua_Client c, uint32 silver, uint32 gold, uint32 platinum) {
+	Lua_Safe_Call_Void();
+	self->QuestReward(c, silver, gold, platinum);
+}
+
+void Lua_Mob::CameraEffect(uint32 duration, uint32 intensity) {
+	Lua_Safe_Call_Void();
+	self->CameraEffect(duration, intensity);
+}
+
+void Lua_Mob::CameraEffect(uint32 duration, uint32 intensity, Lua_Client c) {
+	Lua_Safe_Call_Void();
+	self->CameraEffect(duration, intensity, c);
+}
+
+void Lua_Mob::CameraEffect(uint32 duration, uint32 intensity, Lua_Client c, bool global) {
+	Lua_Safe_Call_Void();
+	self->CameraEffect(duration, intensity, c, global);
+}
+
+void Lua_Mob::SendSpellEffect(uint32 effect_id, uint32 duration, uint32 finish_delay, bool zone_wide, uint32 unk020) {
+	Lua_Safe_Call_Void();
+	self->SendSpellEffect(effect_id, duration, finish_delay, zone_wide, unk020);
+}
+
+void Lua_Mob::SendSpellEffect(uint32 effect_id, uint32 duration, uint32 finish_delay, bool zone_wide, uint32 unk020, bool perm_effect) {
+	Lua_Safe_Call_Void();
+	self->SendSpellEffect(effect_id, duration, finish_delay, zone_wide, unk020, perm_effect);
+}
+
+void Lua_Mob::SendSpellEffect(uint32 effect_id, uint32 duration, uint32 finish_delay, bool zone_wide, uint32 unk020, bool perm_effect, 
+							  Lua_Client c) {
+	Lua_Safe_Call_Void();
+	self->SendSpellEffect(effect_id, duration, finish_delay, zone_wide, unk020, perm_effect, c);
+}
+
+void Lua_Mob::TempName() {
+	Lua_Safe_Call_Void();
+	self->TempName();
+}
+
+void Lua_Mob::TempName(const char *newname) {
+	Lua_Safe_Call_Void();
+	self->TempName(newname);
+}
+
+void Lua_Mob::SetGlobal(const char *varname, const char *newvalue, int options, const char *duration) {
+	Lua_Safe_Call_Void();
+	self->SetGlobal(varname, newvalue, options, duration);
+}
+
+void Lua_Mob::SetGlobal(const char *varname, const char *newvalue, int options, const char *duration, Lua_Mob other) {
+	Lua_Safe_Call_Void();
+	self->SetGlobal(varname, newvalue, options, duration, other);
+}
+
+void Lua_Mob::TarGlobal(const char *varname, const char *value, const char *duration, int npc_id, int char_id, int zone_id) {
+	Lua_Safe_Call_Void();
+	self->TarGlobal(varname, value, duration, npc_id, char_id, zone_id);
+}
+
+void Lua_Mob::DelGlobal(const char *varname) {
+	Lua_Safe_Call_Void();
+	self->DelGlobal(varname);
+}
+
+void Lua_Mob::SetSlotTint(int material_slot, int red_tint, int green_tint, int blue_tint) {
+	Lua_Safe_Call_Void();
+	self->SetSlotTint(material_slot, red_tint, green_tint, blue_tint);
+}
+
+void Lua_Mob::WearChange(int material_slot, int texture, uint32 color) {
+	Lua_Safe_Call_Void();
+	self->WearChange(material_slot, texture, color);
+}
+
+void Lua_Mob::DoKnockback(Lua_Mob caster, uint32 pushback, uint32 pushup) {
+	Lua_Safe_Call_Void();
+	self->DoKnockback(caster, pushback, pushup);
+}
+
+void Lua_Mob::RemoveNimbusEffect(int effect_id) {
+	Lua_Safe_Call_Void();
+	self->RemoveNimbusEffect(effect_id);
+}
+
+bool Lua_Mob::IsRunning() {
+	Lua_Safe_Call_Bool();
+	return self->IsRunning();
+}
+
+void Lua_Mob::SetRunning(bool running) {
+	Lua_Safe_Call_Void();
+	self->SetRunning(running);
+}
+
+void Lua_Mob::SetBodyType(int new_body, bool overwrite_orig) {
+	Lua_Safe_Call_Void();
+	self->SetBodyType(static_cast<bodyType>(new_body), overwrite_orig);
+}
+
+void Lua_Mob::SetTargetable(bool on) {
+	Lua_Safe_Call_Void();
+	self->SetTargetable(on);
+}
+
+void Lua_Mob::ModSkillDmgTaken(int skill, int value) {
+	Lua_Safe_Call_Void();
+	self->ModSkillDmgTaken(static_cast<SkillType>(skill), value);
+}
+
+int Lua_Mob::GetModSkillDmgTaken(int skill) {
+	Lua_Safe_Call_Int();
+	return self->GetModSkillDmgTaken(static_cast<SkillType>(skill));
+}
+
+int Lua_Mob::GetSkillDmgTaken(int skill) {
+	Lua_Safe_Call_Int();
+	return self->GetSkillDmgTaken(static_cast<SkillType>(skill));
+}
+
+void Lua_Mob::SetAllowBeneficial(bool value) {
+	Lua_Safe_Call_Void();
+	self->SetAllowBeneficial(value);
+}
+
+bool Lua_Mob::GetAllowBeneficial() {
+	Lua_Safe_Call_Bool();
+	return self->GetAllowBeneficial();
+}
+
+bool Lua_Mob::IsBeneficialAllowed(Lua_Mob target) {
+	Lua_Safe_Call_Bool();
+	return self->IsBeneficialAllowed(target);
+}
+
+void Lua_Mob::ModVulnerability(int resist, int value) {
+	Lua_Safe_Call_Void();
+	self->ModVulnerability(resist, value);
+}
+
+int Lua_Mob::GetModVulnerability(int resist) {
+	Lua_Safe_Call_Int();
+	return self->GetModVulnerability(resist);
+}
+
+void Lua_Mob::SetDisableMelee(bool disable) {
+	Lua_Safe_Call_Void();
+	self->SetDisableMelee(disable);
+}
+
+bool Lua_Mob::IsMeleeDisabled() {
+	Lua_Safe_Call_Bool();
+	return IsMeleeDisabled();
+}
+
+void Lua_Mob::SetFlurryChance(int value) {
+	Lua_Safe_Call_Void();
+	self->SetFlurryChance(value);
+}
+
+int Lua_Mob::GetFlurryChance() {
+	Lua_Safe_Call_Int();
+	return self->GetFlurryChance();
+}
+
 #endif