diff --git a/zone/client.cpp b/zone/client.cpp
index 9abe26072..21b9b512b 100644
--- a/zone/client.cpp
+++ b/zone/client.cpp
@@ -7720,3 +7720,52 @@ void Client::TryItemTick(int slot)
         }
     }
 }
+
+void Client::RefundAA() {
+	int cur = 0;
+	bool refunded = false;
+
+	for(int x = 0; x < aaHighestID; x++) {
+		cur = GetAA(x);
+		if(cur > 0){
+			SendAA_Struct* curaa = zone->FindAA(x);
+			if(cur){
+				SetAA(x, 0);
+				for(int j = 0; j < cur; j++) {
+					m_pp.aapoints += curaa->cost + (curaa->cost_inc * j);
+					refunded = true;
+				}
+			}
+			else
+			{
+				m_pp.aapoints += cur;
+				SetAA(x, 0);
+				refunded = true;
+			}
+		}
+	}
+
+	if(refunded) {
+		Save();
+		Kick();
+	}
+}
+
+void Client::IncrementAA(int aa_id) {
+	SendAA_Struct* aa2 = zone->FindAA(aa_id);
+
+	if(aa2 == nullptr)
+		return;
+
+	if(GetAA(aa_id) == aa2->max_level)
+		return;
+
+	SetAA(aa_id, GetAA(aa_id) + 1);
+
+	Save();
+
+	SendAA(aa_id);
+	SendAATable();
+	SendAAStats();
+	CalcBonuses();
+}
diff --git a/zone/client.h b/zone/client.h
index cb74a31c9..f95bfe063 100644
--- a/zone/client.h
+++ b/zone/client.h
@@ -750,6 +750,12 @@ public:
 	inline uint32 GetAAPointsSpent() { return m_pp.aapoints_spent; }
 	int16 CalcAAFocusEffect(focusType type, uint16 focus_spell, uint16 spell_id);
 	int16 CalcAAFocus(focusType type, uint32 aa_ID, uint16 spell_id);
+	void SetAAPoints(uint32 points) { m_pp.aapoints = points; SendAAStats(); }
+	void AddAAPoints(uint32 points) { m_pp.aapoints += points; SendAAStats(); }
+	int GetAAPoints() { return m_pp.aapoints; }
+	int GetSpentAA() { return m_pp.aapoints_spent; }
+	void RefundAA();
+	void IncrementAA(int aa_id);
 
 	int16 acmod();
 
@@ -1015,6 +1021,9 @@ public:
 	void DepopAllCorpses();
 	void DepopPlayerCorpse(uint32 dbid);
 	void BuryPlayerCorpses();
+	uint32 GetCorpseCount() { return database.GetPlayerCorpseCount(CharacterID()); }
+	uint32 GetCorpseID(int corpse) { return database.GetPlayerCorpseID(CharacterID(), corpse); }
+	uint32 GetCorpseItemAt(int corpse_id, int slot_id) { return database.GetPlayerCorpseItemAt(corpse_id, slot_id); }
 	void SuspendMinion();
 	void Doppelganger(uint16 spell_id, Mob *target, const char *name_override, int pet_count, int pet_duration);
 	void NotifyNewTitlesAvailable();
diff --git a/zone/command.cpp b/zone/command.cpp
index 92c661030..0dafbff58 100644
--- a/zone/command.cpp
+++ b/zone/command.cpp
@@ -8650,9 +8650,7 @@ void command_altactivate(Client *c, const Seperator *sep){
 
 void command_refundaa(Client *c, const Seperator *sep){
 	Client* refundee = nullptr;
-	int curpt = 0;
-	bool refunded = false;
-	if(c){
+	if(c) {
 		if(c->GetTarget()){
 			if(c->GetTarget()->IsClient())
 				refundee = c->GetTarget()->CastToClient();
@@ -8663,32 +8661,10 @@ void command_refundaa(Client *c, const Seperator *sep){
 			c->Message(0, "You must have a target selected.");
 		}
 
-		if(refundee){
-			for(int x1=0;x1<aaHighestID;x1++){
-				curpt = refundee->GetAA(x1);
-				if(curpt > 0){
-					SendAA_Struct* curaa = zone->FindAA(x1);
-					if(curaa){
-						refundee->SetAA(x1, 0);
-						for(int x2=0;x2<curpt;x2++){ //add up all the AA points pt by pt to get the correct cost
-							refundee->GetPP().aapoints += curaa->cost + (curaa->cost_inc * x2);
-							refunded = true;
-						}
-					}
-					else //aa doesn't exist.. but if they bought it then it had at least a cost of 1 point each
-					{ //so give back what we can
-						refundee->GetPP().aapoints += curpt;
-						refundee->SetAA(x1, 0);
-						refunded = true;
-					}
-				}
-			}
+		if(refundee) {
+			refundee->RefundAA();
 		}
 	}
-	if(refunded){
-		refundee->Save(); //save of course
-		refundee->Kick(); //client gets all buggy if we don't immediatly relog so just force it on them
-	}
 }
 
 void command_traindisc(Client *c, const Seperator *sep)
diff --git a/zone/lua_client.cpp b/zone/lua_client.cpp
index 58df9699d..1e079d30e 100644
--- a/zone/lua_client.cpp
+++ b/zone/lua_client.cpp
@@ -6,13 +6,1175 @@
 
 #include "masterentity.h"
 #include "lua_client.h"
+#include "lua_npc.h"
+#include "lua_item.h"
+#include "lua_iteminst.h"
 #include "../common/item.h"
 
 struct InventoryWhere { };
 
+void Lua_Client::SendSound() {
+	Lua_Safe_Call_Void();
+	self->SendSound();
+}
+
+void Lua_Client::Save(int commit_now) {
+	Lua_Safe_Call_Void();
+	self->Save(commit_now);
+}
+
+void Lua_Client::SaveBackup() {
+	Lua_Safe_Call_Void();
+	self->SaveBackup();
+}
+
+bool Lua_Client::Connected() {
+	Lua_Safe_Call_Bool();
+	return self->Connected();
+}
+
+bool Lua_Client::InZone() {
+	Lua_Safe_Call_Bool();
+	return self->InZone();
+}
+
+void Lua_Client::Kick() {
+	Lua_Safe_Call_Void();
+	self->Kick();
+}
+
+void Lua_Client::Disconnect() {
+	Lua_Safe_Call_Void();
+	self->Disconnect();
+}
+
+bool Lua_Client::IsLD() {
+	Lua_Safe_Call_Bool();
+	return self->IsLD();
+}
+
+void Lua_Client::WorldKick() {
+	Lua_Safe_Call_Void();
+	self->WorldKick();
+}
+
+bool Lua_Client::GetAnon() {
+	Lua_Safe_Call_Bool();
+	return self->GetAnon() != 0;
+}
+
+void Lua_Client::Duck() {
+	Lua_Safe_Call_Void();
+	self->Duck();
+}
+
+void Lua_Client::Stand() {
+	Lua_Safe_Call_Void();
+	self->Stand();
+}
+
+void Lua_Client::SetGM(bool v) {
+	Lua_Safe_Call_Void();
+	self->SetGM(v);
+}
+
+void Lua_Client::SetPVP(bool v) {
+	Lua_Safe_Call_Void();
+	self->SetPVP(v);
+}
+
+bool Lua_Client::GetPVP() {
+	Lua_Safe_Call_Bool();
+	return self->GetPVP();
+}
+
+bool Lua_Client::GetGM() {
+	Lua_Safe_Call_Bool();
+	return self->GetGM();
+}
+
+void Lua_Client::SetBaseClass(int v) {
+	Lua_Safe_Call_Void();
+	self->SetBaseClass(v);
+}
+
+void Lua_Client::SetBaseRace(int v) {
+	Lua_Safe_Call_Void();
+	self->SetBaseClass(v);
+}
+
+void Lua_Client::SetBaseGender(int v) {
+	Lua_Safe_Call_Void();
+	self->SetBaseGender(v);
+}
+
+int Lua_Client::GetBaseFace() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseFace();
+}
+
+int Lua_Client::GetLanguageSkill(int skill_id) {
+	Lua_Safe_Call_Int();
+	return self->GetLanguageSkill(skill_id);
+}
+
+const char *Lua_Client::GetLastName() {
+	Lua_Safe_Call_String();
+	return self->GetLastName();
+}
+
+int Lua_Client::GetLDoNPointsTheme(int theme) {
+	Lua_Safe_Call_Int();
+	return self->GetLDoNPointsTheme(theme);
+}
+
+int Lua_Client::GetBaseSTR() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseSTR();
+}
+
+int Lua_Client::GetBaseSTA() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseSTA();
+}
+
+int Lua_Client::GetBaseCHA() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseCHA();
+}
+
+int Lua_Client::GetBaseDEX() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseDEX();
+}
+
+int Lua_Client::GetBaseINT() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseINT();
+}
+
+int Lua_Client::GetBaseAGI() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseAGI();
+}
+
+int Lua_Client::GetBaseWIS() {
+	Lua_Safe_Call_Int();
+	return self->GetBaseWIS();
+}
+
+int Lua_Client::GetWeight() {
+	Lua_Safe_Call_Int();
+	return self->GetWeight();
+}
+
+uint32 Lua_Client::GetEXP() {
+	Lua_Safe_Call_Int();
+	return self->GetEXP();
+}
+
+uint32 Lua_Client::GetAAExp() {
+	Lua_Safe_Call_Int();
+	return self->GetAAXP();
+}
+
+uint32 Lua_Client::GetTotalSecondsPlayed() {
+	Lua_Safe_Call_Int();
+	return self->GetTotalSecondsPlayed();
+}
+
+void Lua_Client::UpdateLDoNPoints(int points, uint32 theme) {
+	Lua_Safe_Call_Void();
+	self->UpdateLDoNPoints(points, theme);
+}
+
+void Lua_Client::SetDeity(int v) {
+	Lua_Safe_Call_Void();
+	self->SetDeity(v);
+}
+
+void Lua_Client::AddEXP(uint32 add_exp, int conlevel, bool resexp) {
+	Lua_Safe_Call_Void();
+	self->AddEXP(add_exp, conlevel, resexp);
+}
+
+void Lua_Client::SetEXP(uint32 set_exp, uint32 set_aaxp, bool resexp) {
+	Lua_Safe_Call_Void();
+	self->SetEXP(set_exp, set_aaxp, resexp);
+}
+
+void Lua_Client::SetBindPoint(int to_zone, float new_x, float new_y, float new_z) {
+	Lua_Safe_Call_Void();
+	self->SetBindPoint(to_zone, new_x, new_y, new_z);
+}
+
+float Lua_Client::GetBindX(int index) {
+	Lua_Safe_Call_Real();
+	return self->GetBindX();
+}
+
+float Lua_Client::GetBindY(int index) {
+	Lua_Safe_Call_Real();
+	return self->GetBindY();
+}
+
+float Lua_Client::GetBindZ(int index) {
+	Lua_Safe_Call_Real();
+	return self->GetBindZ();
+}
+
+float Lua_Client::GetBindHeading(int index) {
+	Lua_Safe_Call_Real();
+	return self->GetBindHeading();
+}
+
+uint32 Lua_Client::GetBindZoneID(int index) {
+	Lua_Safe_Call_Int();
+	return self->GetBindZoneID();
+}
+
+void Lua_Client::MovePC(int zone, float x, float y, float z, float heading) {
+	Lua_Safe_Call_Void();
+	self->MovePC(zone, x, y, z, heading);
+}
+
+void Lua_Client::MovePCInstance(int zone, int instance, float x, float y, float z, float heading) {
+	Lua_Safe_Call_Void();
+	self->MovePC(zone, instance, x, y, z, heading);
+}
+
+void Lua_Client::ChangeLastName(const char *in) {
+	Lua_Safe_Call_Void();
+	self->ChangeLastName(in);
+}
+
+int Lua_Client::GetFactionLevel(uint32 char_id, uint32 npc_id, uint32 race, uint32 class_, uint32 deity, uint32 faction, Lua_NPC npc) {
+	Lua_Safe_Call_Int();
+	return static_cast<int>(self->GetFactionLevel(char_id, npc_id, race, class_, deity, faction, npc));
+}
+
+void Lua_Client::SetFactionLevel(uint32 char_id, uint32 npc_id, int char_class, int char_race, int char_deity) {
+	Lua_Safe_Call_Void();
+	self->SetFactionLevel(char_id, npc_id, char_class, char_race, char_deity);
+}
+
+void Lua_Client::SetFactionLevel2(uint32 char_id, int faction_id, int char_class, int char_race, int char_deity, int value, int temp) {
+	Lua_Safe_Call_Void();
+	self->SetFactionLevel2(char_id, faction_id, char_class, char_race, char_deity, value, temp);
+}
+
+int Lua_Client::GetRawItemAC() {
+	Lua_Safe_Call_Int();
+	return self->GetRawItemAC();
+}
+
+uint32 Lua_Client::AccountID() {
+	Lua_Safe_Call_Int();
+	return self->AccountID();
+}
+
+const char *Lua_Client::AccountName() {
+	Lua_Safe_Call_String();
+	return self->AccountName();
+}
+
+int Lua_Client::Admin() {
+	Lua_Safe_Call_Bool();
+	return self->Admin();
+}
+
+uint32 Lua_Client::CharacterID() {
+	Lua_Safe_Call_Int();
+	return self->CharacterID();
+}
+
+int Lua_Client::GuildRank() {
+	Lua_Safe_Call_Int();
+	return self->GuildRank();
+}
+
+uint32 Lua_Client::GuildID() {
+	Lua_Safe_Call_Int();
+	return self->GuildID();
+}
+
+int Lua_Client::GetFace() {
+	Lua_Safe_Call_Int();
+	return self->GetFace();
+}
+
+bool Lua_Client::TakeMoneyFromPP(uint64 copper, bool update_client) {
+	Lua_Safe_Call_Bool();
+	return self->TakeMoneyFromPP(copper, update_client);
+}
+
+void Lua_Client::AddMoneyToPP(uint32 copper, uint32 silver, uint32 gold, uint32 platinum, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->AddMoneyToPP(copper, silver, gold, platinum, update_client);
+}
+
+bool Lua_Client::TGB() {
+	Lua_Safe_Call_Bool();
+	return self->TGB();
+}
+
+int Lua_Client::GetSkillPoints() {
+	Lua_Safe_Call_Int();
+	return self->GetSkillPoints();
+}
+
+void Lua_Client::SetSkillPoints(int skill) {
+	Lua_Safe_Call_Void();
+	self->SetSkillPoints(skill);
+}
+
+void Lua_Client::IncreaseSkill(int skill_id, int value) {
+	Lua_Safe_Call_Void();
+	self->IncreaseSkill(skill_id, value);
+}
+
+void Lua_Client::IncreaseLanguageSkill(int skill_id, int value) {
+	Lua_Safe_Call_Void();
+	self->IncreaseLanguageSkill(skill_id, value);
+}
+
+int Lua_Client::GetRawSkill(int skill_id) {
+	Lua_Safe_Call_Int();
+	return self->GetRawSkill(static_cast<SkillType>(skill_id));
+}
+
+bool Lua_Client::HasSkill(int skill_id) {
+	Lua_Safe_Call_Bool();
+	return self->HasSkill(static_cast<SkillType>(skill_id));
+}
+
+bool Lua_Client::CanHaveSkill(int skill_id) {
+	Lua_Safe_Call_Bool();
+	return self->CanHaveSkill(static_cast<SkillType>(skill_id));
+}
+
+void Lua_Client::SetSkill(int skill_id, int value) {
+	Lua_Safe_Call_Void();
+	self->SetSkill(static_cast<SkillType>(skill_id), value);
+}
+
+void Lua_Client::AddSkill(int skill_id, int value) {
+	Lua_Safe_Call_Void();
+	self->AddSkill(static_cast<SkillType>(skill_id), value);
+}
+
+void Lua_Client::CheckSpecializeIncrease(int spell_id) {
+	Lua_Safe_Call_Void();
+	self->CheckSpecializeIncrease(spell_id);
+}
+
+void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) {
+	Lua_Safe_Call_Void();
+	self->CheckIncreaseSkill(static_cast<SkillType>(skill_id), target, chance_mod);
+}
+
+void Lua_Client::SetLanguageSkill(int language, int value) {
+	Lua_Safe_Call_Void();
+	self->SetLanguageSkill(language, value);
+}
+
+int Lua_Client::MaxSkill(int skill_id) {
+	Lua_Safe_Call_Int();
+	return self->MaxSkill(static_cast<SkillType>(skill_id));
+}
+
+bool Lua_Client::IsMedding() {
+	Lua_Safe_Call_Bool();
+	return self->IsMedding();
+}
+
+int Lua_Client::GetDuelTarget() {
+	Lua_Safe_Call_Int();
+	return self->GetDuelTarget();
+}
+
+bool Lua_Client::IsDueling() {
+	Lua_Safe_Call_Bool();
+	return self->IsDueling();
+}
+
+void Lua_Client::SetDuelTarget(int c) {
+	Lua_Safe_Call_Void();
+	self->SetDuelTarget(c);
+}
+
+void Lua_Client::SetDueling(bool v) {
+	Lua_Safe_Call_Void();
+	self->SetDueling(v);
+}
+
+void Lua_Client::ResetAA() {
+	Lua_Safe_Call_Void();
+	self->ResetAA();
+}
+
+void Lua_Client::MemSpell(int spell_id, int slot, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->MemSpell(spell_id, slot, update_client);
+}
+
+void Lua_Client::UnmemSpell(int slot, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UnmemSpell(slot, update_client);
+}
+
+void Lua_Client::UnmemSpellAll(bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UnmemSpellAll(update_client);
+}
+
+void Lua_Client::ScribeSpell(int spell_id, int slot, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->ScribeSpell(spell_id, slot, update_client);
+}
+
+void Lua_Client::UnscribeSpell(int slot, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UnscribeSpell(slot, update_client);
+}
+
+void Lua_Client::UnscribeSpellAll(bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UnscribeSpellAll(update_client);
+}
+
+void Lua_Client::UntrainDisc(int slot, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UntrainDisc(slot, update_client);
+}
+
+void Lua_Client::UntrainDiscAll(bool update_client) {
+	Lua_Safe_Call_Void();
+	self->UntrainDiscAll(update_client);
+}
+
+bool Lua_Client::IsSitting() {
+	Lua_Safe_Call_Bool();
+	return self->IsSitting();
+}
+
+void Lua_Client::SetFeigned(bool v) {
+	Lua_Safe_Call_Void();
+	self->SetFeigned(v);
+}
+
+bool Lua_Client::GetFeigned() {
+	Lua_Safe_Call_Bool();
+	return self->GetFeigned();
+}
+
+bool Lua_Client::AutoSplitEnabled() {
+	Lua_Safe_Call_Bool();
+	return self->AutoSplitEnabled();
+}
+
+void Lua_Client::SetHorseId(int id) {
+	Lua_Safe_Call_Void();
+	self->SetHorseId(id);
+}
+
+int Lua_Client::GetHorseId() {
+	Lua_Safe_Call_Int();
+	return self->GetHorseId();
+}
+
+void Lua_Client::NukeItem(uint32 item_num, int where_to_check) {
+	Lua_Safe_Call_Void();
+	self->NukeItem(item_num, where_to_check);
+}
+
+void Lua_Client::SetTint(int slot_id, uint32 color) {
+	Lua_Safe_Call_Void();
+	self->SetTint(slot_id, color);
+}
+
+void Lua_Client::SetMaterial(int slot_id, uint32 item_id) {
+	Lua_Safe_Call_Void();
+	self->SetMaterial(slot_id, item_id);
+}
+
+void Lua_Client::Undye() {
+	Lua_Safe_Call_Void();
+	self->Undye();
+}
+
+int Lua_Client::GetItemIDAt(int slot_id) {
+	Lua_Safe_Call_Int();
+	return self->GetItemIDAt(slot_id);
+}
+
+int Lua_Client::GetAugmentIDAt(int slot_id, int aug_slot) {
+	Lua_Safe_Call_Int();
+	return self->GetAugmentIDAt(slot_id, aug_slot);
+}
+
+void Lua_Client::DeleteItemInInventory(int slot_id, int quantity, bool update_client) {
+	Lua_Safe_Call_Void();
+	self->DeleteItemInInventory(slot_id, quantity, update_client);
+}
+
+void Lua_Client::SummonItem(uint32 item_id, int charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, 
+							bool attuned, int to_slot) {
+	Lua_Safe_Call_Void();
+	self->SummonItem(item_id, charges, aug1, aug2, aug3, aug4, aug5, attuned, to_slot);
+}
+
+void Lua_Client::SetStats(int type, int value) {
+	Lua_Safe_Call_Void();
+	self->SetStats(type, value);
+}
+
+void Lua_Client::IncStats(int type, int value) {
+	Lua_Safe_Call_Void();
+	self->IncStats(type, value);
+}
+
+void Lua_Client::DropItem(int slot_id) {
+	Lua_Safe_Call_Void();
+	self->DropItem(slot_id);
+}
+
+void Lua_Client::BreakInvis() {
+	Lua_Safe_Call_Void();
+	self->BreakInvis();
+}
+
+void Lua_Client::LeaveGroup() {
+	Lua_Safe_Call_Void();
+	self->LeaveGroup();
+}
+
+bool Lua_Client::IsGrouped() {
+	Lua_Safe_Call_Bool();
+	return self->IsGrouped();
+}
+
+bool Lua_Client::IsRaidGrouped() {
+	Lua_Safe_Call_Bool();
+	return self->IsRaidGrouped();
+}
+
+bool Lua_Client::Hungry() {
+	Lua_Safe_Call_Bool();
+	return self->Hungry();
+}
+
+bool Lua_Client::Thirsty() {
+	Lua_Safe_Call_Bool();
+	return self->Thirsty();
+}
+
+int Lua_Client::GetInstrumentMod(int spell_id) {
+	Lua_Safe_Call_Int();
+	return self->GetInstrumentMod(spell_id);
+}
+
+bool Lua_Client::DecreaseByID(uint32 type, int amt) {
+	Lua_Safe_Call_Bool();
+	return self->DecreaseByID(type, amt);
+}
+
+void Lua_Client::Escape() {
+	Lua_Safe_Call_Void();
+	self->Escape();
+}
+
+void Lua_Client::GoFish() {
+	Lua_Safe_Call_Void();
+	self->GoFish();
+}
+
+void Lua_Client::ForageItem(bool guarantee) {
+	Lua_Safe_Call_Void();
+	self->ForageItem(guarantee);
+}
+
+float Lua_Client::CalcPriceMod(Lua_Mob other, bool reverse) {
+	Lua_Safe_Call_Real();
+	return self->CalcPriceMod(other, reverse);
+}
+
+void Lua_Client::ResetTrade() {
+	Lua_Safe_Call_Void();
+	self->ResetTrade();
+}
+
+bool Lua_Client::UseDiscipline(int spell_id, int target_id) {
+	Lua_Safe_Call_Bool();
+	return self->UseDiscipline(spell_id, target_id);
+}
+
+int Lua_Client::GetCharacterFactionLevel(int faction_id) {
+	Lua_Safe_Call_Int();
+	return self->GetCharacterFactionLevel(faction_id);
+}
+
+void Lua_Client::SetZoneFlag(int zone_id) {
+	Lua_Safe_Call_Void();
+	self->SetZoneFlag(zone_id);
+}
+
+void Lua_Client::ClearZoneFlag(int zone_id) {
+	Lua_Safe_Call_Void();
+	self->ClearZoneFlag(zone_id);
+}
+
+bool Lua_Client::HasZoneFlag(int zone_id) {
+	Lua_Safe_Call_Bool();
+	return self->HasZoneFlag(zone_id);
+}
+
+void Lua_Client::SendZoneFlagInfo(Lua_Client to) {
+	Lua_Safe_Call_Void();
+	self->SendZoneFlagInfo(to);
+}
+
+void Lua_Client::SetAATitle(const char *title) {
+	Lua_Safe_Call_Void();
+	self->SetAATitle(title);
+}
+
+int Lua_Client::GetClientVersion() {
+	Lua_Safe_Call_Int();
+	return self->GetClientVersion();
+}
+
+uint32 Lua_Client::GetClientVersionBit() {
+	Lua_Safe_Call_Int();
+	return self->GetClientVersionBit();
+}
+
+void Lua_Client::SetTitleSuffix(const char *text) {
+	Lua_Safe_Call_Void();
+	self->SetTitleSuffix(text);
+}
+
+void Lua_Client::SetAAPoints(int points) {
+	Lua_Safe_Call_Void();
+	self->SetAAPoints(points);
+}
+
+int Lua_Client::GetAAPoints() {
+	Lua_Safe_Call_Int();
+	return self->GetAAPoints();
+}
+
+int Lua_Client::GetSpentAA() {
+	Lua_Safe_Call_Int();
+	return self->GetSpentAA();
+}
+
+void Lua_Client::AddAAPoints(int points) {
+	Lua_Safe_Call_Void();
+	self->AddAAPoints(points);
+}
+
+void Lua_Client::RefundAA() {
+	Lua_Safe_Call_Void();
+	self->RefundAA();
+}
+
+int Lua_Client::GetModCharacterFactionLevel(int faction) {
+	Lua_Safe_Call_Int();
+	return self->GetModCharacterFactionLevel(faction);
+}
+
+int Lua_Client::GetLDoNWins() {
+	Lua_Safe_Call_Int();
+	return self->GetLDoNWins();
+}
+
+int Lua_Client::GetLDoNLosses() {
+	Lua_Safe_Call_Int();
+	return self->GetLDoNLosses();
+}
+
+int Lua_Client::GetLDoNWinsTheme(int theme) {
+	Lua_Safe_Call_Int();
+	return self->GetLDoNWinsTheme(theme);
+}
+
+int Lua_Client::GetLDoNLossesTheme(int theme) {
+	Lua_Safe_Call_Int();
+	return self->GetLDoNLossesTheme(theme);
+}
+
+Lua_ItemInst Lua_Client::GetItemAt(int slot) {
+	Lua_Safe_Call_ItemInst();
+	return Lua_ItemInst(self->GetInv().GetItem(slot));
+}
+
+int Lua_Client::GetStartZone() {
+	Lua_Safe_Call_Int();
+	return self->GetStartZone();
+}
+
+void Lua_Client::SetStartZone(int zone_id, float x, float y, float z) {
+	Lua_Safe_Call_Void();
+	self->SetStartZone(zone_id, x, y, z);
+}
+
+void Lua_Client::KeyRingAdd(uint32 item) {
+	Lua_Safe_Call_Void();
+	self->KeyRingAdd(item);
+}
+
+bool Lua_Client::KeyRingCheck(uint32 item) {
+	Lua_Safe_Call_Bool();
+	return self->KeyRingCheck(item);
+}
+
+void Lua_Client::AddPVPPoints(uint32 points) {
+	Lua_Safe_Call_Void();
+	self->AddPVPPoints(points);
+}
+
+void Lua_Client::AddCrystals(uint32 radiant, uint32 ebon) {
+	Lua_Safe_Call_Void();
+	self->AddCrystals(radiant, ebon);
+}
+
+uint32 Lua_Client::GetPVPPoints() {
+	Lua_Safe_Call_Int();
+	return self->GetPVPPoints();
+}
+
+uint32 Lua_Client::GetRadiantCrystals() {
+	Lua_Safe_Call_Int();
+	return self->GetRadiantCrystals();
+}
+
+uint32 Lua_Client::GetEbonCrystals() {
+	Lua_Safe_Call_Int();
+	return self->GetEbonCrystals();
+}
+
+void Lua_Client::QuestReadBook(const char *text, int type) {
+	Lua_Safe_Call_Void();
+	self->QuestReadBook(text, type);
+}
+
+void Lua_Client::UpdateGroupAAs(int points, uint32 type) {
+	Lua_Safe_Call_Void();
+	self->UpdateGroupAAs(points, type);
+}
+
+uint32 Lua_Client::GetGroupPoints() {
+	Lua_Safe_Call_Int();
+	return self->GetGroupPoints();
+}
+
+uint32 Lua_Client::GetRaidPoints() {
+	Lua_Safe_Call_Int();
+	return self->GetRaidPoints();
+}
+
+void Lua_Client::LearnRecipe(uint32 recipe) {
+	Lua_Safe_Call_Void();
+	self->LearnRecipe(recipe);
+}
+
+int Lua_Client::GetEndurance() {
+	Lua_Safe_Call_Int();
+	return self->GetEndurance();
+}
+
+int Lua_Client::GetMaxEndurance() {
+	Lua_Safe_Call_Int();
+	return self->GetMaxEndurance();
+}
+
+int Lua_Client::GetEndurancePercent() {
+	Lua_Safe_Call_Int();
+	return self->GetEndurancePercent();
+}
+
+void Lua_Client::SetEndurance(int endur) {
+	Lua_Safe_Call_Void();
+	self->SetEndurance(endur);
+}
+
+void Lua_Client::SendOPTranslocateConfirm(Lua_Mob caster, int spell_id) {
+	Lua_Safe_Call_Void();
+	self->SendOPTranslocateConfirm(caster, spell_id);
+}
+
+uint32 Lua_Client::GetIP() {
+	Lua_Safe_Call_Int();
+	return self->GetIP();
+}
+
+void Lua_Client::AddLevelBasedExp(int exp_pct, int max_level) {
+	Lua_Safe_Call_Void();
+	self->AddLevelBasedExp(exp_pct, max_level);
+}
+
+void Lua_Client::IncrementAA(int aa) {
+	Lua_Safe_Call_Void();
+	self->IncrementAA(aa);
+}
+
+void Lua_Client::MarkSingleCompassLoc(float in_x, float in_y, float in_z, int count) {
+	Lua_Safe_Call_Void();
+	self->MarkSingleCompassLoc(in_x, in_y, in_z, count);
+}
+
+int Lua_Client::GetNextAvailableSpellBookSlot(int start) {
+	Lua_Safe_Call_Int();
+	return self->GetNextAvailableSpellBookSlot(start);
+}
+
+int Lua_Client::FindSpellBookSlotBySpellID(int spell_id) {
+	Lua_Safe_Call_Int();
+	return self->FindSpellBookSlotBySpellID(spell_id);
+}
+
+void Lua_Client::UpdateTaskActivity(int task, int activity, int count) {
+	Lua_Safe_Call_Void();
+	self->UpdateTaskActivity(task, activity, count);
+}
+
+void Lua_Client::AssignTask(int task, int npc_id) {
+	Lua_Safe_Call_Void();
+	self->AssignTask(task, npc_id);
+}
+
+void Lua_Client::FailTask(int task) {
+	Lua_Safe_Call_Void();
+	self->FailTask(task);
+}
+
+bool Lua_Client::IsTaskCompleted(int task) {
+	Lua_Safe_Call_Bool();
+	return self->IsTaskCompleted(task) != 0;
+}
+
+bool Lua_Client::IsTaskActive(int task) {
+	Lua_Safe_Call_Bool();
+	return self->IsTaskActive(task);
+}
+
+bool Lua_Client::IsTaskActivityActive(int task, int activity) {
+	Lua_Safe_Call_Bool();
+	return self->IsTaskActivityActive(task, activity);
+}
+
+int Lua_Client::GetCorpseCount() {
+	Lua_Safe_Call_Int();
+	return self->GetCorpseCount();
+}
+
+int Lua_Client::GetCorpseID(int corpse) {
+	Lua_Safe_Call_Int();
+	return self->GetCorpseID(corpse);
+}
+
+int Lua_Client::GetCorpseItemAt(int corpse, int slot) {
+	Lua_Safe_Call_Int();
+	return self->GetCorpseItemAt(corpse, slot);
+}
+
+void Lua_Client::AssignToInstance(int instance_id) {
+	Lua_Safe_Call_Void();
+	self->AssignToInstance(instance_id);
+}
+
+void Lua_Client::Freeze() {
+	Lua_Safe_Call_Void();
+	self->SendAppearancePacket(AT_Anim, ANIM_FREEZE);
+}
+
+void Lua_Client::UnFreeze() {
+	Lua_Safe_Call_Void();
+	self->SendAppearancePacket(AT_Anim, ANIM_STAND);
+}
+
+int Lua_Client::GetAggroCount() {
+	Lua_Safe_Call_Int();
+	return self->GetAggroCount();
+}
+
+uint64 Lua_Client::GetCarriedMoney() {
+	Lua_Safe_Call_Int();
+	return self->GetCarriedMoney();
+}
+
+uint64 Lua_Client::GetAllMoney() {
+	Lua_Safe_Call_Int();
+	return self->GetAllMoney();
+}
+
+void Lua_Client::OpenLFGuildWindow() {
+	Lua_Safe_Call_Void();
+	self->OpenLFGuildWindow();
+}
+
+void Lua_Client::Signal(uint32 id) {
+	Lua_Safe_Call_Void();
+	self->Signal(id);
+}
+
+void Lua_Client::AddAlternateCurrencyValue(uint32 currency, int amount) {
+	Lua_Safe_Call_Void();
+	self->AddAlternateCurrencyValue(currency, amount);
+}
+
+void Lua_Client::SendWebLink(const char *site) {
+	Lua_Safe_Call_Void();
+	self->SendWebLink(site);
+}
+
+bool Lua_Client::HasSpellScribed(int spell_id) {
+	Lua_Safe_Call_Bool();
+	return self->HasSpellScribed(spell_id);
+}
+
+void Lua_Client::SetAccountFlag(std::string flag, std::string val) {
+	Lua_Safe_Call_Void();
+	self->SetAccountFlag(flag, val);
+}
+
+std::string Lua_Client::GetAccountFlag(std::string flag) {
+	Lua_Safe_Call_String();
+	return self->GetAccountFlag(flag);
+}
+
 luabind::scope lua_register_client() {
 	return luabind::class_<Lua_Client, Lua_Mob>("Client")
-		.def(luabind::constructor<>());
+		.def(luabind::constructor<>())
+		.def("SendSound", (void(Lua_Client::*)(void))&Lua_Client::SendSound)
+		.def("Save", (void(Lua_Client::*)(void))&Lua_Client::Save)
+		.def("Save", (void(Lua_Client::*)(int))&Lua_Client::Save)
+		.def("SaveBackup", (void(Lua_Client::*)(void))&Lua_Client::SaveBackup)
+		.def("Connected", (bool(Lua_Client::*)(void))&Lua_Client::Connected)
+		.def("InZone", (bool(Lua_Client::*)(void))&Lua_Client::InZone)
+		.def("Kick", (void(Lua_Client::*)(void))&Lua_Client::Kick)
+		.def("Disconnect", (void(Lua_Client::*)(void))&Lua_Client::Disconnect)
+		.def("IsLD", (bool(Lua_Client::*)(void))&Lua_Client::IsLD)
+		.def("WorldKick", (void(Lua_Client::*)(void))&Lua_Client::WorldKick)
+		.def("GetAnon", (bool(Lua_Client::*)(void))&Lua_Client::GetAnon)
+		.def("Duck", (void(Lua_Client::*)(void))&Lua_Client::Duck)
+		.def("Stand", (void(Lua_Client::*)(void))&Lua_Client::Stand)
+		.def("SetGM", (void(Lua_Client::*)(bool))&Lua_Client::SetGM)
+		.def("SetPVP", (void(Lua_Client::*)(bool))&Lua_Client::SetPVP)
+		.def("GetPVP", (bool(Lua_Client::*)(void))&Lua_Client::GetPVP)
+		.def("GetGM", (bool(Lua_Client::*)(void))&Lua_Client::GetGM)
+		.def("SetBaseClass", (void(Lua_Client::*)(int))&Lua_Client::SetBaseClass)
+		.def("SetBaseRace", (void(Lua_Client::*)(int))&Lua_Client::SetBaseRace)
+		.def("SetBaseGender", (void(Lua_Client::*)(int))&Lua_Client::SetBaseGender)
+		.def("GetBaseFace", (int(Lua_Client::*)(void))&Lua_Client::GetBaseFace)
+		.def("GetLanguageSkill", (int(Lua_Client::*)(int))&Lua_Client::GetLanguageSkill)
+		.def("GetLastName", (const char *(Lua_Client::*)(void))&Lua_Client::GetLastName)
+		.def("GetLDoNPointsTheme", (int(Lua_Client::*)(int))&Lua_Client::GetLDoNPointsTheme)
+		.def("GetBaseSTR", (int(Lua_Client::*)(void))&Lua_Client::GetBaseSTR)
+		.def("GetBaseSTA", (int(Lua_Client::*)(void))&Lua_Client::GetBaseSTA)
+		.def("GetBaseCHA", (int(Lua_Client::*)(void))&Lua_Client::GetBaseCHA)
+		.def("GetBaseDEX", (int(Lua_Client::*)(void))&Lua_Client::GetBaseDEX)
+		.def("GetBaseINT", (int(Lua_Client::*)(void))&Lua_Client::GetBaseINT)
+		.def("GetBaseAGI", (int(Lua_Client::*)(void))&Lua_Client::GetBaseAGI)
+		.def("GetBaseWIS", (int(Lua_Client::*)(void))&Lua_Client::GetBaseWIS)
+		.def("GetWeight", (int(Lua_Client::*)(void))&Lua_Client::GetWeight)
+		.def("GetEXP", (uint32(Lua_Client::*)(void))&Lua_Client::GetEXP)
+		.def("GetAAExp", (uint32(Lua_Client::*)(void))&Lua_Client::GetAAExp)
+		.def("GetTotalSecondsPlayed", (uint32(Lua_Client::*)(void))&Lua_Client::GetTotalSecondsPlayed)
+		.def("UpdateLDoNPoints", (void(Lua_Client::*)(int,uint32))&Lua_Client::UpdateLDoNPoints)
+		.def("SetDeity", (void(Lua_Client::*)(int v))&Lua_Client::SetDeity)
+		.def("AddEXP", (void(Lua_Client::*)(uint32))&Lua_Client::AddEXP)
+		.def("AddEXP", (void(Lua_Client::*)(uint32,int))&Lua_Client::AddEXP)
+		.def("AddEXP", (void(Lua_Client::*)(uint32,int,bool))&Lua_Client::AddEXP)
+		.def("SetEXP", (void(Lua_Client::*)(uint32,uint32))&Lua_Client::SetEXP)
+		.def("SetEXP", (void(Lua_Client::*)(uint32,uint32,bool))&Lua_Client::SetEXP)
+		.def("SetBindPoint", (void(Lua_Client::*)(void))&Lua_Client::SetBindPoint)
+		.def("SetBindPoint", (void(Lua_Client::*)(int))&Lua_Client::SetBindPoint)
+		.def("SetBindPoint", (void(Lua_Client::*)(int,float))&Lua_Client::SetBindPoint)
+		.def("SetBindPoint", (void(Lua_Client::*)(int,float,float))&Lua_Client::SetBindPoint)
+		.def("SetBindPoint", (void(Lua_Client::*)(int,float,float,float))&Lua_Client::SetBindPoint)
+		.def("GetBindX", (float(Lua_Client::*)(void))&Lua_Client::GetBindX)
+		.def("GetBindX", (float(Lua_Client::*)(int))&Lua_Client::GetBindX)
+		.def("GetBindY", (float(Lua_Client::*)(void))&Lua_Client::GetBindY)
+		.def("GetBindY", (float(Lua_Client::*)(int))&Lua_Client::GetBindY)
+		.def("GetBindZ", (float(Lua_Client::*)(void))&Lua_Client::GetBindZ)
+		.def("GetBindZ", (float(Lua_Client::*)(int))&Lua_Client::GetBindZ)
+		.def("GetBindHeading", (float(Lua_Client::*)(void))&Lua_Client::GetBindHeading)
+		.def("GetBindHeading", (float(Lua_Client::*)(int))&Lua_Client::GetBindHeading)
+		.def("GetBindZoneID", (uint32(Lua_Client::*)(void))&Lua_Client::GetBindZoneID)
+		.def("GetBindZoneID", (uint32(Lua_Client::*)(int))&Lua_Client::GetBindZoneID)
+		.def("MovePC", (void(Lua_Client::*)(int,float,float,float,float))&Lua_Client::MovePC)
+		.def("MovePCInstance", (void(Lua_Client::*)(int,int,float,float,float,float))&Lua_Client::MovePCInstance)
+		.def("ChangeLastName", (void(Lua_Client::*)(const char *in))&Lua_Client::ChangeLastName)
+		.def("GetFactionLevel", (int(Lua_Client::*)(uint32,uint32,uint32,uint32,uint32,uint32,Lua_NPC))&Lua_Client::GetFactionLevel)
+		.def("SetFactionLevel", (void(Lua_Client::*)(uint32,uint32,int,int,int))&Lua_Client::SetFactionLevel)
+		.def("SetFactionLevel2", (void(Lua_Client::*)(uint32,int,int,int,int,int,int))&Lua_Client::SetFactionLevel2)
+		.def("GetRawItemAC", (int(Lua_Client::*)(void))&Lua_Client::GetRawItemAC)
+		.def("AccountID", (uint32(Lua_Client::*)(void))&Lua_Client::AccountID)
+		.def("AccountName", (const char *(Lua_Client::*)(void))&Lua_Client::AccountName)
+		.def("Admin", (int(Lua_Client::*)(void))&Lua_Client::Admin)
+		.def("CharacterID", (uint32(Lua_Client::*)(void))&Lua_Client::CharacterID)
+		.def("GuildRank", (int(Lua_Client::*)(void))&Lua_Client::GuildRank)
+		.def("GuildID", (uint32(Lua_Client::*)(void))&Lua_Client::GuildID)
+		.def("GetFace", (int(Lua_Client::*)(void))&Lua_Client::GetFace)
+		.def("TakeMoneyFromPP", (bool(Lua_Client::*)(uint64))&Lua_Client::TakeMoneyFromPP)
+		.def("TakeMoneyFromPP", (bool(Lua_Client::*)(uint64,bool))&Lua_Client::TakeMoneyFromPP)
+		.def("AddMoneyToPP", (void(Lua_Client::*)(uint32,uint32,uint32,uint32))&Lua_Client::AddMoneyToPP)
+		.def("AddMoneyToPP", (void(Lua_Client::*)(uint32,uint32,uint32,uint32,bool))&Lua_Client::AddMoneyToPP)
+		.def("TGB", (bool(Lua_Client::*)(void))&Lua_Client::TGB)
+		.def("GetSkillPoints", (int(Lua_Client::*)(void))&Lua_Client::GetSkillPoints)
+		.def("SetSkillPoints", (void(Lua_Client::*)(int))&Lua_Client::SetSkillPoints)
+		.def("IncreaseSkill", (void(Lua_Client::*)(int))&Lua_Client::IncreaseSkill)
+		.def("IncreaseSkill", (void(Lua_Client::*)(int,int))&Lua_Client::IncreaseSkill)
+		.def("IncreaseLanguageSkill", (void(Lua_Client::*)(int))&Lua_Client::IncreaseLanguageSkill)
+		.def("IncreaseLanguageSkill", (void(Lua_Client::*)(int,int))&Lua_Client::IncreaseLanguageSkill)
+		.def("GetRawSkill", (int(Lua_Client::*)(int))&Lua_Client::GetRawSkill)
+		.def("HasSkill", (bool(Lua_Client::*)(int))&Lua_Client::HasSkill)
+		.def("CanHaveSkill", (bool(Lua_Client::*)(int))&Lua_Client::CanHaveSkill)
+		.def("SetSkill", (void(Lua_Client::*)(int,int))&Lua_Client::SetSkill)
+		.def("AddSkill", (void(Lua_Client::*)(int,int))&Lua_Client::AddSkill)
+		.def("CheckSpecializeIncrease", (void(Lua_Client::*)(int))&Lua_Client::CheckSpecializeIncrease)
+		.def("CheckIncreaseSkill", (void(Lua_Client::*)(int,Lua_Mob))&Lua_Client::CheckIncreaseSkill)
+		.def("CheckIncreaseSkill", (void(Lua_Client::*)(int,Lua_Mob,int))&Lua_Client::CheckIncreaseSkill)
+		.def("SetLanguageSkill", (void(Lua_Client::*)(int,int))&Lua_Client::SetLanguageSkill)
+		.def("MaxSkill", (int(Lua_Client::*)(int))&Lua_Client::MaxSkill)
+		.def("IsMedding", (bool(Lua_Client::*)(void))&Lua_Client::IsMedding)
+		.def("GetDuelTarget", (int(Lua_Client::*)(void))&Lua_Client::GetDuelTarget)
+		.def("IsDueling", (bool(Lua_Client::*)(void))&Lua_Client::IsDueling)
+		.def("SetDuelTarget", (void(Lua_Client::*)(int))&Lua_Client::SetDuelTarget)
+		.def("SetDueling", (void(Lua_Client::*)(bool))&Lua_Client::SetDueling)
+		.def("ResetAA", (void(Lua_Client::*)(void))&Lua_Client::ResetAA)
+		.def("MemSpell", (void(Lua_Client::*)(int,int))&Lua_Client::MemSpell)
+		.def("MemSpell", (void(Lua_Client::*)(int,int,bool))&Lua_Client::MemSpell)
+		.def("UnmemSpell", (void(Lua_Client::*)(int))&Lua_Client::UnmemSpell)
+		.def("UnmemSpell", (void(Lua_Client::*)(int,bool))&Lua_Client::UnmemSpell)
+		.def("UnmemSpellAll", (void(Lua_Client::*)(void))&Lua_Client::UnmemSpellAll)
+		.def("UnmemSpellAll", (void(Lua_Client::*)(bool))&Lua_Client::UnmemSpellAll)
+		.def("ScribeSpell", (void(Lua_Client::*)(int,int))&Lua_Client::ScribeSpell)
+		.def("ScribeSpell", (void(Lua_Client::*)(int,int,bool))&Lua_Client::ScribeSpell)
+		.def("UnscribeSpell", (void(Lua_Client::*)(int))&Lua_Client::UnscribeSpell)
+		.def("UnscribeSpell", (void(Lua_Client::*)(int,bool))&Lua_Client::UnscribeSpell)
+		.def("UnscribeSpellAll", (void(Lua_Client::*)(void))&Lua_Client::UnscribeSpellAll)
+		.def("UnscribeSpellAll", (void(Lua_Client::*)(bool))&Lua_Client::UnscribeSpellAll)
+		.def("UntrainDisc", (void(Lua_Client::*)(int))&Lua_Client::UntrainDisc)
+		.def("UntrainDisc", (void(Lua_Client::*)(int,bool))&Lua_Client::UntrainDisc)
+		.def("UntrainDiscAll", (void(Lua_Client::*)(void))&Lua_Client::UntrainDiscAll)
+		.def("UntrainDiscAll", (void(Lua_Client::*)(bool))&Lua_Client::UntrainDiscAll)
+		.def("IsSitting", (bool(Lua_Client::*)(void))&Lua_Client::IsSitting)
+		.def("SetFeigned", (void(Lua_Client::*)(bool))&Lua_Client::SetFeigned)
+		.def("GetFeigned", (bool(Lua_Client::*)(void))&Lua_Client::GetFeigned)
+		.def("AutoSplitEnabled", (bool(Lua_Client::*)(void))&Lua_Client::AutoSplitEnabled)
+		.def("SetHorseId", (void(Lua_Client::*)(int))&Lua_Client::SetHorseId)
+		.def("GetHorseId", (int(Lua_Client::*)(void))&Lua_Client::GetHorseId)
+		.def("NukeItem", (void(Lua_Client::*)(uint32,int))&Lua_Client::NukeItem)
+		.def("SetTint", (void(Lua_Client::*)(int,uint32))&Lua_Client::SetTint)
+		.def("SetMaterial", (void(Lua_Client::*)(int,uint32))&Lua_Client::SetMaterial)
+		.def("Undye", (void(Lua_Client::*)(void))&Lua_Client::Undye)
+		.def("GetItemIDAt", (int(Lua_Client::*)(int))&Lua_Client::GetItemIDAt)
+		.def("GetAugmentIDAt", (int(Lua_Client::*)(int,int))&Lua_Client::GetAugmentIDAt)
+		.def("DeleteItemInInventory", (void(Lua_Client::*)(int,int))&Lua_Client::DeleteItemInInventory)
+		.def("DeleteItemInInventory", (void(Lua_Client::*)(int,int,bool))&Lua_Client::DeleteItemInInventory)
+		.def("SummonItem", (void(Lua_Client::*)(uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32,uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32,uint32,uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32,uint32,uint32,uint32))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32,uint32,uint32,uint32,bool))&Lua_Client::SummonItem)
+		.def("SummonItem", (void(Lua_Client::*)(uint32,int,uint32,uint32,uint32,uint32,uint32,bool,int))&Lua_Client::SummonItem) 
+		.def("SetStats", (void(Lua_Client::*)(int,int))&Lua_Client::SetStats)
+		.def("IncStats", (void(Lua_Client::*)(int,int))&Lua_Client::IncStats)
+		.def("DropItem", (void(Lua_Client::*)(int))&Lua_Client::DropItem)
+		.def("BreakInvis", (void(Lua_Client::*)(void))&Lua_Client::BreakInvis)
+		.def("LeaveGroup", (void(Lua_Client::*)(void))&Lua_Client::LeaveGroup)
+		.def("IsGrouped", (bool(Lua_Client::*)(void))&Lua_Client::IsGrouped)
+		.def("IsRaidGrouped", (bool(Lua_Client::*)(void))&Lua_Client::IsRaidGrouped)
+		.def("Hungry", (bool(Lua_Client::*)(void))&Lua_Client::Hungry)
+		.def("Thirsty", (bool(Lua_Client::*)(void))&Lua_Client::Thirsty)
+		.def("GetInstrumentMod", (int(Lua_Client::*)(int))&Lua_Client::GetInstrumentMod)
+		.def("DecreaseByID", (bool(Lua_Client::*)(uint32,int))&Lua_Client::DecreaseByID)
+		.def("Escape", (void(Lua_Client::*)(void))&Lua_Client::Escape)
+		.def("GoFish", (void(Lua_Client::*)(void))&Lua_Client::GoFish)
+		.def("ForageItem", (void(Lua_Client::*)(void))&Lua_Client::ForageItem)
+		.def("ForageItem", (void(Lua_Client::*)(bool))&Lua_Client::ForageItem)
+		.def("CalcPriceMod", (float(Lua_Client::*)(Lua_Mob,bool))&Lua_Client::CalcPriceMod)
+		.def("ResetTrade", (void(Lua_Client::*)(void))&Lua_Client::ResetTrade)
+		.def("UseDiscipline", (bool(Lua_Client::*)(int,int))&Lua_Client::UseDiscipline)
+		.def("GetCharacterFactionLevel", (int(Lua_Client::*)(int))&Lua_Client::GetCharacterFactionLevel)
+		.def("SetZoneFlag", (void(Lua_Client::*)(int))&Lua_Client::SetZoneFlag)
+		.def("ClearZoneFlag", (void(Lua_Client::*)(int))&Lua_Client::ClearZoneFlag)
+		.def("HasZoneFlag", (bool(Lua_Client::*)(int))&Lua_Client::HasZoneFlag)
+		.def("SendZoneFlagInfo", (void(Lua_Client::*)(Lua_Client))&Lua_Client::SendZoneFlagInfo)
+		.def("SetAATitle", (void(Lua_Client::*)(const char *))&Lua_Client::SetAATitle)
+		.def("GetClientVersion", (int(Lua_Client::*)(void))&Lua_Client::GetClientVersion)
+		.def("GetClientVersionBit", (uint32(Lua_Client::*)(void))&Lua_Client::GetClientVersionBit)
+		.def("SetTitleSuffix", (void(Lua_Client::*)(const char *))&Lua_Client::SetTitleSuffix)
+		.def("SetAAPoints", (void(Lua_Client::*)(int))&Lua_Client::SetAAPoints)
+		.def("GetAAPoints", (int(Lua_Client::*)(void))&Lua_Client::GetAAPoints)
+		.def("GetSpentAA", (int(Lua_Client::*)(void))&Lua_Client::GetSpentAA)
+		.def("AddAAPoints", (void(Lua_Client::*)(int))&Lua_Client::AddAAPoints)
+		.def("RefundAA", (void(Lua_Client::*)(void))&Lua_Client::RefundAA)
+		.def("GetModCharacterFactionLevel", (int(Lua_Client::*)(int))&Lua_Client::GetModCharacterFactionLevel)
+		.def("GetLDoNWins", (int(Lua_Client::*)(void))&Lua_Client::GetLDoNWins)
+		.def("GetLDoNLosses", (int(Lua_Client::*)(void))&Lua_Client::GetLDoNLosses)
+		.def("GetLDoNWinsTheme", (int(Lua_Client::*)(int))&Lua_Client::GetLDoNWinsTheme)
+		.def("GetLDoNLossesTheme", (int(Lua_Client::*)(int))&Lua_Client::GetLDoNLossesTheme)
+		.def("GetItemAt", (Lua_ItemInst(Lua_Client::*)(int))&Lua_Client::GetItemAt)
+		.def("GetStartZone", (int(Lua_Client::*)(void))&Lua_Client::GetStartZone)
+		.def("SetStartZone", (void(Lua_Client::*)(int))&Lua_Client::SetStartZone)
+		.def("SetStartZone", (void(Lua_Client::*)(int,float))&Lua_Client::SetStartZone)
+		.def("SetStartZone", (void(Lua_Client::*)(int,float,float))&Lua_Client::SetStartZone)
+		.def("SetStartZone", (void(Lua_Client::*)(int,float,float,float))&Lua_Client::SetStartZone)
+		.def("KeyRingAdd", (void(Lua_Client::*)(uint32))&Lua_Client::KeyRingAdd)
+		.def("KeyRingCheck", (bool(Lua_Client::*)(uint32))&Lua_Client::KeyRingCheck)
+		.def("AddPVPPoints", (void(Lua_Client::*)(uint32))&Lua_Client::AddPVPPoints)
+		.def("AddCrystals", (void(Lua_Client::*)(uint32,uint32))&Lua_Client::AddCrystals)
+		.def("GetPVPPoints", (uint32(Lua_Client::*)(void))&Lua_Client::GetPVPPoints)
+		.def("GetRadiantCrystals", (uint32(Lua_Client::*)(void))&Lua_Client::GetRadiantCrystals)
+		.def("GetEbonCrystals", (uint32(Lua_Client::*)(void))&Lua_Client::GetEbonCrystals)
+		.def("QuestReadBook", (void(Lua_Client::*)(const char *,int))&Lua_Client::QuestReadBook)
+		.def("UpdateGroupAAs", (void(Lua_Client::*)(int,uint32))&Lua_Client::UpdateGroupAAs)
+		.def("GetGroupPoints", (uint32(Lua_Client::*)(void))&Lua_Client::GetGroupPoints)
+		.def("GetRaidPoints", (uint32(Lua_Client::*)(void))&Lua_Client::GetRaidPoints)
+		.def("LearnRecipe", (void(Lua_Client::*)(uint32))&Lua_Client::LearnRecipe)
+		.def("GetEndurance", (int(Lua_Client::*)(void))&Lua_Client::GetEndurance)
+		.def("GetMaxEndurance", (int(Lua_Client::*)(void))&Lua_Client::GetMaxEndurance)
+		.def("GetEndurancePercent", (int(Lua_Client::*)(void))&Lua_Client::GetEndurancePercent)
+		.def("SetEndurance", (void(Lua_Client::*)(int))&Lua_Client::SetEndurance)
+		.def("SendOPTranslocateConfirm", (void(Lua_Client::*)(Lua_Mob,int))&Lua_Client::SendOPTranslocateConfirm)
+		.def("GetIP", (uint32(Lua_Client::*)(void))&Lua_Client::GetIP)
+		.def("AddLevelBasedExp", (void(Lua_Client::*)(int))&Lua_Client::AddLevelBasedExp)
+		.def("AddLevelBasedExp", (void(Lua_Client::*)(int,int))&Lua_Client::AddLevelBasedExp)
+		.def("IncrementAA", (void(Lua_Client::*)(int))&Lua_Client::IncrementAA)
+		.def("MarkSingleCompassLoc", (void(Lua_Client::*)(float,float,float))&Lua_Client::MarkSingleCompassLoc)
+		.def("MarkSingleCompassLoc", (void(Lua_Client::*)(float,float,float,int))&Lua_Client::MarkSingleCompassLoc)
+		.def("GetNextAvailableSpellBookSlot", (int(Lua_Client::*)(void))&Lua_Client::GetNextAvailableSpellBookSlot)
+		.def("GetNextAvailableSpellBookSlot", (int(Lua_Client::*)(int))&Lua_Client::GetNextAvailableSpellBookSlot)
+		.def("FindSpellBookSlotBySpellID", (int(Lua_Client::*)(int))&Lua_Client::FindSpellBookSlotBySpellID)
+		.def("UpdateTaskActivity", (void(Lua_Client::*)(int,int,int))&Lua_Client::UpdateTaskActivity)
+		.def("AssignTask", (void(Lua_Client::*)(int,int))&Lua_Client::AssignTask)
+		.def("FailTask", (void(Lua_Client::*)(int))&Lua_Client::FailTask)
+		.def("IsTaskCompleted", (bool(Lua_Client::*)(int))&Lua_Client::IsTaskCompleted)
+		.def("IsTaskActive", (bool(Lua_Client::*)(int))&Lua_Client::IsTaskActive)
+		.def("IsTaskActivityActive", (bool(Lua_Client::*)(int,int))&Lua_Client::IsTaskActivityActive)
+		.def("GetCorpseCount", (int(Lua_Client::*)(void))&Lua_Client::GetCorpseCount)
+		.def("GetCorpseID", (int(Lua_Client::*)(int))&Lua_Client::GetCorpseID)
+		.def("GetCorpseItemAt", (int(Lua_Client::*)(int,int))&Lua_Client::GetCorpseItemAt)
+		.def("AssignToInstance", (void(Lua_Client::*)(int))&Lua_Client::AssignToInstance)
+		.def("Freeze", (void(Lua_Client::*)(void))&Lua_Client::Freeze)
+		.def("UnFreeze", (void(Lua_Client::*)(void))&Lua_Client::UnFreeze)
+		.def("GetAggroCount", (int(Lua_Client::*)(void))&Lua_Client::GetAggroCount)
+		.def("GetCarriedMoney", (uint64(Lua_Client::*)(void))&Lua_Client::GetCarriedMoney)
+		.def("GetAllMoney", (uint64(Lua_Client::*)(void))&Lua_Client::GetAllMoney)
+		.def("OpenLFGuildWindow", (void(Lua_Client::*)(void))&Lua_Client::OpenLFGuildWindow)
+		.def("Signal", (void(Lua_Client::*)(uint32))&Lua_Client::Signal)
+		.def("AddAlternateCurrencyValue", (void(Lua_Client::*)(uint32,int))&Lua_Client::AddAlternateCurrencyValue)
+		.def("SendWebLink", (void(Lua_Client::*)(const char *))&Lua_Client::SendWebLink)
+		.def("HasSpellScribed", (bool(Lua_Client::*)(int))&Lua_Client::HasSpellScribed)
+		.def("SetAccountFlag", (void(Lua_Client::*)(std::string,std::string))&Lua_Client::SetAccountFlag)
+		.def("GetAccountFlag", (std::string(Lua_Client::*)(std::string))&Lua_Client::GetAccountFlag);
 }
 
 luabind::scope lua_register_inventory_where() {
@@ -27,4 +1189,6 @@ luabind::scope lua_register_inventory_where() {
 		];
 }
 
+
+
 #endif
diff --git a/zone/lua_client.h b/zone/lua_client.h
index 2ba3670b6..8769d4426 100644
--- a/zone/lua_client.h
+++ b/zone/lua_client.h
@@ -30,10 +30,8 @@ public:
 		return nullptr;
 	}
 
-	/*
 	void SendSound();
-	void Save();
-	void Save(bool commit_now);
+	void Save(int commit_now = 0);
 	void SaveBackup();
 	bool Connected();
 	bool InZone();
@@ -52,9 +50,9 @@ public:
 	void SetBaseRace(int v);
 	void SetBaseGender(int v);
 	int GetBaseFace();
-	int GetLanguageSkill();
-	int GetLastName();
-	int GetLDoNPointsTheme();
+	int GetLanguageSkill(int skill_id);
+	const char *GetLastName();
+	int GetLDoNPointsTheme(int theme);
 	int GetBaseSTR();
 	int GetBaseSTA();
 	int GetBaseCHA();
@@ -70,7 +68,7 @@ public:
 	void SetDeity(int v);
 	void AddEXP(uint32 add_exp, int conlevel = 255, bool resexp = false);
 	void SetEXP(uint32 set_exp, uint32 set_aaxp, bool resexp = false);
-	SetBindPoint(int to_zone = -1, float new_x = 0.0f, float new_y = 0.0f, float new_z = 0.0f);
+	void SetBindPoint(int to_zone = -1, float new_x = 0.0f, float new_y = 0.0f, float new_z = 0.0f);
 	float GetBindX(int index = 0);
 	float GetBindY(int index = 0);
 	float GetBindZ(int index = 0);
@@ -79,24 +77,25 @@ public:
 	void MovePC(int zone, float x, float y, float z, float heading);
 	void MovePCInstance(int zone, int instance, float x, float y, float z, float heading);
 	void ChangeLastName(const char *in);
-	int GetFactionLevel(uint32 char_id, uint32 npc_id, uint32 race, uint32 class, uint32 deity, uint32 faction, Lua_NPC npc);
+	int GetFactionLevel(uint32 char_id, uint32 npc_id, uint32 race, uint32 class_, uint32 deity, uint32 faction, Lua_NPC npc);
 	void SetFactionLevel(uint32 char_id, uint32 npc_id, int char_class, int char_race, int char_deity);
 	void SetFactionLevel2(uint32 char_id, int faction_id, int char_class, int char_race, int char_deity, int value, int temp);
 	int GetRawItemAC();
 	uint32 AccountID();
 	const char *AccountName();
-	bool Admin();
+	int Admin();
 	uint32 CharacterID();
 	int GuildRank();
 	uint32 GuildID();
 	int GetFace();
+
 	bool TakeMoneyFromPP(uint64 copper, bool update_client = false);
 	void AddMoneyToPP(uint32 copper, uint32 silver, uint32 gold, uint32 platinum, bool update_client = false);
 	bool TGB();
 	int GetSkillPoints();
 	void SetSkillPoints(int skill);
-	void IncreaseSkill(int skill_id, int value);
-	void IncreaseLanguageSkill(int skill_id, int value);
+	void IncreaseSkill(int skill_id, int value = 1);
+	void IncreaseLanguageSkill(int skill_id, int value = 1);
 	int GetRawSkill(int skill_id);
 	bool HasSkill(int skill_id);
 	bool CanHaveSkill(int skill_id);
@@ -105,11 +104,11 @@ public:
 	void CheckSpecializeIncrease(int spell_id);
 	void CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod = 0);
 	void SetLanguageSkill(int language, int value);
-	int MaxSkill(int spell_id);
+	int MaxSkill(int skill_id);
 	bool IsMedding();
-	Lua_Client GetDuelTarget();
+	int GetDuelTarget();
 	bool IsDueling();
-	void SetDuelTarget(Lua_Client c);
+	void SetDuelTarget(int c);
 	void SetDueling(bool v);
 	void ResetAA();
 	void MemSpell(int spell_id, int slot, bool update_client = true);
@@ -129,7 +128,7 @@ public:
 	void NukeItem(uint32 item_num, int where_to_check);
 	void SetTint(int slot_id, uint32 color);
 	void SetMaterial(int slot_id, uint32 item_id);
-	void Undye(int slot_id);
+	void Undye();
 	int GetItemIDAt(int slot_id);
 	int GetAugmentIDAt(int slot_id, int aug_slot);
 	void DeleteItemInInventory(int slot_id, int quantity, bool update_client = true);
@@ -137,7 +136,7 @@ public:
 					uint32 aug5 = 0, bool attuned = false, int to_slot = 30);
 	void SetStats(int type, int value);
 	void IncStats(int type, int value);
-	int DropItem(int slot_id);
+	void DropItem(int slot_id);
 	void BreakInvis();
 	void LeaveGroup();
 	bool IsGrouped();
@@ -181,7 +180,7 @@ public:
 	uint32 GetPVPPoints();
 	uint32 GetRadiantCrystals();
 	uint32 GetEbonCrystals();
-	void ReadBook(const char *text, int type);
+	void QuestReadBook(const char *text, int type);
 	void UpdateGroupAAs(int points, uint32 type);
 	uint32 GetGroupPoints();
 	uint32 GetRaidPoints();
@@ -191,18 +190,18 @@ public:
 	int GetEndurancePercent();
 	void SetEndurance(int endur);
 	void SendOPTranslocateConfirm(Lua_Mob caster, int spell_id);
-	const char *GetIP();
+	uint32 GetIP();
 	void AddLevelBasedExp(int exp_pct, int max_level = 0);
 	void IncrementAA(int aa);
-	MarkSingleCompassLoc(float in_x, float in_y, float in_z, int count = 1);
-	int GetFreeSpellBookSlot(int start = 0);
-	int GetSpellBookSlotBySpellID(int spell_id);
+	void MarkSingleCompassLoc(float in_x, float in_y, float in_z, int count = 1);
+	int GetNextAvailableSpellBookSlot(int start = 0);
+	int FindSpellBookSlotBySpellID(int spell_id);
 	void UpdateTaskActivity(int task, int activity, int count);
 	void AssignTask(int task, int npc_id);
 	void FailTask(int task);
 	bool IsTaskCompleted(int task);
 	bool IsTaskActive(int task);
-	bool IsTaskActivityActive(int task, int activty);
+	bool IsTaskActivityActive(int task, int activity);
 	int GetCorpseCount();
 	int GetCorpseID(int corpse);
 	int GetCorpseItemAt(int corpse, int slot);
@@ -218,8 +217,9 @@ public:
 	void SendWebLink(const char *site);
 	bool HasSpellScribed(int spell_id);
 	void SetAccountFlag(std::string flag, std::string val);
-	std::string value GetAccountFlag(std::string flag);
+	std::string GetAccountFlag(std::string flag);
 
+	/*
 	//unsup features
 	Lua_Group GetGroup();
 	Lua_Raid GetRaid();
diff --git a/zone/lua_parser.cpp b/zone/lua_parser.cpp
index fa2901833..fbb06124a 100644
--- a/zone/lua_parser.cpp
+++ b/zone/lua_parser.cpp
@@ -10,10 +10,10 @@
 #include <stdio.h>
 #include <sstream>
 #include <vector>
+#include <algorithm>
 
 #include "masterentity.h"
 #include "../common/spdat.h"
-#include "../common/seperator.h"
 #include "lua_entity.h"
 #include "lua_item.h"
 #include "lua_iteminst.h"
@@ -767,14 +767,7 @@ void LuaParser::LoadScript(std::string filename, std::string package_name) {
 }
 
 bool LuaParser::HasFunction(std::string subname, std::string package_name) {
-	size_t sz = subname.length();
-	for(size_t i = 0; i < sz; ++i) {
-		char c = subname[i];
-		if(65 <= c && c <= 90) {
-			c += 32;
-		}
-		subname[i] = c;
-	}
+	std::transform(subname.begin(), subname.end(), subname.begin(), ::tolower);
 
 	auto iter = loaded_.find(package_name);
 	if(iter == loaded_.end()) {
diff --git a/zone/perl_client.cpp b/zone/perl_client.cpp
index 09201f1d6..da09a8e81 100644
--- a/zone/perl_client.cpp
+++ b/zone/perl_client.cpp
@@ -3940,8 +3940,7 @@ XS(XS_Client_SetAAPoints) {
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		THIS->GetPP().aapoints = points;
-		THIS->SendAAStats();
+		THIS->SetAAPoints(points);
 	}
 	XSRETURN_EMPTY;
 }
@@ -3965,7 +3964,7 @@ XS(XS_Client_GetAAPoints) {
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		RETVAL = THIS->GetPP().aapoints;
+		RETVAL = THIS->GetAAPoints();
 		XSprePUSH; PUSHu((UV)RETVAL);
 	}
 	XSRETURN(1);
@@ -3990,7 +3989,7 @@ XS(XS_Client_GetSpentAA) {
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		RETVAL = THIS->GetPP().aapoints_spent;
+		RETVAL = THIS->GetSpentAA();
 		XSprePUSH; PUSHu((UV)RETVAL);
 	}
 	XSRETURN(1);
@@ -4014,8 +4013,7 @@ XS(XS_Client_AddAAPoints) {
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		THIS->GetPP().aapoints += points;
-		THIS->SendAAStats();
+		THIS->AddAAPoints(points);
 	}
 	XSRETURN_EMPTY;
 }
@@ -4875,22 +4873,7 @@ XS(XS_Client_IncrementAA)
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		SendAA_Struct* aa2 = zone->FindAA(aaskillid);
-
-		if(aa2 == nullptr)
-			Perl_croak(aTHX_ "Invalid AA.");
-
-		if(THIS->GetAA(aaskillid) == aa2->max_level)
-			Perl_croak(aTHX_ "AA at Max already.");
-
-		THIS->SetAA(aaskillid, THIS->GetAA(aaskillid)+1);
-
-		THIS->Save();
-
-		THIS->SendAA(aaskillid);
-		THIS->SendAATable();
-		THIS->SendAAStats();
-		THIS->CalcBonuses();
+		THIS->IncrementAA(aaskillid);
 	}
 	XSRETURN_EMPTY;
 }
@@ -5205,7 +5188,7 @@ XS(XS_Client_GetCorpseCount)
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		RETVAL = database.GetPlayerCorpseCount(THIS->CharacterID());
+		RETVAL = THIS->GetCorpseCount();
 		XSprePUSH; PUSHi((IV)RETVAL);
 	}
 	XSRETURN(1);
@@ -5232,7 +5215,7 @@ XS(XS_Client_GetCorpseID)
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		RETVAL = database.GetPlayerCorpseID(THIS->CharacterID(), corpse);
+		RETVAL = THIS->GetCorpseID(corpse);
 		XSprePUSH; PUSHi((IV)RETVAL);
 	}
 	XSRETURN(1);
@@ -5260,7 +5243,7 @@ XS(XS_Client_GetCorpseItemAt)
 		if(THIS == nullptr)
 			Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
 
-		RETVAL = database.GetPlayerCorpseItemAt(corpse_id, slotid);
+		RETVAL = THIS->GetCorpseItemAt(corpse_id, slotid);
 		XSprePUSH; PUSHi((IV)RETVAL);
 	}
 	XSRETURN(1);