pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-13 14:41:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Regression fixes, support for new lua arguments for many events

Browse Source
This commit is contained in:
KimLS 2013-06-19 22:56:46 -07:00
parent bb8d11a57b
commit d8a1d84a49
30 changed files with 797 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
common/Item.cpp
View File

@ -632,6 +632,23 @@ std::string ItemInst::GetCustomData(std::string identifier) {
return ""; return "";
} }
void ItemInst::SetTimer(std::string name, uint32 time) {
Timer t(time);
t.Start(time, false);
m_timers[name] = t;
}
void ItemInst::StopTimer(std::string name) {
auto iter = m_timers.find(name);
if(iter != m_timers.end()) {
m_timers.erase(iter);
}
}
void ItemInst::ClearTimers() {
m_timers.clear();
}
// Retrieve item at specified position within bag // Retrieve item at specified position within bag
ItemInst* Inventory::GetItem(int16 slot_id, uint8 bagidx) const ItemInst* Inventory::GetItem(int16 slot_id, uint8 bagidx) const
{ {

3
common/Item.h
View File

@ -380,6 +380,9 @@ public:
inline void SetSerialNumber(int32 id) { m_SerialNumber = id; } inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
std::map<std::string, Timer>& GetTimers() { return m_timers; } std::map<std::string, Timer>& GetTimers() { return m_timers; }
void SetTimer(std::string name, uint32 time);
void StopTimer(std::string name);
void ClearTimers();
protected: protected:
////////////////////////// //////////////////////////

4
zone/Object.cpp
View File

@ -465,7 +465,9 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
char buf[10]; char buf[10];
snprintf(buf, 9, "%u", m_inst->GetItem()->ID); snprintf(buf, 9, "%u", m_inst->GetItem()->ID);
buf[9] = '\0'; buf[9] = '\0';
parse->EventPlayer(EVENT_PLAYER_PICKUP, sender, buf, 0); std::vector<void*> args;
args.push_back(m_inst);
parse->EventPlayer(EVENT_PLAYER_PICKUP, sender, buf, 0, &args);
// Transfer item to client // Transfer item to client
sender->PutItemInInventory(SLOT_CURSOR, *m_inst, false); sender->PutItemInInventory(SLOT_CURSOR, *m_inst, false);

30
zone/QuestInterface.h
View File

@ -29,14 +29,19 @@ class NPC;
class QuestInterface { class QuestInterface {
public: public:
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { return 0; } std::vector<void*> *extra_pointers) { return 0; }
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { return 0; } std::vector<void*> *extra_pointers) { return 0; }
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { return 0; } virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { return 0; } std::vector<void*> *extra_pointers) { return 0; }
virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { return 0; } virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { return 0; } std::vector<void*> *extra_pointers) { return 0; }
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data) { return 0; } virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) { return 0; }
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) { return 0; }
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers) { return 0; }
virtual bool HasQuestSub(uint32 npcid, QuestEventID evt) { return false; } virtual bool HasQuestSub(uint32 npcid, QuestEventID evt) { return false; }
virtual bool HasGlobalQuestSub(QuestEventID evt) { return false; } virtual bool HasGlobalQuestSub(QuestEventID evt) { return false; }
@ -55,10 +60,13 @@ public:
virtual void LoadEncounterScript(std::string filename, std::string encounter_name) { } virtual void LoadEncounterScript(std::string filename, std::string encounter_name) { }
virtual void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { } std::vector<void*> *extra_pointers) { }
virtual void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { } virtual void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { } std::vector<void*> *extra_pointers) { }
virtual void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { } virtual void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) { }
virtual void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) { }
virtual void AddVar(std::string name, std::string val) { } virtual void AddVar(std::string name, std::string val) { }
virtual std::string GetVar(std::string name) { return std::string(); } virtual std::string GetVar(std::string name) { return std::string(); }

99
zone/QuestParserCollection.cpp
View File

@ -226,10 +226,10 @@ bool QuestParserCollection::ItemHasQuestSub(ItemInst *itm, QuestEventID evt) {
} }
int QuestParserCollection::EventNPC(QuestEventID evt, NPC *npc, Mob *init, std::string data, uint32 extra_data, int QuestParserCollection::EventNPC(QuestEventID evt, NPC *npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
int rl = EventNPCLocal(evt, npc, init, data, extra_data, items); int rl = EventNPCLocal(evt, npc, init, data, extra_data, extra_pointers);
int rg = EventNPCGlobal(evt, npc, init, data, extra_data, items); int rg = EventNPCGlobal(evt, npc, init, data, extra_data, extra_pointers);
DispatchEventNPC(evt, npc, init, data, extra_data, items); DispatchEventNPC(evt, npc, init, data, extra_data, extra_pointers);
//Local quests returning non-default values have priority over global quests //Local quests returning non-default values have priority over global quests
if(rl != 0) { if(rl != 0) {
@ -242,13 +242,13 @@ int QuestParserCollection::EventNPC(QuestEventID evt, NPC *npc, Mob *init, std::
} }
int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
std::map<uint32, uint32>::iterator iter = _npc_quest_status.find(npc->GetNPCTypeID()); std::map<uint32, uint32>::iterator iter = _npc_quest_status.find(npc->GetNPCTypeID());
if(iter != _npc_quest_status.end()) { if(iter != _npc_quest_status.end()) {
//loaded or failed to load //loaded or failed to load
if(iter->second != QuestFailedToLoad) { if(iter->second != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second); std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second);
return qiter->second->EventNPC(evt, npc, init, data, extra_data, items); return qiter->second->EventNPC(evt, npc, init, data, extra_data, extra_pointers);
} }
} else { } else {
std::string filename; std::string filename;
@ -256,7 +256,7 @@ int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init,
if(qi) { if(qi) {
_npc_quest_status[npc->GetNPCTypeID()] = qi->GetIdentifier(); _npc_quest_status[npc->GetNPCTypeID()] = qi->GetIdentifier();
qi->LoadNPCScript(filename, npc->GetNPCTypeID()); qi->LoadNPCScript(filename, npc->GetNPCTypeID());
return qi->EventNPC(evt, npc, init, data, extra_data, items); return qi->EventNPC(evt, npc, init, data, extra_data, extra_pointers);
} else { } else {
_npc_quest_status[npc->GetNPCTypeID()] = QuestFailedToLoad; _npc_quest_status[npc->GetNPCTypeID()] = QuestFailedToLoad;
} }
@ -265,17 +265,17 @@ int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init,
} }
int QuestParserCollection::EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int QuestParserCollection::EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
if(_global_npc_quest_status != QuestUnloaded && _global_npc_quest_status != QuestFailedToLoad) { if(_global_npc_quest_status != QuestUnloaded && _global_npc_quest_status != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(_global_npc_quest_status); std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(_global_npc_quest_status);
return qiter->second->EventGlobalNPC(evt, npc, init, data, extra_data, items); return qiter->second->EventGlobalNPC(evt, npc, init, data, extra_data, extra_pointers);
} else { } else {
std::string filename; std::string filename;
QuestInterface *qi = GetQIByGlobalNPCQuest(filename); QuestInterface *qi = GetQIByGlobalNPCQuest(filename);
if(qi) { if(qi) {
_global_npc_quest_status = qi->GetIdentifier(); _global_npc_quest_status = qi->GetIdentifier();
qi->LoadGlobalNPCScript(filename); qi->LoadGlobalNPCScript(filename);
return qi->EventGlobalNPC(evt, npc, init, data, extra_data, items); return qi->EventGlobalNPC(evt, npc, init, data, extra_data, extra_pointers);
} else { } else {
_global_npc_quest_status = QuestFailedToLoad; _global_npc_quest_status = QuestFailedToLoad;
} }
@ -283,10 +283,11 @@ int QuestParserCollection::EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init,
return 0; return 0;
} }
int QuestParserCollection::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int QuestParserCollection::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
int rl = EventPlayerLocal(evt, client, data, extra_data); std::vector<void*> *extra_pointers) {
int rg = EventPlayerGlobal(evt, client, data, extra_data); int rl = EventPlayerLocal(evt, client, data, extra_data, extra_pointers);
DispatchEventPlayer(evt, client, data, extra_data); int rg = EventPlayerGlobal(evt, client, data, extra_data, extra_pointers);
DispatchEventPlayer(evt, client, data, extra_data, extra_pointers);
//Local quests returning non-default values have priority over global quests //Local quests returning non-default values have priority over global quests
if(rl != 0) { if(rl != 0) {
@ -298,43 +299,46 @@ int QuestParserCollection::EventPlayer(QuestEventID evt, Client *client, std::st
return 0; return 0;
} }
int QuestParserCollection::EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int QuestParserCollection::EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
if(_player_quest_status == QuestUnloaded) { if(_player_quest_status == QuestUnloaded) {
std::string filename; std::string filename;
QuestInterface *qi = GetQIByPlayerQuest(filename); QuestInterface *qi = GetQIByPlayerQuest(filename);
if(qi) { if(qi) {
_player_quest_status = qi->GetIdentifier(); _player_quest_status = qi->GetIdentifier();
qi->LoadPlayerScript(filename); qi->LoadPlayerScript(filename);
return qi->EventPlayer(evt, client, data, extra_data); return qi->EventPlayer(evt, client, data, extra_data, extra_pointers);
} }
} else { } else {
if(_player_quest_status != QuestFailedToLoad) { if(_player_quest_status != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator iter = _interfaces.find(_player_quest_status); std::map<uint32, QuestInterface*>::iterator iter = _interfaces.find(_player_quest_status);
return iter->second->EventPlayer(evt, client, data, extra_data); return iter->second->EventPlayer(evt, client, data, extra_data, extra_pointers);
} }
} }
return 0; return 0;
} }
int QuestParserCollection::EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int QuestParserCollection::EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
if(_global_player_quest_status == QuestUnloaded) { if(_global_player_quest_status == QuestUnloaded) {
std::string filename; std::string filename;
QuestInterface *qi = GetQIByGlobalPlayerQuest(filename); QuestInterface *qi = GetQIByGlobalPlayerQuest(filename);
if(qi) { if(qi) {
_global_player_quest_status = qi->GetIdentifier(); _global_player_quest_status = qi->GetIdentifier();
qi->LoadGlobalPlayerScript(filename); qi->LoadGlobalPlayerScript(filename);
return qi->EventGlobalPlayer(evt, client, data, extra_data); return qi->EventGlobalPlayer(evt, client, data, extra_data, extra_pointers);
} }
} else { } else {
if(_global_player_quest_status != QuestFailedToLoad) { if(_global_player_quest_status != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator iter = _interfaces.find(_global_player_quest_status); std::map<uint32, QuestInterface*>::iterator iter = _interfaces.find(_global_player_quest_status);
return iter->second->EventGlobalPlayer(evt, client, data, extra_data); return iter->second->EventGlobalPlayer(evt, client, data, extra_data, extra_pointers);
} }
} }
return 0; return 0;
} }
int QuestParserCollection::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { int QuestParserCollection::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
std::string item_script; std::string item_script;
if(item->GetItem()->ScriptFileID != 0) { if(item->GetItem()->ScriptFileID != 0) {
item_script = "script_"; item_script = "script_";
@ -351,63 +355,65 @@ int QuestParserCollection::EventItem(QuestEventID evt, Client *client, ItemInst
//loaded or failed to load //loaded or failed to load
if(iter->second != QuestFailedToLoad) { if(iter->second != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second); std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second);
auto ret = qiter->second->EventItem(evt, client, item, mob, data, extra_data); auto ret = qiter->second->EventItem(evt, client, item, mob, data, extra_data, extra_pointers);
DispatchEventItem(evt, client, item, mob, data, extra_data); DispatchEventItem(evt, client, item, mob, data, extra_data, extra_pointers);
return ret; return ret;
} }
DispatchEventItem(evt, client, item, mob, data, extra_data); DispatchEventItem(evt, client, item, mob, data, extra_data, extra_pointers);
} else { } else {
std::string filename; std::string filename;
QuestInterface *qi = GetQIByItemQuest(item_script, filename); QuestInterface *qi = GetQIByItemQuest(item_script, filename);
if(qi) { if(qi) {
_item_quest_status[item_id] = qi->GetIdentifier(); _item_quest_status[item_id] = qi->GetIdentifier();
qi->LoadItemScript(filename, item); qi->LoadItemScript(filename, item);
auto ret = qi->EventItem(evt, client, item, mob, data, extra_data); auto ret = qi->EventItem(evt, client, item, mob, data, extra_data, extra_pointers);
DispatchEventItem(evt, client, item, mob, data, extra_data); DispatchEventItem(evt, client, item, mob, data, extra_data, extra_pointers);
return ret; return ret;
} else { } else {
_item_quest_status[item_id] = QuestFailedToLoad; _item_quest_status[item_id] = QuestFailedToLoad;
DispatchEventItem(evt, client, item, mob, data, extra_data); DispatchEventItem(evt, client, item, mob, data, extra_data, extra_pointers);
} }
} }
return 0; return 0;
} }
int QuestParserCollection::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { int QuestParserCollection::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
std::map<uint32, uint32>::iterator iter = _spell_quest_status.find(spell_id); std::map<uint32, uint32>::iterator iter = _spell_quest_status.find(spell_id);
if(iter != _spell_quest_status.end()) { if(iter != _spell_quest_status.end()) {
//loaded or failed to load //loaded or failed to load
if(iter->second != QuestFailedToLoad) { if(iter->second != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second); std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second);
auto ret = qiter->second->EventSpell(evt, npc, client, spell_id, extra_data); auto ret = qiter->second->EventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
DispatchEventSpell(evt, npc, client, spell_id, extra_data); DispatchEventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
return ret; return ret;
} }
DispatchEventSpell(evt, npc, client, spell_id, extra_data); DispatchEventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
} else { } else {
std::string filename; std::string filename;
QuestInterface *qi = GetQIBySpellQuest(spell_id, filename); QuestInterface *qi = GetQIBySpellQuest(spell_id, filename);
if(qi) { if(qi) {
_spell_quest_status[spell_id] = qi->GetIdentifier(); _spell_quest_status[spell_id] = qi->GetIdentifier();
qi->LoadSpellScript(filename, spell_id); qi->LoadSpellScript(filename, spell_id);
auto ret = qi->EventSpell(evt, npc, client, spell_id, extra_data); auto ret = qi->EventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
DispatchEventSpell(evt, npc, client, spell_id, extra_data); DispatchEventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
return ret; return ret;
} else { } else {
_spell_quest_status[spell_id] = QuestFailedToLoad; _spell_quest_status[spell_id] = QuestFailedToLoad;
DispatchEventSpell(evt, npc, client, spell_id, extra_data); DispatchEventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
} }
} }
return 0; return 0;
} }
int QuestParserCollection::EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data) { int QuestParserCollection::EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers) {
auto iter = _encounter_quest_status.find(encounter_name); auto iter = _encounter_quest_status.find(encounter_name);
if(iter != _encounter_quest_status.end()) { if(iter != _encounter_quest_status.end()) {
//loaded or failed to load //loaded or failed to load
if(iter->second != QuestFailedToLoad) { if(iter->second != QuestFailedToLoad) {
std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second); std::map<uint32, QuestInterface*>::iterator qiter = _interfaces.find(iter->second);
return qiter->second->EventEncounter(evt, encounter_name, extra_data); return qiter->second->EventEncounter(evt, encounter_name, extra_data, extra_pointers);
} }
} else { } else {
std::string filename; std::string filename;
@ -415,7 +421,7 @@ int QuestParserCollection::EventEncounter(QuestEventID evt, std::string encounte
if(qi) { if(qi) {
_encounter_quest_status[encounter_name] = qi->GetIdentifier(); _encounter_quest_status[encounter_name] = qi->GetIdentifier();
qi->LoadEncounterScript(filename, encounter_name); qi->LoadEncounterScript(filename, encounter_name);
return qi->EventEncounter(evt, encounter_name, extra_data); return qi->EventEncounter(evt, encounter_name, extra_data, extra_pointers);
} else { } else {
_encounter_quest_status[encounter_name] = QuestFailedToLoad; _encounter_quest_status[encounter_name] = QuestFailedToLoad;
} }
@ -855,36 +861,37 @@ void QuestParserCollection::GetErrors(std::list<std::string> &err) {
} }
void QuestParserCollection::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, void QuestParserCollection::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
auto iter = _load_precedence.begin(); auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) { while(iter != _load_precedence.end()) {
(*iter)->DispatchEventNPC(evt, npc, init, data, extra_data, items); (*iter)->DispatchEventNPC(evt, npc, init, data, extra_data, extra_pointers);
++iter; ++iter;
} }
} }
void QuestParserCollection::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { void QuestParserCollection::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
auto iter = _load_precedence.begin(); auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) { while(iter != _load_precedence.end()) {
(*iter)->DispatchEventPlayer(evt, client, data, extra_data); (*iter)->DispatchEventPlayer(evt, client, data, extra_data, extra_pointers);
++iter; ++iter;
} }
} }
void QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, void QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data,
uint32 extra_data) { uint32 extra_data, std::vector<void*> *extra_pointers) {
auto iter = _load_precedence.begin(); auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) { while(iter != _load_precedence.end()) {
(*iter)->DispatchEventItem(evt, client, item, mob, data, extra_data); (*iter)->DispatchEventItem(evt, client, item, mob, data, extra_data, extra_pointers);
++iter; ++iter;
} }
} }
void QuestParserCollection::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { void QuestParserCollection::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
auto iter = _load_precedence.begin(); auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) { while(iter != _load_precedence.end()) {
(*iter)->DispatchEventSpell(evt, npc, client, spell_id, extra_data); (*iter)->DispatchEventSpell(evt, npc, client, spell_id, extra_data, extra_pointers);
++iter; ++iter;
} }
} }

34
zone/QuestParserCollection.h
View File

@ -50,11 +50,15 @@ public:
bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt); bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt);
int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items = nullptr); std::vector<void*> *extra_pointers = nullptr);
int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers = nullptr);
int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data); int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data); std::vector<void*> *extra_pointers = nullptr);
int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers = nullptr);
int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers = nullptr);
void GetErrors(std::list<std::string> &err); void GetErrors(std::list<std::string> &err);
@ -64,10 +68,10 @@ private:
bool PlayerHasQuestSubLocal(QuestEventID evt); bool PlayerHasQuestSubLocal(QuestEventID evt);
bool PlayerHasQuestSubGlobal(QuestEventID evt); bool PlayerHasQuestSubGlobal(QuestEventID evt);
int EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<ItemInst*> *items); int EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<void*> *extra_pointers);
int EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<ItemInst*> *items); int EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<void*> *extra_pointers);
int EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data); int EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<void*> *extra_pointers);
int EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data); int EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<void*> *extra_pointers);
QuestInterface *GetQIByNPCQuest(uint32 npcid, std::string &filename); QuestInterface *GetQIByNPCQuest(uint32 npcid, std::string &filename);
QuestInterface *GetQIByGlobalNPCQuest(std::string &filename); QuestInterface *GetQIByGlobalNPCQuest(std::string &filename);
@ -77,10 +81,14 @@ private:
QuestInterface *GetQIByItemQuest(std::string item_script, std::string &filename); QuestInterface *GetQIByItemQuest(std::string item_script, std::string &filename);
QuestInterface *GetQIByEncounterQuest(std::string encounter_name, std::string &filename); QuestInterface *GetQIByEncounterQuest(std::string encounter_name, std::string &filename);
void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<ItemInst*> *items); void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data); void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data); std::vector<void*> *extra_pointers);
void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
std::map<uint32, QuestInterface*> _interfaces; std::map<uint32, QuestInterface*> _interfaces;
std::map<uint32, std::string> _extensions; std::map<uint32, std::string> _extensions;

10
zone/bonuses.cpp
View File

@ -2441,10 +2441,6 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y)
{ {
EvoItemInst* e_inst = (EvoItemInst*)inst; EvoItemInst* e_inst = (EvoItemInst*)inst;
uint16 oldexp = e_inst->GetExp(); uint16 oldexp = e_inst->GetExp();
//if(login) {
// parse->EventItem(EVENT_ITEM_ENTER_ZONE, this, e_inst, nullptr, "", 0);
//}
parse->EventItem(EVENT_SCALE_CALC, this, e_inst, nullptr, "", 0); parse->EventItem(EVENT_SCALE_CALC, this, e_inst, nullptr, "", 0);
if (e_inst->GetExp() != oldexp) { // if the scaling factor changed, rescale the item and update the client if (e_inst->GetExp() != oldexp) { // if the scaling factor changed, rescale the item and update the client
@ -2465,10 +2461,6 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y)
{ {
EvoItemInst* e_inst = (EvoItemInst*)a_inst; EvoItemInst* e_inst = (EvoItemInst*)a_inst;
uint16 oldexp = e_inst->GetExp(); uint16 oldexp = e_inst->GetExp();
//if(login) {
// parse->EventItem(EVENT_ITEM_ENTER_ZONE, this, e_inst, nullptr, "", 0);
//}
parse->EventItem(EVENT_SCALE_CALC, this, e_inst, nullptr, "", 0); parse->EventItem(EVENT_SCALE_CALC, this, e_inst, nullptr, "", 0);
if (e_inst->GetExp() != oldexp) if (e_inst->GetExp() != oldexp)
@ -2520,7 +2512,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
bool changed = false; bool changed = false;
for(int i = slot_x; i < slot_y; i++) { for(int i = slot_x; i < slot_y; i++) {
ItemInst* inst = m_inv.GetItem(i); ItemInst* inst = m_inv.GetItem(i);
if(inst == 0) if(!inst)
continue; continue;
bool update_slot = false; bool update_slot = false;

210
zone/client.cpp
View File

@ -26,13 +26,13 @@
// for windows compile // for windows compile
#ifdef _WINDOWS #ifdef _WINDOWS
#define abs64 _abs64 #define abs64 _abs64
#else #else
#include <stdarg.h> #include <stdarg.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h> #include <netinet/in.h>
#include "../common/unix.h" #include "../common/unix.h"
#define abs64 abs #define abs64 abs
#endif #endif
extern volatile bool RunLoops; extern volatile bool RunLoops;
@ -159,7 +159,8 @@ Client::Client(EQStreamInterface* ieqs)
TrackingTimer(2000), TrackingTimer(2000),
RespawnFromHoverTimer(0), RespawnFromHoverTimer(0),
merc_timer(RuleI(Mercs, UpkeepIntervalMS)), merc_timer(RuleI(Mercs, UpkeepIntervalMS)),
ItemTickTimer(10000) ItemTickTimer(10000),
ItemQuestTimer(500)
{ {
for(int cf=0; cf < _FilterCount; cf++) for(int cf=0; cf < _FilterCount; cf++)
ClientFilters[cf] = FilterShow; ClientFilters[cf] = FilterShow;
@ -7617,109 +7618,166 @@ some day.
void Client::LoadAccountFlags() void Client::LoadAccountFlags()
{ {
char errbuf[MYSQL_ERRMSG_SIZE]; char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0; char *query = 0;
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_ROW row; MYSQL_ROW row;
accountflags.clear(); accountflags.clear();
MakeAnyLenString(&query, "SELECT p_flag, p_value FROM account_flags WHERE p_accid = '%d'", account_id); MakeAnyLenString(&query, "SELECT p_flag, p_value FROM account_flags WHERE p_accid = '%d'", account_id);
if(database.RunQuery(query, strlen(query), errbuf, &result)) if(database.RunQuery(query, strlen(query), errbuf, &result))
{ {
while(row = mysql_fetch_row(result)) while(row = mysql_fetch_row(result))
{ {
std::string fname(row[0]); std::string fname(row[0]);
std::string fval(row[1]); std::string fval(row[1]);
accountflags[fname] = fval; accountflags[fname] = fval;
} }
mysql_free_result(result); mysql_free_result(result);
} }
else else
{ {
std::cerr << "Error in LoadAccountFlags query '" << query << "' " << errbuf << std::endl; std::cerr << "Error in LoadAccountFlags query '" << query << "' " << errbuf << std::endl;
} }
safe_delete_array(query); safe_delete_array(query);
} }
void Client::SetAccountFlag(std::string flag, std::string val) void Client::SetAccountFlag(std::string flag, std::string val)
{ {
char errbuf[MYSQL_ERRMSG_SIZE]; char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0; char *query = 0;
MakeAnyLenString(&query, "REPLACE INTO account_flags (p_accid, p_flag, p_value) VALUES( '%d', '%s', '%s')", account_id, flag.c_str(), val.c_str()); MakeAnyLenString(&query, "REPLACE INTO account_flags (p_accid, p_flag, p_value) VALUES( '%d', '%s', '%s')", account_id, flag.c_str(), val.c_str());
if(!database.RunQuery(query, strlen(query), errbuf)) if(!database.RunQuery(query, strlen(query), errbuf))
{ {
std::cerr << "Error in SetAccountFlags query '" << query << "' " << errbuf << std::endl; std::cerr << "Error in SetAccountFlags query '" << query << "' " << errbuf << std::endl;
} }
safe_delete_array(query); safe_delete_array(query);
accountflags[flag] = val; accountflags[flag] = val;
} }
std::string Client::GetAccountFlag(std::string flag) std::string Client::GetAccountFlag(std::string flag)
{ {
return(accountflags[flag]); return(accountflags[flag]);
} }
void Client::TickItemCheck() void Client::TickItemCheck()
{ {
int i; int i;
if(zone->tick_items.empty()) { return; } if(zone->tick_items.empty()) { return; }
//Scan equip slots for items //Scan equip slots for items
for(i = 0; i <= 21; i++) for(i = 0; i <= 21; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
//Scan main inventory + cursor //Scan main inventory + cursor
for(i = 22; i < 31; i++) for(i = 22; i < 31; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
//Scan bags //Scan bags
for(i = 251; i < 340; i++) for(i = 251; i < 340; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
} }
void Client::TryItemTick(int slot) void Client::TryItemTick(int slot)
{ {
int iid = 0; int iid = 0;
const ItemInst* inst = m_inv[slot]; const ItemInst* inst = m_inv[slot];
if(inst == 0) { return; } if(inst == 0) { return; }
iid = inst->GetID(); iid = inst->GetID();
if(zone->tick_items.count(iid) > 0) if(zone->tick_items.count(iid) > 0)
{ {
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot < 22) ) if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot < 22) )
{ {
ItemInst* e_inst = (ItemInst*)inst; ItemInst* e_inst = (ItemInst*)inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot); parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
} }
} }
//Only look at augs in main inventory //Only look at augs in main inventory
if(slot > 21) { return; } if(slot > 21) { return; }
for(int x = 0; x < MAX_AUGMENT_SLOTS; ++x) for(int x = 0; x < MAX_AUGMENT_SLOTS; ++x)
{ {
ItemInst * a_inst = inst->GetAugment(x); ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) { continue; } if(!a_inst) { continue; }
iid = a_inst->GetID(); iid = a_inst->GetID();
if(zone->tick_items.count(iid) > 0) if(zone->tick_items.count(iid) > 0)
{ {
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) ) if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) )
{ {
ItemInst* e_inst = (ItemInst*)a_inst; ItemInst* e_inst = (ItemInst*)a_inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot); parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
} }
} }
} }
}
void Client::ItemTimerCheck()
{
int i;
for(i = 0; i <= 21; i++)
{
TryItemTimer(i);
}
for(i = 22; i < 31; i++)
{
TryItemTimer(i);
}
for(i = 251; i < 340; i++)
{
TryItemTimer(i);
}
}
void Client::TryItemTimer(int slot)
{
ItemInst* inst = m_inv.GetItem(slot);
if(!inst) {
return;
}
auto item_timers = inst->GetTimers();
auto it_iter = item_timers.begin();
while(it_iter != item_timers.end()) {
if(it_iter->second.Check()) {
parse->EventItem(EVENT_TIMER, this, inst, nullptr, it_iter->first, 0);
}
++it_iter;
}
if(slot > 21) {
return;
}
for(int x = 0; x < MAX_AUGMENT_SLOTS; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) {
continue;
}
auto item_timers = a_inst->GetTimers();
auto it_iter = item_timers.begin();
while(it_iter != item_timers.end()) {
if(it_iter->second.Check()) {
parse->EventItem(EVENT_TIMER, this, a_inst, nullptr, it_iter->first, 0);
}
++it_iter;
}
}
} }
void Client::RefundAA() { void Client::RefundAA() {

6
zone/client.h
View File

@ -1122,6 +1122,9 @@ public:
void TickItemCheck(); void TickItemCheck();
void TryItemTick(int slot); void TryItemTick(int slot);
void ItemTimerCheck();
void TryItemTimer(int slot);
int16 GetActSTR() { return( std::min(GetMaxSTR(), GetSTR()) ); } int16 GetActSTR() { return( std::min(GetMaxSTR(), GetSTR()) ); }
int16 GetActSTA() { return( std::min(GetMaxSTA(), GetSTA()) ); } int16 GetActSTA() { return( std::min(GetMaxSTA(), GetSTA()) ); }
int16 GetActDEX() { return( std::min(GetMaxDEX(), GetDEX()) ); } int16 GetActDEX() { return( std::min(GetMaxDEX(), GetDEX()) ); }
@ -1455,7 +1458,8 @@ private:
struct XTarget_Struct XTargets[XTARGET_HARDCAP]; struct XTarget_Struct XTargets[XTARGET_HARDCAP];
Timer ItemTickTimer; Timer ItemTickTimer;
Timer ItemQuestTimer;
std::map<std::string,std::string> accountflags; std::map<std::string,std::string> accountflags;
}; };

31
zone/client_packet.cpp
View File

@ -4562,7 +4562,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
LogFile->write(EQEMuLog::Debug, "cs_unknown2: 16 %p %u %u", &castspell->cs_unknown, *(uint16*) castspell->cs_unknown, *(uint16*) castspell->cs_unknown+sizeof(uint16) ); LogFile->write(EQEMuLog::Debug, "cs_unknown2: 16 %p %u %u", &castspell->cs_unknown, *(uint16*) castspell->cs_unknown, *(uint16*) castspell->cs_unknown+sizeof(uint16) );
LogFile->write(EQEMuLog::Debug, "cs_unknown2: 16 %p %i %i", &castspell->cs_unknown, *(uint16*) castspell->cs_unknown, *(uint16*) castspell->cs_unknown+sizeof(uint16) ); LogFile->write(EQEMuLog::Debug, "cs_unknown2: 16 %p %i %i", &castspell->cs_unknown, *(uint16*) castspell->cs_unknown, *(uint16*) castspell->cs_unknown+sizeof(uint16) );
#endif #endif
LogFile->write(EQEMuLog::Debug, "OP CastSpell: slot=%d, spell=%d, target=%d, inv=%lx", castspell->slot, castspell->spell_id, castspell->target_id, (unsigned long)castspell->inventoryslot); LogFile->write(EQEMuLog::Debug, "OP CastSpell: slot=%d, spell=%d, target=%d, inv=%lx", castspell->slot, castspell->spell_id, castspell->target_id, (unsigned long)castspell->inventoryslot);
if ((castspell->slot == USE_ITEM_SPELL_SLOT) || (castspell->slot == POTION_BELT_SPELL_SLOT)) // this means item if ((castspell->slot == USE_ITEM_SPELL_SLOT) || (castspell->slot == POTION_BELT_SPELL_SLOT)) // this means item
{ {
@ -4671,22 +4671,28 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
else else
spell_to_cast = SPELL_HARM_TOUCH2; spell_to_cast = SPELL_HARM_TOUCH2;
p_timers.Start(pTimerHarmTouch, HarmTouchReuseTime); p_timers.Start(pTimerHarmTouch, HarmTouchReuseTime);
} else if(castspell->slot == DISCIPLINE_SPELL_SLOT) { }
//handle disciplines, OLD, they keep changing this
if(castspell->slot == DISCIPLINE_SPELL_SLOT) {
if(!UseDiscipline(castspell->spell_id, castspell->target_id)) { if(!UseDiscipline(castspell->spell_id, castspell->target_id)) {
printf("Unknown ability being used by %s, spell being cast is: %i\n",GetName(),castspell->spell_id); printf("Unknown ability being used by %s, spell being cast is: %i\n",GetName(),castspell->spell_id);
InterruptSpell(castspell->spell_id); InterruptSpell(castspell->spell_id);
} }
return; return;
} else if(castspell->slot < MAX_PP_MEMSPELL) { }
if(castspell->slot < MAX_PP_MEMSPELL)
{
spell_to_cast = m_pp.mem_spells[castspell->slot]; spell_to_cast = m_pp.mem_spells[castspell->slot];
if(spell_to_cast != castspell->spell_id) if(spell_to_cast != castspell->spell_id)
{ {
InterruptSpell(castspell->spell_id); //CHEATER!!! InterruptSpell(castspell->spell_id); //CHEATER!!!
return; return;
} }
} else { }
//If we get to here this slot should be invalid invalid else {
InterruptSpell(castspell->spell_id); InterruptSpell();
return; return;
} }
@ -5759,7 +5765,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
if ((RuleB(Character, EnableDiscoveredItems))) if ((RuleB(Character, EnableDiscoveredItems)))
{ {
if(!GetGM() && !IsDiscovered(item_id)) if(!GetGM() && !IsDiscovered(item_id))
DiscoverItem(item_id); DiscoverItem(item_id);
} }
t1.stop(); t1.stop();
@ -6009,15 +6015,18 @@ void Client::Handle_OP_ClickObject(const EQApplicationPacket *app)
ClickObject_Struct* click_object = (ClickObject_Struct*)app->pBuffer; ClickObject_Struct* click_object = (ClickObject_Struct*)app->pBuffer;
Entity* entity = entity_list.GetID(click_object->drop_id); Entity* entity = entity_list.GetID(click_object->drop_id);
//TODO: should enforce range checking here.
if (entity && entity->IsObject()) { if (entity && entity->IsObject()) {
Object* object = entity->CastToObject(); Object* object = entity->CastToObject();
object->HandleClick(this, click_object); object->HandleClick(this, click_object);
std::vector<void*> args;
args.push_back(object);
char buf[10]; char buf[10];
snprintf(buf, 9, "%u", click_object->drop_id); snprintf(buf, 9, "%u", click_object->drop_id);
buf[9] = '\0'; buf[9] = '\0';
parse->EventPlayer(EVENT_CLICK_OBJECT, this, buf, 0); parse->EventPlayer(EVENT_CLICK_OBJECT, this, buf, 0, &args);
} }
// Observed in RoF after OP_ClickObjectAction: // Observed in RoF after OP_ClickObjectAction:
@ -6253,7 +6262,9 @@ void Client::Handle_OP_ClickDoor(const EQApplicationPacket *app)
char buf[20]; char buf[20];
snprintf(buf, 19, "%u", cd->doorid); snprintf(buf, 19, "%u", cd->doorid);
buf[19] = '\0'; buf[19] = '\0';
parse->EventPlayer(EVENT_CLICK_DOOR, this, buf, 0); std::vector<void*> args;
args.push_back(currentdoor);
parse->EventPlayer(EVENT_CLICK_DOOR, this, buf, 0, &args);
currentdoor->HandleClick(this,0); currentdoor->HandleClick(this,0);
return; return;

11
zone/client_process.cpp
View File

@ -641,9 +641,14 @@ bool Client::Process() {
} }
if(ItemTickTimer.Check()) if(ItemTickTimer.Check())
{ {
TickItemCheck(); TickItemCheck();
} }
if(ItemQuestTimer.Check())
{
ItemTimerCheck();
}
} }
} }

7
zone/corpse.cpp
View File

@ -1167,12 +1167,15 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app)
strcpy(corpse_name, orgname); strcpy(corpse_name, orgname);
snprintf(buf, 87, "%d %d %s", inst->GetItem()->ID, inst->GetCharges(), EntityList::RemoveNumbers(corpse_name)); snprintf(buf, 87, "%d %d %s", inst->GetItem()->ID, inst->GetCharges(), EntityList::RemoveNumbers(corpse_name));
buf[87] = '\0'; buf[87] = '\0';
parse->EventPlayer(EVENT_LOOT, client, buf, 0); std::vector<void*> args;
args.push_back(inst);
args.push_back(this);
parse->EventPlayer(EVENT_LOOT, client, buf, 0, &args);
if ((RuleB(Character, EnableDiscoveredItems))) if ((RuleB(Character, EnableDiscoveredItems)))
{ {
if(client && !client->GetGM() && !client->IsDiscovered(inst->GetItem()->ID)) if(client && !client->GetGM() && !client->IsDiscovered(inst->GetItem()->ID))
client->DiscoverItem(inst->GetItem()->ID); client->DiscoverItem(inst->GetItem()->ID);
} }
if (zone->lootvar != 0) if (zone->lootvar != 0)

56
zone/embparser.cpp
View File

@ -142,7 +142,7 @@ void PerlembParser::ReloadQuests() {
} }
void PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob, void PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
uint32 extradata, bool global, std::vector<ItemInst*> *items) uint32 extradata, bool global, std::vector<void*> *extra_pointers)
{ {
if(!perl) if(!perl)
return; return;
@ -151,7 +151,7 @@ void PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * d
return; return;
if(perl->InUse()) { if(perl->InUse()) {
AddQueueEvent(event, objid, data, npcmob, iteminst, mob, extradata, global, items); AddQueueEvent(event, objid, data, npcmob, iteminst, mob, extradata, global, extra_pointers);
return; return;
} }
@ -182,7 +182,7 @@ void PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * d
package_name, mob, npcmob); package_name, mob, npcmob);
ExportZoneVariables(package_name); ExportZoneVariables(package_name);
ExportItemVariables(package_name, mob); ExportItemVariables(package_name, mob);
ExportEventVariables(package_name, event, objid, data, npcmob, iteminst, mob, extradata, items); ExportEventVariables(package_name, event, objid, data, npcmob, iteminst, mob, extradata, extra_pointers);
if(isPlayerQuest || isGlobalPlayerQuest){ if(isPlayerQuest || isGlobalPlayerQuest){
SendCommands(package_name.c_str(), sub_name, 0, mob, mob, nullptr); SendCommands(package_name.c_str(), sub_name, 0, mob, mob, nullptr);
@ -206,34 +206,38 @@ void PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * d
} }
int PerlembParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int PerlembParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, false, items); EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, false, extra_pointers);
return 0; return 0;
} }
int PerlembParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int PerlembParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, true, nullptr); EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, true, extra_pointers);
return 0; return 0;
} }
int PerlembParser::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int PerlembParser::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, false, nullptr); std::vector<void*> *extra_pointers) {
EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, false, extra_pointers);
return 0; return 0;
} }
int PerlembParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int PerlembParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, true, nullptr); std::vector<void*> *extra_pointers) {
EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, true, extra_pointers);
return 0; return 0;
} }
int PerlembParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { int PerlembParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
EventCommon(evt, item->GetID(), nullptr, nullptr, item, client, extra_data, false, nullptr); std::vector<void*> *extra_pointers) {
EventCommon(evt, item->GetID(), nullptr, nullptr, item, client, extra_data, false, extra_pointers);
return 0; return 0;
} }
int PerlembParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { int PerlembParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
EventCommon(evt, 0, itoa(spell_id), npc, nullptr, client, extra_data, false, nullptr); std::vector<void*> *extra_pointers) {
EventCommon(evt, 0, itoa(spell_id), npc, nullptr, client, extra_data, false, extra_pointers);
return 0; return 0;
} }
@ -750,10 +754,10 @@ void PerlembParser::HandleQueue() {
EventRecord e = event_queue_.front(); EventRecord e = event_queue_.front();
event_queue_.pop(); event_queue_.pop();
EventCommon(e.event, e.objid, e.data.c_str(), e.npcmob, e.iteminst, e.mob, e.extradata, e.global, &e.items); EventCommon(e.event, e.objid, e.data.c_str(), e.npcmob, e.iteminst, e.mob, e.extradata, e.global, &e.extra_pointers);
for(size_t i = 0; i < e.items.size(); ++i) { for(size_t i = 0; i < e.extra_pointers.size(); ++i) {
delete e.items[i]; delete e.extra_pointers[i];
} }
} }
@ -761,7 +765,7 @@ void PerlembParser::HandleQueue() {
} }
void PerlembParser::AddQueueEvent(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob, void PerlembParser::AddQueueEvent(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
uint32 extradata, bool global, std::vector<ItemInst*> *items) uint32 extradata, bool global, std::vector<void*> *extra_pointers)
{ {
EventRecord e; EventRecord e;
e.event = event; e.event = event;
@ -773,9 +777,9 @@ void PerlembParser::AddQueueEvent(QuestEventID event, uint32 objid, const char *
e.extradata = extradata; e.extradata = extradata;
e.global = global; e.global = global;
if(items) { if(extra_pointers) {
for(size_t i = 0; i < items->size(); ++i) { for(size_t i = 0; i < extra_pointers->size(); ++i) {
e.items.push_back(items->at(i)->Clone()); e.extra_pointers.push_back(reinterpret_cast<ItemInst*>(extra_pointers->at(i))->Clone());
} }
} }
@ -1083,7 +1087,7 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob) {
#undef HASITEM_ISNULLITEM #undef HASITEM_ISNULLITEM
void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data, void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<ItemInst*> *items) NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<void*> *extra_pointers)
{ {
switch (event) { switch (event) {
case EVENT_SAY: { case EVENT_SAY: {
@ -1098,9 +1102,9 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
} }
case EVENT_TRADE: { case EVENT_TRADE: {
if(items) { if(extra_pointers) {
for(size_t i = 0; i < items->size(); ++i) { for(size_t i = 0; i < extra_pointers->size(); ++i) {
ItemInst *inst = items->at(i); ItemInst *inst = reinterpret_cast<ItemInst*>(extra_pointers->at(i));
std::string var_name = "item"; std::string var_name = "item";
var_name += std::to_string(i + 1); var_name += std::to_string(i + 1);

26
zone/embparser.h
View File

@ -49,7 +49,7 @@ class PerlembParser : public QuestInterface {
Mob* mob; Mob* mob;
uint32 extradata; uint32 extradata;
bool global; bool global;
std::vector<ItemInst*> items; std::vector<void*> extra_pointers;
} EventRecord; } EventRecord;
public: public:
@ -57,13 +57,17 @@ public:
~PerlembParser(); ~PerlembParser();
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data); virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data); std::vector<void*> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual bool HasQuestSub(uint32 npcid, QuestEventID evt); virtual bool HasQuestSub(uint32 npcid, QuestEventID evt);
virtual bool HasGlobalQuestSub(QuestEventID evt); virtual bool HasGlobalQuestSub(QuestEventID evt);
@ -94,13 +98,13 @@ private:
void ExportVarComplex(const char *pkgprefix, const char *varname, const char *value) const; void ExportVarComplex(const char *pkgprefix, const char *varname, const char *value) const;
void EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob, void EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
uint32 extradata, bool global, std::vector<ItemInst*> *items); uint32 extradata, bool global, std::vector<void*> *extra_pointers);
void SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, ItemInst* iteminst); void SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, ItemInst *iteminst);
void MapFunctions(); void MapFunctions();
void HandleQueue(); void HandleQueue();
void AddQueueEvent(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob, void AddQueueEvent(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
uint32 extradata, bool global, std::vector<ItemInst*> *items); uint32 extradata, bool global, std::vector<void*> *extra_pointers);
void GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest, void GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global); bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global);
@ -115,7 +119,7 @@ private:
void ExportZoneVariables(std::string &package_name); void ExportZoneVariables(std::string &package_name);
void ExportItemVariables(std::string &package_name, Mob *mob); void ExportItemVariables(std::string &package_name, Mob *mob);
void ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data, void ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<ItemInst*> *items); NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<void*> *extra_pointers);
std::map<uint32, PerlQuestStatus> npc_quest_status_; std::map<uint32, PerlQuestStatus> npc_quest_status_;
PerlQuestStatus global_npc_quest_status_; PerlQuestStatus global_npc_quest_status_;

32
zone/entity.cpp
View File

@ -715,13 +715,12 @@ void EntityList::AddToSpawnQueue(uint16 entityid, NewSpawn_Struct** ns) {
NumSpawnsOnQueue++; NumSpawnsOnQueue++;
if (tsFirstSpawnOnQueue == 0xFFFFFFFF) if (tsFirstSpawnOnQueue == 0xFFFFFFFF)
tsFirstSpawnOnQueue = Timer::GetCurrentTime(); tsFirstSpawnOnQueue = Timer::GetCurrentTime();
*ns = 0; // make it so the calling function cant fuck us and delete the data =) *ns = nullptr;
} }
void EntityList::CheckSpawnQueue() { void EntityList::CheckSpawnQueue() {
// Send the stuff if the oldest packet on the queue is older than 50ms -Quagmire // Send the stuff if the oldest packet on the queue is older than 50ms -Quagmire
if (tsFirstSpawnOnQueue != 0xFFFFFFFF && (Timer::GetCurrentTime() - tsFirstSpawnOnQueue) > 50) { if (tsFirstSpawnOnQueue != 0xFFFFFFFF && (Timer::GetCurrentTime() - tsFirstSpawnOnQueue) > 50) {
//if (NumSpawnsOnQueue <= 5) {
LinkedListIterator<NewSpawn_Struct*> iterator(SpawnQueue); LinkedListIterator<NewSpawn_Struct*> iterator(SpawnQueue);
EQApplicationPacket* outapp = 0; EQApplicationPacket* outapp = 0;
@ -729,29 +728,10 @@ void EntityList::CheckSpawnQueue() {
while(iterator.MoreElements()) { while(iterator.MoreElements()) {
outapp = new EQApplicationPacket; outapp = new EQApplicationPacket;
Mob::CreateSpawnPacket(outapp, iterator.GetData()); Mob::CreateSpawnPacket(outapp, iterator.GetData());
// cout << "Sending spawn packet: " << iterator.GetData()->spawn.name << endl;
QueueClients(0, outapp); QueueClients(0, outapp);
safe_delete(outapp); safe_delete(outapp);
iterator.RemoveCurrent(); iterator.RemoveCurrent();
} }
//sending Spawns like this after zone in causes the client to freeze...
/*}
else {
uint32 spawns_per_pack = MAX_SPAWNS_PER_PACKET;
if(NumSpawnsOnQueue < spawns_per_pack)
spawns_per_pack = NumSpawnsOnQueue;
BulkZoneSpawnPacket* bzsp = new BulkZoneSpawnPacket(0, spawns_per_pack);
LinkedListIterator<NewSpawn_Struct*> iterator(SpawnQueue);
iterator.Reset();
while(iterator.MoreElements()) {
bzsp->AddSpawn(iterator.GetData());
iterator.RemoveCurrent();
}
safe_delete(bzsp);
}*/
tsFirstSpawnOnQueue = 0xFFFFFFFF; tsFirstSpawnOnQueue = 0xFFFFFFFF;
NumSpawnsOnQueue = 0; NumSpawnsOnQueue = 0;
} }
@ -1883,8 +1863,12 @@ void EntityList::DuelMessage(Mob* winner, Mob* loser, bool flee) {
if(winner->GetLevelCon(winner->GetLevel(), loser->GetLevel()) > 2) if(winner->GetLevelCon(winner->GetLevel(), loser->GetLevel()) > 2)
{ {
parse->EventPlayer(EVENT_DUEL_WIN, winner->CastToClient(), loser->GetName(), loser->CastToClient()->CharacterID()); std::vector<void*> args;
parse->EventPlayer(EVENT_DUEL_LOSE, loser->CastToClient(), winner->GetName(), winner->CastToClient()->CharacterID()); args.push_back(winner);
args.push_back(loser);
parse->EventPlayer(EVENT_DUEL_WIN, winner->CastToClient(), loser->GetName(), loser->CastToClient()->CharacterID(), &args);
parse->EventPlayer(EVENT_DUEL_LOSE, loser->CastToClient(), winner->GetName(), winner->CastToClient()->CharacterID(), &args);
} }
iterator.Reset(); iterator.Reset();
@ -3367,6 +3351,8 @@ void EntityList::ClearFeignAggro(Mob* targ)
} }
if(targ->IsClient()) { if(targ->IsClient()) {
std::vector<void*> args;
args.push_back(iterator.GetData());
int i = parse->EventPlayer(EVENT_FEIGN_DEATH, targ->CastToClient(), "", 0); int i = parse->EventPlayer(EVENT_FEIGN_DEATH, targ->CastToClient(), "", 0);
if(i != 0) { if(i != 0) {
iterator.Advance(); iterator.Advance();

32
zone/forage.cpp
View File

@ -350,23 +350,28 @@ void Client::GoFish()
const Item_Struct* food_item = database.GetItem(food_id); const Item_Struct* food_item = database.GetItem(food_id);
Message_StringID(MT_Skills, FISHING_SUCCESS); Message_StringID(MT_Skills, FISHING_SUCCESS);
const ItemInst* inst = database.CreateItem(food_item, 1); ItemInst* inst = database.CreateItem(food_item, 1);
if(inst != nullptr) { if(inst != nullptr) {
if(CheckLoreConflict(inst->GetItem())) if(CheckLoreConflict(inst->GetItem()))
{ {
this->Message_StringID(0,DUP_LORE); Message_StringID(0, DUP_LORE);
safe_delete(inst);
} }
else else
{ {
PushItemOnCursor(*inst); // changed from PutItemInInventory(SLOT_CURSOR, *inst); - was additional overhead PushItemOnCursor(*inst);
SendItemPacket(SLOT_CURSOR,inst,ItemPacketSummonItem); SendItemPacket(SLOT_CURSOR,inst,ItemPacketSummonItem);
if(RuleB(TaskSystem, EnableTaskSystem)) if(RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityFish, food_id); UpdateTasksForItem(ActivityFish, food_id);
safe_delete(inst);
inst = m_inv.GetItem(SLOT_CURSOR);
} }
safe_delete(inst);
} }
parse->EventPlayer(EVENT_FISH_SUCCESS, this, "", inst != nullptr ? inst->GetItem()->ID : 0); std::vector<void*> args;
args.push_back(inst);
parse->EventPlayer(EVENT_FISH_SUCCESS, this, "", inst != nullptr ? inst->GetItem()->ID : 0, &args);
} }
else else
{ {
@ -459,28 +464,33 @@ void Client::ForageItem(bool guarantee) {
} }
Message_StringID(MT_Skills, stringid); Message_StringID(MT_Skills, stringid);
const ItemInst* inst = database.CreateItem(food_item, 1); ItemInst* inst = database.CreateItem(food_item, 1);
if(inst != nullptr) { if(inst != nullptr) {
// check to make sure it isn't a foraged lore item // check to make sure it isn't a foraged lore item
if(CheckLoreConflict(inst->GetItem())) if(CheckLoreConflict(inst->GetItem()))
{ {
this->Message_StringID(0,DUP_LORE); Message_StringID(0, DUP_LORE);
safe_delete(inst);
} }
else { else {
PushItemOnCursor(*inst); PushItemOnCursor(*inst);
SendItemPacket(SLOT_CURSOR, inst, ItemPacketSummonItem); SendItemPacket(SLOT_CURSOR, inst, ItemPacketSummonItem);
if(RuleB(TaskSystem, EnableTaskSystem)) if(RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityForage, foragedfood); UpdateTasksForItem(ActivityForage, foragedfood);
safe_delete(inst);
inst = m_inv.GetItem(SLOT_CURSOR);
} }
safe_delete(inst);
} }
parse->EventPlayer(EVENT_FORAGE_SUCCESS, this, "", inst != nullptr ? inst->GetItem()->ID : 0); std::vector<void*> args;
args.push_back(inst);
parse->EventPlayer(EVENT_FORAGE_SUCCESS, this, "", inst ? inst->GetItem()->ID : 0, &args);
int ChanceSecondForage = aabonuses.ForageAdditionalItems + itembonuses.ForageAdditionalItems + spellbonuses.ForageAdditionalItems; int ChanceSecondForage = aabonuses.ForageAdditionalItems + itembonuses.ForageAdditionalItems + spellbonuses.ForageAdditionalItems;
if(!guarantee && MakeRandomInt(0,99) < ChanceSecondForage) { if(!guarantee && MakeRandomInt(0,99) < ChanceSecondForage) {
this->Message_StringID(MT_Skills, FORAGE_MASTERY); Message_StringID(MT_Skills, FORAGE_MASTERY);
this->ForageItem(true); ForageItem(true);
} }
} else { } else {

2
zone/inventory.cpp
View File

@ -303,7 +303,7 @@ void Client::SummonItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2,
if ((RuleB(Character, EnableDiscoveredItems))) if ((RuleB(Character, EnableDiscoveredItems)))
{ {
if(!GetGM() && !IsDiscovered(item_id)) if(!GetGM() && !IsDiscovered(item_id))
DiscoverItem(item_id); DiscoverItem(item_id);
} }
} }
} }

6
zone/lua_door.cpp
View File

@ -7,11 +7,6 @@
#include "doors.h" #include "doors.h"
#include "lua_door.h" #include "lua_door.h"
int Lua_Door::GetID() {
Lua_Safe_Call_Int();
return self->GetID();
}
void Lua_Door::SetDoorName(const char *name) { void Lua_Door::SetDoorName(const char *name) {
Lua_Safe_Call_Void(); Lua_Safe_Call_Void();
self->SetDoorName(name); self->SetDoorName(name);
@ -147,7 +142,6 @@ luabind::scope lua_register_door() {
.def(luabind::constructor<>()) .def(luabind::constructor<>())
.property("null", &Lua_Door::Null) .property("null", &Lua_Door::Null)
.property("valid", &Lua_Door::Valid) .property("valid", &Lua_Door::Valid)
.def("GetID", (int(Lua_Door::*)(void))&Lua_Door::GetID)
.def("SetDoorName", (void(Lua_Door::*)(const char*))&Lua_Door::SetDoorName) .def("SetDoorName", (void(Lua_Door::*)(const char*))&Lua_Door::SetDoorName)
.def("GetDoorName", (const char*(Lua_Door::*)(void))&Lua_Door::GetDoorName) .def("GetDoorName", (const char*(Lua_Door::*)(void))&Lua_Door::GetDoorName)
.def("GetX", (float(Lua_Door::*)(void))&Lua_Door::GetX) .def("GetX", (float(Lua_Door::*)(void))&Lua_Door::GetX)

1
zone/lua_door.h
View File

@ -29,7 +29,6 @@ public:
return nullptr; return nullptr;
} }
int GetID();
void SetDoorName(const char *name); void SetDoorName(const char *name);
const char *GetDoorName(); const char *GetDoorName();
float GetX(); float GetX();

20
zone/lua_iteminst.cpp
View File

@ -253,6 +253,21 @@ Lua_ItemInst Lua_ItemInst::Clone() {
return Lua_ItemInst(self->Clone(), true); return Lua_ItemInst(self->Clone(), true);
} }
void Lua_ItemInst::SetTimer(std::string name, uint32 time) {
Lua_Safe_Call_Void();
self->SetTimer(name, time);
}
void Lua_ItemInst::StopTimer(std::string name) {
Lua_Safe_Call_Void();
self->StopTimer(name);
}
void Lua_ItemInst::ClearTimers() {
Lua_Safe_Call_Void();
self->ClearTimers();
}
luabind::scope lua_register_iteminst() { luabind::scope lua_register_iteminst() {
return luabind::class_<Lua_ItemInst>("ItemInst") return luabind::class_<Lua_ItemInst>("ItemInst")
.def(luabind::constructor<>()) .def(luabind::constructor<>())
@ -301,7 +316,10 @@ luabind::scope lua_register_iteminst() {
.def("AddExp", (void(Lua_ItemInst::*)(uint32))&Lua_ItemInst::AddExp) .def("AddExp", (void(Lua_ItemInst::*)(uint32))&Lua_ItemInst::AddExp)
.def("GetMaxEvolveLvl", (int(Lua_ItemInst::*)(void))&Lua_ItemInst::GetMaxEvolveLvl) .def("GetMaxEvolveLvl", (int(Lua_ItemInst::*)(void))&Lua_ItemInst::GetMaxEvolveLvl)
.def("GetKillsNeeded", (uint32(Lua_ItemInst::*)(int))&Lua_ItemInst::GetKillsNeeded) .def("GetKillsNeeded", (uint32(Lua_ItemInst::*)(int))&Lua_ItemInst::GetKillsNeeded)
.def("Clone", (Lua_ItemInst(Lua_ItemInst::*)(void))&Lua_ItemInst::Clone); .def("Clone", (Lua_ItemInst(Lua_ItemInst::*)(void))&Lua_ItemInst::Clone)
.def("SetTimer", (void(Lua_ItemInst::*)(std::string,uint32))&Lua_ItemInst::SetTimer)
.def("StopTimer", (void(Lua_ItemInst::*)(std::string))&Lua_ItemInst::StopTimer)
.def("ClearTimers", (void(Lua_ItemInst::*)(void))&Lua_ItemInst::ClearTimers);
} }
#endif #endif

3
zone/lua_iteminst.h
View File

@ -70,6 +70,9 @@ public:
int GetMaxEvolveLvl(); int GetMaxEvolveLvl();
uint32 GetKillsNeeded(int current_level); uint32 GetKillsNeeded(int current_level);
Lua_ItemInst Clone(); Lua_ItemInst Clone();
void SetTimer(std::string name, uint32 time);
void StopTimer(std::string name);
void ClearTimers();
private: private:
bool cloned_; bool cloned_;

79
zone/lua_parser.cpp
View File

@ -130,7 +130,7 @@ LuaParser::LuaParser() {
NPCArgumentDispatch[EVENT_SLAY] = handle_npc_single_mob; NPCArgumentDispatch[EVENT_SLAY] = handle_npc_single_mob;
NPCArgumentDispatch[EVENT_ENTER] = handle_npc_single_client; NPCArgumentDispatch[EVENT_ENTER] = handle_npc_single_client;
NPCArgumentDispatch[EVENT_EXIT] = handle_npc_single_client; NPCArgumentDispatch[EVENT_EXIT] = handle_npc_single_client;
NPCArgumentDispatch[EVENT_TASK_ACCEPTED] = handle_npc_single_client; NPCArgumentDispatch[EVENT_TASK_ACCEPTED] = handle_npc_task_accepted;
NPCArgumentDispatch[EVENT_POPUP_RESPONSE] = handle_npc_popup; NPCArgumentDispatch[EVENT_POPUP_RESPONSE] = handle_npc_popup;
NPCArgumentDispatch[EVENT_WAYPOINT_ARRIVE] = handle_npc_waypoint; NPCArgumentDispatch[EVENT_WAYPOINT_ARRIVE] = handle_npc_waypoint;
NPCArgumentDispatch[EVENT_WAYPOINT_DEPART] = handle_npc_waypoint; NPCArgumentDispatch[EVENT_WAYPOINT_DEPART] = handle_npc_waypoint;
@ -162,11 +162,16 @@ LuaParser::LuaParser() {
PlayerArgumentDispatch[EVENT_DUEL_LOSE] = handle_player_duel_loss; PlayerArgumentDispatch[EVENT_DUEL_LOSE] = handle_player_duel_loss;
PlayerArgumentDispatch[EVENT_LOOT] = handle_player_loot; PlayerArgumentDispatch[EVENT_LOOT] = handle_player_loot;
PlayerArgumentDispatch[EVENT_TASK_STAGE_COMPLETE] = handle_player_task_stage_complete; PlayerArgumentDispatch[EVENT_TASK_STAGE_COMPLETE] = handle_player_task_stage_complete;
PlayerArgumentDispatch[EVENT_TASK_COMPLETE] = handle_player_task_complete; PlayerArgumentDispatch[EVENT_TASK_COMPLETE] = handle_player_task_update;
PlayerArgumentDispatch[EVENT_TASK_UPDATE] = handle_player_task_update;
PlayerArgumentDispatch[EVENT_COMMAND] = handle_player_command; PlayerArgumentDispatch[EVENT_COMMAND] = handle_player_command;
PlayerArgumentDispatch[EVENT_COMBINE_SUCCESS] = handle_player_combine;
PlayerArgumentDispatch[EVENT_COMBINE_FAILURE] = handle_player_combine;
PlayerArgumentDispatch[EVENT_FEIGN_DEATH] = handle_player_feign;
ItemArgumentDispatch[EVENT_ITEM_CLICK] = handle_item_click; ItemArgumentDispatch[EVENT_ITEM_CLICK] = handle_item_click;
ItemArgumentDispatch[EVENT_ITEM_CLICK_CAST] = handle_item_click; ItemArgumentDispatch[EVENT_ITEM_CLICK_CAST] = handle_item_click;
ItemArgumentDispatch[EVENT_TIMER] = handle_item_timer;
SpellArgumentDispatch[EVENT_SPELL_EFFECT_CLIENT] = handle_spell_effect; SpellArgumentDispatch[EVENT_SPELL_EFFECT_CLIENT] = handle_spell_effect;
SpellArgumentDispatch[EVENT_SPELL_BUFF_TIC_CLIENT] = handle_spell_effect; SpellArgumentDispatch[EVENT_SPELL_BUFF_TIC_CLIENT] = handle_spell_effect;
@ -182,7 +187,7 @@ LuaParser::~LuaParser() {
} }
int LuaParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int LuaParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -197,11 +202,11 @@ int LuaParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data,
} }
std::string package_name = "npc_" + std::to_string(npc->GetNPCTypeID()); std::string package_name = "npc_" + std::to_string(npc->GetNPCTypeID());
return _EventNPC(package_name, evt, npc, init, data, extra_data, items); return _EventNPC(package_name, evt, npc, init, data, extra_data, extra_pointers);
} }
int LuaParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int LuaParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -215,11 +220,11 @@ int LuaParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string
return 0; return 0;
} }
return _EventNPC("global_npc", evt, npc, init, data, extra_data, items); return _EventNPC("global_npc", evt, npc, init, data, extra_data, extra_pointers);
} }
int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items, luabind::object *l_func) { std::vector<void*> *extra_pointers, luabind::object *l_func) {
const char *sub_name = LuaEvents[evt]; const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L); int start = lua_gettop(L);
@ -242,7 +247,7 @@ int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, M
lua_setfield(L, -2, "self"); lua_setfield(L, -2, "self");
auto arg_function = NPCArgumentDispatch[evt]; auto arg_function = NPCArgumentDispatch[evt];
arg_function(this, L, npc, init, data, extra_data, items); arg_function(this, L, npc, init, data, extra_data, extra_pointers);
Client *c = (init && init->IsClient()) ? init->CastToClient() : nullptr; Client *c = (init && init->IsClient()) ? init->CastToClient() : nullptr;
quest_manager.StartQuest(npc, c, nullptr); quest_manager.StartQuest(npc, c, nullptr);
@ -277,7 +282,8 @@ int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, M
return 0; return 0;
} }
int LuaParser::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int LuaParser::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -291,10 +297,11 @@ int LuaParser::EventPlayer(QuestEventID evt, Client *client, std::string data, u
return 0; return 0;
} }
return _EventPlayer("player", evt, client, data, extra_data); return _EventPlayer("player", evt, client, data, extra_data, extra_pointers);
} }
int LuaParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { int LuaParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -308,11 +315,11 @@ int LuaParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string d
return 0; return 0;
} }
return _EventPlayer("global_player", evt, client, data, extra_data); return _EventPlayer("global_player", evt, client, data, extra_data, extra_pointers);
} }
int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data, int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data,
luabind::object *l_func) { std::vector<void*> *extra_pointers, luabind::object *l_func) {
const char *sub_name = LuaEvents[evt]; const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L); int start = lua_gettop(L);
@ -334,7 +341,7 @@ int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *
lua_setfield(L, -2, "self"); lua_setfield(L, -2, "self");
auto arg_function = PlayerArgumentDispatch[evt]; auto arg_function = PlayerArgumentDispatch[evt];
arg_function(this, L, client, data, extra_data); arg_function(this, L, client, data, extra_data, extra_pointers);
quest_manager.StartQuest(client, client, nullptr); quest_manager.StartQuest(client, client, nullptr);
if(lua_pcall(L, 1, 1, 0)) { if(lua_pcall(L, 1, 1, 0)) {
@ -368,7 +375,8 @@ int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *
return 0; return 0;
} }
int LuaParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { int LuaParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -384,11 +392,11 @@ int LuaParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *
std::string package_name = "item_"; std::string package_name = "item_";
package_name += std::to_string(item->GetID()); package_name += std::to_string(item->GetID());
return _EventItem(package_name, evt, client, item, mob, data, extra_data); return _EventItem(package_name, evt, client, item, mob, data, extra_data, extra_pointers);
} }
int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *client, ItemInst *item, Mob *mob, int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *client, ItemInst *item, Mob *mob,
std::string data, uint32 extra_data, luabind::object *l_func) { std::string data, uint32 extra_data, std::vector<void*> *extra_pointers, luabind::object *l_func) {
const char *sub_name = LuaEvents[evt]; const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L); int start = lua_gettop(L);
@ -416,7 +424,7 @@ int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *cl
//redo this arg function //redo this arg function
auto arg_function = ItemArgumentDispatch[evt]; auto arg_function = ItemArgumentDispatch[evt];
arg_function(this, L, client, item, 0, extra_data); arg_function(this, L, client, item, data, extra_data, extra_pointers);
quest_manager.StartQuest(client, client, item); quest_manager.StartQuest(client, client, item);
if(lua_pcall(L, 1, 1, 0)) { if(lua_pcall(L, 1, 1, 0)) {
@ -450,7 +458,8 @@ int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *cl
return 0; return 0;
} }
int LuaParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { int LuaParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -462,11 +471,11 @@ int LuaParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spe
return 0; return 0;
} }
return _EventSpell(package_name, evt, npc, client, spell_id, extra_data); return _EventSpell(package_name, evt, npc, client, spell_id, extra_data, extra_pointers);
} }
int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data, int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
luabind::object *l_func) { std::vector<void*> *extra_pointers, luabind::object *l_func) {
const char *sub_name = LuaEvents[evt]; const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L); int start = lua_gettop(L);
@ -496,7 +505,7 @@ int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc,
lua_setfield(L, -2, "self"); lua_setfield(L, -2, "self");
auto arg_function = SpellArgumentDispatch[evt]; auto arg_function = SpellArgumentDispatch[evt];
arg_function(this, L, npc, client, spell_id, extra_data); arg_function(this, L, npc, client, spell_id, extra_data, extra_pointers);
quest_manager.StartQuest(npc, client, nullptr); quest_manager.StartQuest(npc, client, nullptr);
if(lua_pcall(L, 1, 1, 0)) { if(lua_pcall(L, 1, 1, 0)) {
@ -530,7 +539,7 @@ int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc,
return 0; return 0;
} }
int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data) { int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data, std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return 0; return 0;
@ -542,10 +551,11 @@ int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, uint
return 0; return 0;
} }
return _EventEncounter(package_name, evt, encounter_name, extra_data); return _EventEncounter(package_name, evt, encounter_name, extra_data, extra_pointers);
} }
int LuaParser::_EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, uint32 extra_data) { int LuaParser::_EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers) {
const char *sub_name = LuaEvents[evt]; const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L); int start = lua_gettop(L);
@ -884,7 +894,7 @@ void LuaParser::MapFunctions(lua_State *L) {
} }
void LuaParser::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, void LuaParser::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return; return;
@ -904,13 +914,14 @@ void LuaParser::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::str
while(riter != iter->second.end()) { while(riter != iter->second.end()) {
if(riter->event_id == evt) { if(riter->event_id == evt) {
std::string package_name = "encounter_" + riter->encounter_name; std::string package_name = "encounter_" + riter->encounter_name;
_EventNPC(package_name, evt, npc, init, data, extra_data, items, &riter->lua_reference); _EventNPC(package_name, evt, npc, init, data, extra_data, extra_pointers, &riter->lua_reference);
} }
++riter; ++riter;
} }
} }
void LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data) { void LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return; return;
@ -927,13 +938,14 @@ void LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::strin
while(riter != iter->second.end()) { while(riter != iter->second.end()) {
if(riter->event_id == evt) { if(riter->event_id == evt) {
std::string package_name = "encounter_" + riter->encounter_name; std::string package_name = "encounter_" + riter->encounter_name;
_EventPlayer(package_name, evt, client, data, extra_data, &riter->lua_reference); _EventPlayer(package_name, evt, client, data, extra_data, extra_pointers, &riter->lua_reference);
} }
++riter; ++riter;
} }
} }
void LuaParser::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data) { void LuaParser::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return; return;
@ -954,13 +966,14 @@ void LuaParser::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *it
while(riter != iter->second.end()) { while(riter != iter->second.end()) {
if(riter->event_id == evt) { if(riter->event_id == evt) {
std::string package_name = "encounter_" + riter->encounter_name; std::string package_name = "encounter_" + riter->encounter_name;
_EventItem(package_name, evt, client, item, mob, data, extra_data, &riter->lua_reference); _EventItem(package_name, evt, client, item, mob, data, extra_data, extra_pointers, &riter->lua_reference);
} }
++riter; ++riter;
} }
} }
void LuaParser::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data) { void LuaParser::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
evt = ConvertLuaEvent(evt); evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) { if(evt >= _LargestEventID) {
return; return;
@ -977,7 +990,7 @@ void LuaParser::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, u
while(riter != iter->second.end()) { while(riter != iter->second.end()) {
if(riter->event_id == evt) { if(riter->event_id == evt) {
std::string package_name = "encounter_" + riter->encounter_name; std::string package_name = "encounter_" + riter->encounter_name;
_EventSpell(package_name, evt, npc, client, spell_id, extra_data, &riter->lua_reference); _EventSpell(package_name, evt, npc, client, spell_id, extra_data, extra_pointers, &riter->lua_reference);
} }
++riter; ++riter;
} }

41
zone/lua_parser.h
View File

@ -26,14 +26,19 @@ public:
~LuaParser(); ~LuaParser();
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data); virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data); std::vector<void*> *extra_pointers);
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data); virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual bool HasQuestSub(uint32 npc_id, QuestEventID evt); virtual bool HasQuestSub(uint32 npc_id, QuestEventID evt);
virtual bool HasGlobalQuestSub(QuestEventID evt); virtual bool HasGlobalQuestSub(QuestEventID evt);
@ -58,21 +63,25 @@ public:
virtual uint32 GetIdentifier() { return 0xb0712acc; } virtual uint32 GetIdentifier() { return 0xb0712acc; }
virtual void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, virtual void DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
virtual void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data); virtual void DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
virtual void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
virtual void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data); virtual void DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
virtual void DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
private: private:
int _EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, int _EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items, luabind::object *l_func = nullptr); std::vector<void*> *extra_pointers, luabind::object *l_func = nullptr);
int _EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data, int _EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data,
luabind::object *l_func = nullptr); std::vector<void*> *extra_pointers, luabind::object *l_func = nullptr);
int _EventItem(std::string package_name, QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, int _EventItem(std::string package_name, QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data,
uint32 extra_data, luabind::object *l_func = nullptr); uint32 extra_data, std::vector<void*> *extra_pointers, luabind::object *l_func = nullptr);
int _EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data, int _EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
luabind::object *l_func = nullptr); std::vector<void*> *extra_pointers, luabind::object *l_func = nullptr);
int _EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, uint32 extra_data); int _EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, uint32 extra_data,
std::vector<void*> *extra_pointers);
void LoadScript(std::string filename, std::string package_name); void LoadScript(std::string filename, std::string package_name);
bool HasFunction(std::string function, std::string package_name); bool HasFunction(std::string function, std::string package_name);

202
zone/lua_parser_events.cpp
View File

@ -17,12 +17,15 @@
#include "lua_client.h" #include "lua_client.h"
#include "lua_npc.h" #include "lua_npc.h"
#include "lua_spell.h" #include "lua_spell.h"
#include "lua_corpse.h"
#include "lua_door.h"
#include "lua_object.h"
#include "zone.h" #include "zone.h"
#include "lua_parser_events.h" #include "lua_parser_events.h"
//NPC //NPC
void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
npc->DoQuestPause(init); npc->DoQuestPause(init);
Lua_Client l_client(reinterpret_cast<Client*>(init)); Lua_Client l_client(reinterpret_cast<Client*>(init));
@ -38,7 +41,7 @@ void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *in
} }
void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init)); Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::object l_client_o = luabind::object(L, l_client); luabind::object l_client_o = luabind::object(L, l_client);
l_client_o.push(L); l_client_o.push(L);
@ -48,10 +51,10 @@ void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *
std::stringstream ident; std::stringstream ident;
ident << npc->GetNPCTypeID(); ident << npc->GetNPCTypeID();
if(items) { if(extra_pointers) {
for(size_t i = 0; i < items->size(); ++i) { for(size_t i = 0; i < extra_pointers->size(); ++i) {
std::string prefix = "item" + std::to_string(i + 1); std::string prefix = "item" + std::to_string(i + 1);
Lua_ItemInst l_inst = items->at(i); Lua_ItemInst l_inst = reinterpret_cast<ItemInst*>(extra_pointers->at(i));
luabind::object l_inst_o = luabind::object(L, l_inst); luabind::object l_inst_o = luabind::object(L, l_inst);
l_inst_o.push(L); l_inst_o.push(L);
@ -74,7 +77,7 @@ void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *
} }
void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
if(extra_data == 1) { if(extra_data == 1) {
lua_pushinteger(L, -1); lua_pushinteger(L, -1);
lua_setfield(L, -2, "hp_event"); lua_setfield(L, -2, "hp_event");
@ -91,7 +94,7 @@ void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *ini
} }
void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Mob l_mob(init); Lua_Mob l_mob(init);
luabind::object l_mob_o = luabind::object(L, l_mob); luabind::object l_mob_o = luabind::object(L, l_mob);
l_mob_o.push(L); l_mob_o.push(L);
@ -99,7 +102,7 @@ void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *i
} }
void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init)); Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::object l_client_o = luabind::object(L, l_client); luabind::object l_client_o = luabind::object(L, l_client);
l_client_o.push(L); l_client_o.push(L);
@ -107,15 +110,26 @@ void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob
} }
void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_NPC l_npc(reinterpret_cast<NPC*>(init)); Lua_NPC l_npc(reinterpret_cast<NPC*>(init));
luabind::object l_npc_o = luabind::object(L, l_npc); luabind::object l_npc_o = luabind::object(L, l_npc);
l_npc_o.push(L); l_npc_o.push(L);
lua_setfield(L, -2, "other"); lua_setfield(L, -2, "other");
} }
void handle_npc_task_accepted(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::object l_client_o = luabind::object(L, l_client);
l_client_o.push(L);
lua_setfield(L, -2, "other");
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "task_id");
}
void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Mob l_mob(init); Lua_Mob l_mob(init);
luabind::object l_mob_o = luabind::object(L, l_mob); luabind::object l_mob_o = luabind::object(L, l_mob);
l_mob_o.push(L); l_mob_o.push(L);
@ -126,7 +140,7 @@ void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init,
} }
void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Mob l_mob(init); Lua_Mob l_mob(init);
luabind::object l_mob_o = luabind::object(L, l_mob); luabind::object l_mob_o = luabind::object(L, l_mob);
l_mob_o.push(L); l_mob_o.push(L);
@ -137,7 +151,7 @@ void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *ini
} }
void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Mob l_mob(init); Lua_Mob l_mob(init);
luabind::object l_mob_o = luabind::object(L, l_mob); luabind::object l_mob_o = luabind::object(L, l_mob);
l_mob_o.push(L); l_mob_o.push(L);
@ -149,19 +163,19 @@ void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, s
void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(data)); lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "signal"); lua_setfield(L, -2, "signal");
} }
void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
lua_pushstring(L, data.c_str()); lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer"); lua_setfield(L, -2, "timer");
} }
void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
Lua_Mob l_mob(init); Lua_Mob l_mob(init);
luabind::object l_mob_o = luabind::object(L, l_mob); luabind::object l_mob_o = luabind::object(L, l_mob);
l_mob_o.push(L); l_mob_o.push(L);
@ -189,7 +203,7 @@ void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init,
} }
void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
int spell_id = std::stoi(data); int spell_id = std::stoi(data);
if(IsValidSpell(spell_id)) { if(IsValidSpell(spell_id)) {
Lua_Spell l_spell(&spells[spell_id]); Lua_Spell l_spell(&spells[spell_id]);
@ -205,11 +219,12 @@ void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, s
} }
void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items) { std::vector<void*> *extra_pointers) {
} }
//Player //Player
void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushstring(L, data.c_str()); lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "message"); lua_setfield(L, -2, "message");
@ -217,7 +232,8 @@ void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std:
lua_setfield(L, -2, "language"); lua_setfield(L, -2, "language");
} }
void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
Seperator sep(data.c_str()); Seperator sep(data.c_str());
Mob *o = entity_list.GetMobID(std::stoi(sep.arg[0])); Mob *o = entity_list.GetMobID(std::stoi(sep.arg[0]));
@ -246,12 +262,14 @@ void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, st
lua_setfield(L, -2, "skill"); lua_setfield(L, -2, "skill");
} }
void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushstring(L, data.c_str()); lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer"); lua_setfield(L, -2, "timer");
} }
void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
const Item_Struct *item = database.GetItem(extra_data); const Item_Struct *item = database.GetItem(extra_data);
if(item) { if(item) {
Lua_Item l_item(item); Lua_Item l_item(item);
@ -266,37 +284,52 @@ void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* cl
} }
} }
void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushinteger(L, extra_data); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "item_id"); Lua_ItemInst l_item(reinterpret_cast<ItemInst*>(extra_pointers->at(0)));
luabind::object l_item_o = luabind::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
} }
void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushinteger(L, std::stoi(data)); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "object_id"); Lua_Object l_object(reinterpret_cast<Object*>(extra_pointers->at(0)));
luabind::object l_object_o = luabind::object(L, l_object);
l_object_o.push(L);
lua_setfield(L, -2, "object");
} }
void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushinteger(L, std::stoi(data)); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "door_id"); Lua_Door l_door(reinterpret_cast<Doors*>(extra_pointers->at(0)));
luabind::object l_door_o = luabind::object(L, l_door);
l_door_o.push(L);
lua_setfield(L, -2, "door");
} }
void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(data)); lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "signal"); lua_setfield(L, -2, "signal");
} }
void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(data)); lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "popup_id"); lua_setfield(L, -2, "popup_id");
} }
void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushinteger(L, std::stoi(data)); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "picked_up_id"); Lua_ItemInst l_item(reinterpret_cast<ItemInst*>(extra_pointers->at(0)));
luabind::object l_item_o = luabind::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
} }
void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
int spell_id = std::stoi(data); int spell_id = std::stoi(data);
if(IsValidSpell(spell_id)) { if(IsValidSpell(spell_id)) {
Lua_Spell l_spell(&spells[spell_id]); Lua_Spell l_spell(&spells[spell_id]);
@ -311,45 +344,49 @@ void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std
lua_setfield(L, -2, "spell"); lua_setfield(L, -2, "spell");
} }
void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(data)); lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "task_id"); lua_setfield(L, -2, "task_id");
} }
void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(data)); lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "zone_id"); lua_setfield(L, -2, "zone_id");
} }
void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushstring(L, data.c_str()); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "loser_character_name"); Lua_Client l_client(reinterpret_cast<Client*>(extra_pointers->at(1)));
luabind::object l_client_o = luabind::object(L, l_client);
lua_pushinteger(L, extra_data); l_client_o.push(L);
lua_setfield(L, -2, "loser_character_id"); lua_setfield(L, -2, "other");
} }
void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
lua_pushstring(L, data.c_str()); std::vector<void*> *extra_pointers) {
lua_setfield(L, -2, "winner_character_name"); Lua_Client l_client(reinterpret_cast<Client*>(extra_pointers->at(0)));
luabind::object l_client_o = luabind::object(L, l_client);
lua_pushinteger(L, extra_data); l_client_o.push(L);
lua_setfield(L, -2, "winner_character_id"); lua_setfield(L, -2, "other");
} }
void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
Seperator sep(data.c_str()); std::vector<void*> *extra_pointers) {
lua_pushinteger(L, std::stoi(sep.arg[0])); Lua_ItemInst l_item(reinterpret_cast<ItemInst*>(extra_pointers->at(0)));
lua_setfield(L, -2, "looted_id"); luabind::object l_item_o = luabind::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
lua_pushinteger(L, std::stoi(sep.arg[1])); Lua_Corpse l_corpse(reinterpret_cast<Corpse*>(extra_pointers->at(1)));
lua_setfield(L, -2, "looted_charges"); luabind::object l_corpse_o = luabind::object(L, l_corpse);
l_corpse_o.push(L);
lua_pushstring(L, sep.arg[2]);
lua_setfield(L, -2, "corpse"); lua_setfield(L, -2, "corpse");
} }
void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
Seperator sep(data.c_str()); Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0])); lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "task_id"); lua_setfield(L, -2, "task_id");
@ -358,10 +395,11 @@ void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Clie
lua_setfield(L, -2, "activity_id"); lua_setfield(L, -2, "activity_id");
} }
void handle_player_task_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_task_update(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
Seperator sep(data.c_str()); Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0])); lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "done_count"); lua_setfield(L, -2, "count");
lua_pushinteger(L, std::stoi(sep.arg[1])); lua_pushinteger(L, std::stoi(sep.arg[1]));
lua_setfield(L, -2, "activity_id"); lua_setfield(L, -2, "activity_id");
@ -370,7 +408,8 @@ void handle_player_task_complete(QuestInterface *parse, lua_State* L, Client* cl
lua_setfield(L, -2, "task_id"); lua_setfield(L, -2, "task_id");
} }
void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
Seperator sep(data.c_str(), ' ', 10, 100, true); Seperator sep(data.c_str(), ' ', 10, 100, true);
std::string command(sep.arg[0] + 1); std::string command(sep.arg[0] + 1);
lua_pushstring(L, command.c_str()); lua_pushstring(L, command.c_str());
@ -388,20 +427,43 @@ void handle_player_command(QuestInterface *parse, lua_State* L, Client* client,
lua_setfield(L, -2, "args"); lua_setfield(L, -2, "args");
} }
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data) { void handle_player_combine(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "recipe_id");
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "recipe_name");
}
void handle_player_feign(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
}
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
} }
//Item //Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, uint32 objid, uint32 extra_data) { void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushinteger(L, extra_data); lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id"); lua_setfield(L, -2, "slot_id");
} }
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, uint32 objid, uint32 extra_data) { void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers) {
} }
//Spell //Spell
void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data) { void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
if(npc) { if(npc) {
Lua_NPC l_npc(npc); Lua_NPC l_npc(npc);
luabind::object l_npc_o = luabind::object(L, l_npc); luabind::object l_npc_o = luabind::object(L, l_npc);
@ -421,7 +483,8 @@ void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client*
lua_setfield(L, -2, "caster_id"); lua_setfield(L, -2, "caster_id");
} }
void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data) { void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
if(npc) { if(npc) {
Lua_NPC l_npc(npc); Lua_NPC l_npc(npc);
luabind::object l_npc_o = luabind::object(L, l_npc); luabind::object l_npc_o = luabind::object(L, l_npc);
@ -441,5 +504,6 @@ void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* cl
lua_setfield(L, -2, "buff_slot"); lua_setfield(L, -2, "buff_slot");
} }
void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data) { void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers) {
} }

119
zone/lua_parser_events.h
View File

@ -2,71 +2,104 @@
#define _EQE_LUA_PARSER_EVENTS_H #define _EQE_LUA_PARSER_EVENTS_H
#ifdef LUA_EQEMU #ifdef LUA_EQEMU
typedef void(*NPCArgumentHandler)(QuestInterface*, lua_State*, NPC*, Mob*, std::string, uint32, std::vector<ItemInst*>*); typedef void(*NPCArgumentHandler)(QuestInterface*, lua_State*, NPC*, Mob*, std::string, uint32, std::vector<void*>*);
typedef void(*PlayerArgumentHandler)(QuestInterface*, lua_State*, Client*, std::string, uint32); typedef void(*PlayerArgumentHandler)(QuestInterface*, lua_State*, Client*, std::string, uint32, std::vector<void*>*);
typedef void(*ItemArgumentHandler)(QuestInterface*, lua_State*, Client*, ItemInst*, uint32, uint32); typedef void(*ItemArgumentHandler)(QuestInterface*, lua_State*, Client*, ItemInst*, std::string, uint32, std::vector<void*>*);
typedef void(*SpellArgumentHandler)(QuestInterface*, lua_State*, NPC*, Client*, uint32, uint32); typedef void(*SpellArgumentHandler)(QuestInterface*, lua_State*, NPC*, Client*, uint32, uint32, std::vector<void*>*);
//NPC //NPC
void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_task_accepted(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data, void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<ItemInst*> *items); std::vector<void*> *extra_pointers);
//Player //Player
void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_task_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_task_update(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_combine(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_feign(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
//Item //Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, uint32 objid, uint32 extra_data); void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, uint32 objid, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, std::string data, uint32 extra_data,
std::vector<void*> *extra_pointers);
//Spell //Spell
void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data); void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data); std::vector<void*> *extra_pointers);
void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data); void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<void*> *extra_pointers);
#endif #endif
#endif #endif

142
zone/mob.cpp
View File

@ -726,6 +726,71 @@ void Mob::CreateSpawnPacket(EQApplicationPacket* app, Mob* ForWho) {
memset(app->pBuffer, 0, app->size); memset(app->pBuffer, 0, app->size);
NewSpawn_Struct* ns = (NewSpawn_Struct*)app->pBuffer; NewSpawn_Struct* ns = (NewSpawn_Struct*)app->pBuffer;
FillSpawnStruct(ns, ForWho); FillSpawnStruct(ns, ForWho);
if(strlen(ns->spawn.lastName) == 0) {
switch(ns->spawn.class_)
{
case TRIBUTE_MASTER:
strcpy(ns->spawn.lastName, "Tribute Master");
break;
case ADVENTURERECRUITER:
strcpy(ns->spawn.lastName, "Adventure Recruiter");
break;
case BANKER:
strcpy(ns->spawn.lastName, "Banker");
break;
case ADVENTUREMERCHANT:
strcpy(ns->spawn.lastName,"Adventure Merchant");
break;
case WARRIORGM:
strcpy(ns->spawn.lastName, "GM Warrior");
break;
case PALADINGM:
strcpy(ns->spawn.lastName, "GM Paladin");
break;
case RANGERGM:
strcpy(ns->spawn.lastName, "GM Ranger");
break;
case SHADOWKNIGHTGM:
strcpy(ns->spawn.lastName, "GM Shadowknight");
break;
case DRUIDGM:
strcpy(ns->spawn.lastName, "GM Druid");
break;
case BARDGM:
strcpy(ns->spawn.lastName, "GM Bard");
break;
case ROGUEGM:
strcpy(ns->spawn.lastName, "GM Rogue");
break;
case SHAMANGM:
strcpy(ns->spawn.lastName, "GM Shaman");
break;
case NECROMANCERGM:
strcpy(ns->spawn.lastName, "GM Necromancer");
break;
case WIZARDGM:
strcpy(ns->spawn.lastName, "GM Wizard");
break;
case MAGICIANGM:
strcpy(ns->spawn.lastName, "GM Magician");
break;
case ENCHANTERGM:
strcpy(ns->spawn.lastName, "GM Enchanter");
break;
case BEASTLORDGM:
strcpy(ns->spawn.lastName, "GM Beastlord");
break;
case BERSERKERGM:
strcpy(ns->spawn.lastName, "GM Berserker");
break;
case MERCERNARY_MASTER:
strcpy(ns->spawn.lastName, "Mercenary Recruiter");
break;
default:
break;
}
}
} }
void Mob::CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns) { void Mob::CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns) {
@ -740,47 +805,71 @@ void Mob::CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns) {
// Custom packet data // Custom packet data
NewSpawn_Struct* ns2 = (NewSpawn_Struct*)app->pBuffer; NewSpawn_Struct* ns2 = (NewSpawn_Struct*)app->pBuffer;
strcpy(ns2->spawn.name, ns->spawn.name); strcpy(ns2->spawn.name, ns->spawn.name);
/*if (ns->spawn.class_==MERCHANT) switch(ns->spawn.class_)
strcpy(ns2->spawn.lastName, "EQEmu Shopkeeper"); {
else*/ if (ns->spawn.class_==TRIBUTE_MASTER) case TRIBUTE_MASTER:
strcpy(ns2->spawn.lastName, "Tribute Master"); strcpy(ns2->spawn.lastName, "Tribute Master");
else if (ns->spawn.class_==ADVENTURERECRUITER) break;
case ADVENTURERECRUITER:
strcpy(ns2->spawn.lastName, "Adventure Recruiter"); strcpy(ns2->spawn.lastName, "Adventure Recruiter");
else if (ns->spawn.class_==BANKER) break;
case BANKER:
strcpy(ns2->spawn.lastName, "Banker"); strcpy(ns2->spawn.lastName, "Banker");
else if (ns->spawn.class_==ADVENTUREMERCHANT) break;
case ADVENTUREMERCHANT:
strcpy(ns->spawn.lastName,"Adventure Merchant"); strcpy(ns->spawn.lastName,"Adventure Merchant");
else if (ns->spawn.class_==WARRIORGM) break;
case WARRIORGM:
strcpy(ns2->spawn.lastName, "GM Warrior"); strcpy(ns2->spawn.lastName, "GM Warrior");
else if (ns->spawn.class_==PALADINGM) break;
case PALADINGM:
strcpy(ns2->spawn.lastName, "GM Paladin"); strcpy(ns2->spawn.lastName, "GM Paladin");
else if (ns->spawn.class_==RANGERGM) break;
case RANGERGM:
strcpy(ns2->spawn.lastName, "GM Ranger"); strcpy(ns2->spawn.lastName, "GM Ranger");
else if (ns->spawn.class_==SHADOWKNIGHTGM) break;
case SHADOWKNIGHTGM:
strcpy(ns2->spawn.lastName, "GM Shadowknight"); strcpy(ns2->spawn.lastName, "GM Shadowknight");
else if (ns->spawn.class_==DRUIDGM) break;
case DRUIDGM:
strcpy(ns2->spawn.lastName, "GM Druid"); strcpy(ns2->spawn.lastName, "GM Druid");
else if (ns->spawn.class_==BARDGM) break;
case BARDGM:
strcpy(ns2->spawn.lastName, "GM Bard"); strcpy(ns2->spawn.lastName, "GM Bard");
else if (ns->spawn.class_==ROGUEGM) break;
case ROGUEGM:
strcpy(ns2->spawn.lastName, "GM Rogue"); strcpy(ns2->spawn.lastName, "GM Rogue");
else if (ns->spawn.class_==SHAMANGM) break;
case SHAMANGM:
strcpy(ns2->spawn.lastName, "GM Shaman"); strcpy(ns2->spawn.lastName, "GM Shaman");
else if (ns->spawn.class_==NECROMANCERGM) break;
case NECROMANCERGM:
strcpy(ns2->spawn.lastName, "GM Necromancer"); strcpy(ns2->spawn.lastName, "GM Necromancer");
else if (ns->spawn.class_==WIZARDGM) break;
case WIZARDGM:
strcpy(ns2->spawn.lastName, "GM Wizard"); strcpy(ns2->spawn.lastName, "GM Wizard");
else if (ns->spawn.class_==MAGICIANGM) break;
case MAGICIANGM:
strcpy(ns2->spawn.lastName, "GM Magician"); strcpy(ns2->spawn.lastName, "GM Magician");
else if (ns->spawn.class_==ENCHANTERGM) break;
case ENCHANTERGM:
strcpy(ns2->spawn.lastName, "GM Enchanter"); strcpy(ns2->spawn.lastName, "GM Enchanter");
else if (ns->spawn.class_==BEASTLORDGM) break;
case BEASTLORDGM:
strcpy(ns2->spawn.lastName, "GM Beastlord"); strcpy(ns2->spawn.lastName, "GM Beastlord");
else if (ns->spawn.class_==BERSERKERGM) break;
case BERSERKERGM:
strcpy(ns2->spawn.lastName, "GM Berserker"); strcpy(ns2->spawn.lastName, "GM Berserker");
else break;
case MERCERNARY_MASTER:
strcpy(ns->spawn.lastName, "Mercenary Recruiter");
break;
default:
strcpy(ns2->spawn.lastName, ns->spawn.lastName); strcpy(ns2->spawn.lastName, ns->spawn.lastName);
memset(&app->pBuffer[sizeof(Spawn_Struct)-7],0xFF,7); break;
}
memset(&app->pBuffer[sizeof(Spawn_Struct)-7], 0xFF, 7);
} }
void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
@ -788,10 +877,10 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
int i; int i;
strcpy(ns->spawn.name, name); strcpy(ns->spawn.name, name);
if(IsClient()) if(IsClient()) {
{ strn0cpy(ns->spawn.lastName, lastname, sizeof(ns->spawn.lastName));
strn0cpy(ns->spawn.lastName,lastname,sizeof(ns->spawn.lastName)); }
}
ns->spawn.heading = FloatToEQ19(heading); ns->spawn.heading = FloatToEQ19(heading);
ns->spawn.x = FloatToEQ19(x_pos);//((int32)x_pos)<<3; ns->spawn.x = FloatToEQ19(x_pos);//((int32)x_pos)<<3;
ns->spawn.y = FloatToEQ19(y_pos);//((int32)y_pos)<<3; ns->spawn.y = FloatToEQ19(y_pos);//((int32)y_pos)<<3;
@ -808,7 +897,6 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
ns->spawn.deity = deity; ns->spawn.deity = deity;
ns->spawn.animation = 0; ns->spawn.animation = 0;
ns->spawn.findable = findable?1:0; ns->spawn.findable = findable?1:0;
// vesuvias - appearence fix
ns->spawn.light = light; ns->spawn.light = light;
ns->spawn.showhelm = 1; ns->spawn.showhelm = 1;

2
zone/mob.h
View File

@ -425,6 +425,7 @@ public:
void CreateDespawnPacket(EQApplicationPacket* app, bool Decay); void CreateDespawnPacket(EQApplicationPacket* app, bool Decay);
void CreateHorseSpawnPacket(EQApplicationPacket* app, const char* ownername, uint16 ownerid, Mob* ForWho = 0); void CreateHorseSpawnPacket(EQApplicationPacket* app, const char* ownername, uint16 ownerid, Mob* ForWho = 0);
void CreateSpawnPacket(EQApplicationPacket* app, Mob* ForWho = 0); void CreateSpawnPacket(EQApplicationPacket* app, Mob* ForWho = 0);
static void CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns);
virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho); virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
void CreateHPPacket(EQApplicationPacket* app); void CreateHPPacket(EQApplicationPacket* app);
void SendHPUpdate(); void SendHPUpdate();
@ -432,7 +433,6 @@ public:
//Util //Util
static uint32 RandomTimer(int min, int max); static uint32 RandomTimer(int min, int max);
static uint8 GetDefaultGender(uint16 in_race, uint8 in_gender = 0xFF); static uint8 GetDefaultGender(uint16 in_race, uint8 in_gender = 0xFF);
static void CreateSpawnPacket(EQApplicationPacket* app, NewSpawn_Struct* ns);
uint16 GetSkillByItemType(int ItemType); uint16 GetSkillByItemType(int ItemType);
virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr); virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
virtual void MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower, const char *petname = nullptr); virtual void MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower, const char *petname = nullptr);

20
zone/questmgr.cpp
View File

@ -448,10 +448,7 @@ void QuestManager::settimer(const char *timer_name, int seconds) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
if(questitem) { if(questitem) {
auto timers = questitem->GetTimers(); questitem->SetTimer(timer_name, seconds * 1000);
Timer t(seconds * 1000);
t.Start(seconds * 1000, false);
timers[timer_name] = t;
return; return;
} }
@ -475,10 +472,7 @@ void QuestManager::settimerMS(const char *timer_name, int milliseconds) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
if(questitem) { if(questitem) {
auto timers = questitem->GetTimers(); questitem->SetTimer(timer_name, milliseconds);
Timer t(milliseconds);
t.Start(milliseconds, false);
timers[timer_name] = t;
return; return;
} }
@ -501,6 +495,11 @@ void QuestManager::settimerMS(const char *timer_name, int milliseconds) {
void QuestManager::stoptimer(const char *timer_name) { void QuestManager::stoptimer(const char *timer_name) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
if(questitem) {
questitem->StopTimer(timer_name);
return;
}
std::list<QuestTimer>::iterator cur = QTimerList.begin(), end; std::list<QuestTimer>::iterator cur = QTimerList.begin(), end;
end = QTimerList.end(); end = QTimerList.end();
@ -518,6 +517,11 @@ void QuestManager::stoptimer(const char *timer_name) {
void QuestManager::stopalltimers() { void QuestManager::stopalltimers() {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
if(questitem) {
questitem->ClearTimers();
return;
}
std::list<QuestTimer>::iterator cur = QTimerList.begin(), end, tmp; std::list<QuestTimer>::iterator cur = QTimerList.begin(), end, tmp;
end = QTimerList.end(); end = QTimerList.end();

2
zone/trading.cpp
View File

@ -574,7 +574,7 @@ void Client::FinishTrade(Mob* tradingWith, ServerPacket* qspack, bool finalizer)
quest_npc = true; quest_npc = true;
} }
std::vector<ItemInst*> item_list; std::vector<void*> item_list;
uint32 items[4] = { 0 }; uint32 items[4] = { 0 };
for(int i = 3000; i < 3004; ++i) { for(int i = 3000; i < 3004; ++i) {
ItemInst *inst = m_inv.GetItem(i); ItemInst *inst = m_inv.GetItem(i);

1
zone/zoning.cpp
View File

@ -175,7 +175,6 @@ void Client::Handle_OP_ZoneChange(const EQApplicationPacket *app) {
buf[9] = '\0'; buf[9] = '\0';
parse->EventPlayer(EVENT_ZONE, this, buf, 0); parse->EventPlayer(EVENT_ZONE, this, buf, 0);
//handle circumvention of zone restrictions //handle circumvention of zone restrictions
//we need the value when creating the outgoing packet as well. //we need the value when creating the outgoing packet as well.
uint8 ignorerestrictions = zonesummon_ignorerestrictions; uint8 ignorerestrictions = zonesummon_ignorerestrictions;