diff --git a/changelog.txt b/changelog.txt index abf75bb1f..42a113c8b 100644 --- a/changelog.txt +++ b/changelog.txt @@ -1,5 +1,43 @@ EQEMu Changelog (Started on Sept 24, 2003 15:50) ------------------------------------------------------- +== 11/01/2013 == +JJ: Added in-game commands to enable/disable tradeskill recipes +-Commands: #enablerecipe recipe_id, #disablerecipe recipe_id +-Perl: quest::enablerecipe(recipe_id), quest::disablerecipe(recipe_id) +-Lua: eq.enable_recipe(recipe_id), eq.disable_recipe(recipe_id) + +== 10/31/2013 == +Leere: Add the ability to disable a tradeskill recipe + +== 10/28/2013 == +Uleat: Client patch prep work for extending usable skill range (no apparent issues with Ti through RoF[12-10-2012] testing - i.e., clients showed proper skills and they didn't crash) +Uleat: This final patch aligns the existing server PlayerProfile_Struct with the previous changes. The pp_struct, as well as the character 'pp' blob, remains unchanged in size and alignment. The only difference is that the first trailing 100 bytes of the unknown array have been re-assigned to the skills array, and the unknown array decreased by the same amount. +Notes: + - The existing configuration will allow the use of any new skills up to 99 + - Due to this new segment of the blob having never been written to properly, we may have erratic data there that needs to be cleared before use + - None of the new skills are coded to use these 'new' skill slots + - A per-client method will still need to be observed when coding for the new skill uses + +== 10/27/2013 == +Uleat: Attempted fix for high level (12) debug compile failiures +Notes: + - Explicit Windows vs. Linux code was not changed due to my inability to compile Linux code + - Only CMake accessible flags were corrected if adding the 'std' namespace did not correct the issue + - the tag [CODEBUG] was added to failed code identifed by the above note + - If you are having compile issues after this patch is committed, look to the changes here first +Uleat: Changed riposte fail check to proper failure criteria - (x == a && x == b, where a != b) never passes, so skills a and b can riposte (discovery find, no known reported occurences) +Uleat: Enforced naming standard on my recent changes (Sorry for any inconviencies) +Uleat: Moved DeityTypes enumeration from eq_constants.h to deity.h (expanded utility of accessors, but are yet to be implemented) +Uleat: Changed ItemUseType to ItemInstTypes to better reflect the definition (also to free-up the namespace) +Uleat: Changed ItemClass to ItemClassTypes +Uleat: Converted MATERIAL defines to MaterialUseSlots enumeration - use of scripted 'Bracer' and 'Max' are deprecated +Uleat: Changed ItemTypes to ItemUseTypes - retained the 'ItemType' prefix to avoid too much confusion. Also adopted the '1H Piercing' model found in later clients +Uleat: Converted SkillType typedef enumeration to SkillUseTypes enumeration - Some prep work for adding the newer skills +Uleat: Prepped the client patch files for larger skill buffer size (not active) + +== 10/24/2013 == +demonstar55: Fix some memory leaks in Mob::SpellOnTarget + == 10/21/2013 == demonstar55: Changed GetMinLevel return 0 for more cases that EQ uses for some reason ... demonstar55: Added buff level restrictions, set the Spells:BuffLevelRestrictions to false to have the old behavior. diff --git a/common/EQPacket.cpp b/common/EQPacket.cpp index 04ce3ce7e..5372a0f9d 100644 --- a/common/EQPacket.cpp +++ b/common/EQPacket.cpp @@ -343,7 +343,7 @@ bool valid=false; uint16 packet_crc=ntohs(*(const uint16 *)(buffer+length-2)); #ifdef EQN_DEBUG if (packet_crc && comp_crc != packet_crc) { - cout << "CRC mismatch: comp=" << hex << comp_crc << ", packet=" << packet_crc << dec << endl; + std::cout << "CRC mismatch: comp=" << std::hex << comp_crc << ", packet=" << packet_crc << std::dec << std::endl; } #endif valid = (!packet_crc || comp_crc == packet_crc); diff --git a/common/EQStream.cpp b/common/EQStream.cpp index 1f5d0ea03..962c2f69a 100644 --- a/common/EQStream.cpp +++ b/common/EQStream.cpp @@ -326,7 +326,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p) break; } #endif - //cout << "Got OP_SessionRequest" << endl; + //std::cout << "Got OP_SessionRequest" << std::endl; init(); OutboundQueueClear(); SessionRequest *Request=(SessionRequest *)p->pBuffer; @@ -654,7 +654,7 @@ void EQStream::Write(int eq_fd) int32 threshold=RateThreshold; MRate.unlock(); if (BytesWritten > threshold) { - //cout << "Over threshold: " << BytesWritten << " > " << threshold << endl; + //std::cout << "Over threshold: " << BytesWritten << " > " << threshold << std::endl; return; } @@ -848,15 +848,15 @@ sockaddr_in address; address.sin_port=remote_port; #ifdef NOWAY uint32 ip=address.sin_addr.s_addr; - cout << "Sending to: " + std::cout << "Sending to: " << (int)*(unsigned char *)&ip << "." << (int)*((unsigned char *)&ip+1) << "." << (int)*((unsigned char *)&ip+2) << "." << (int)*((unsigned char *)&ip+3) - << "," << (int)ntohs(address.sin_port) << "(" << p->size << ")" << endl; + << "," << (int)ntohs(address.sin_port) << "(" << p->size << ")" << std::endl; p->DumpRaw(); - cout << "-------------" << endl; + std::cout << "-------------" << std::endl; #endif length=p->serialize(buffer); if (p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) { @@ -907,7 +907,7 @@ char temp[15]; *((unsigned char *)&ip+2), *((unsigned char *)&ip+3), ntohs(from->sin_port)); - //cout << timestamp() << "Data from: " << temp << " OpCode 0x" << hex << setw(2) << setfill('0') << (int)p->opcode << dec << endl; + //std::cout << timestamp() << "Data from: " << temp << " OpCode 0x" << std::hex << std::setw(2) << std::setfill('0') << (int)p->opcode << std::dec << std::endl; //dump_message(p->pBuffer,p->size,timestamp()); } diff --git a/common/EQStreamFactory.cpp b/common/EQStreamFactory.cpp index bc0bad34c..403db3627 100644 --- a/common/EQStreamFactory.cpp +++ b/common/EQStreamFactory.cpp @@ -104,8 +104,8 @@ struct sockaddr_in address; fcntl(sock, F_SETFL, O_NONBLOCK); #endif //moved these because on windows the output was delayed and causing the console window to look bad - //cout << "Starting factory Reader" << endl; - //cout << "Starting factory Writer" << endl; + //std::cout << "Starting factory Reader" << std::endl; + //std::cout << "Starting factory Writer" << std::endl; #ifdef _WINDOWS _beginthread(EQStreamFactoryReaderLoop,0, this); _beginthread(EQStreamFactoryWriterLoop,0, this); @@ -119,7 +119,7 @@ struct sockaddr_in address; EQStream *EQStreamFactory::Pop() { EQStream *s=nullptr; - //cout << "Pop():Locking MNewStreams" << endl; + //std::cout << "Pop():Locking MNewStreams" << std::endl; MNewStreams.lock(); if (NewStreams.size()) { s=NewStreams.front(); @@ -127,18 +127,18 @@ EQStream *s=nullptr; s->PutInUse(); } MNewStreams.unlock(); - //cout << "Pop(): Unlocking MNewStreams" << endl; + //std::cout << "Pop(): Unlocking MNewStreams" << std::endl; return s; } void EQStreamFactory::Push(EQStream *s) { - //cout << "Push():Locking MNewStreams" << endl; + //std::cout << "Push():Locking MNewStreams" << std::endl; MNewStreams.lock(); NewStreams.push(s); MNewStreams.unlock(); - //cout << "Push(): Unlocking MNewStreams" << endl; + //std::cout << "Push(): Unlocking MNewStreams" << std::endl; } void EQStreamFactory::ReaderLoop() @@ -240,7 +240,7 @@ void EQStreamFactory::CheckTimeout() //give it a little time for everybody to finish with it } else { //everybody is done, we can delete it now - //cout << "Removing connection" << endl; + //std::cout << "Removing connection" << std::endl; std::map::iterator temp=stream_itr; stream_itr++; //let whoever has the stream outside delete it @@ -318,9 +318,9 @@ Timer DecayTimer(20); stream_count=Streams.size(); MStreams.unlock(); if (!stream_count) { - //cout << "No streams, waiting on condition" << endl; + //std::cout << "No streams, waiting on condition" << std::endl; WriterWork.Wait(); - //cout << "Awake from condition, must have a stream now" << endl; + //std::cout << "Awake from condition, must have a stream now" << std::endl; } } } diff --git a/common/EmuTCPConnection.cpp b/common/EmuTCPConnection.cpp index 872fa915b..465d16c1e 100644 --- a/common/EmuTCPConnection.cpp +++ b/common/EmuTCPConnection.cpp @@ -171,7 +171,7 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) { struct in_addr in; in.s_addr = GetrIP(); CoutTimestamp(true); - std::cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; + std::cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; #if TCPN_LOG_PACKETS == 2 if (pack->size >= 32) DumpPacket(pack->pBuffer, 32); @@ -198,7 +198,7 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) { struct in_addr in; in.s_addr = GetrIP(); CoutTimestamp(true); - std::cout << ": Logging outgoing TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; + std::cout << ": Logging outgoing TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; #if TCPN_LOG_PACKETS == 2 if (pack->size >= 32) DumpPacket(pack->pBuffer, 32); @@ -237,7 +237,7 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) { struct in_addr in; in.s_addr = GetrIP(); CoutTimestamp(true); - std::cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << tnps->opcode << dec << ", size: " << setw(5) << setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort(); + std::cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << tnps->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort(); if (pOldFormat) std::cout << " (OldFormat)"; std::cout << std::endl; @@ -578,7 +578,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) { struct in_addr in; in.s_addr = GetrIP(); CoutTimestamp(true); - std::cout << ": Logging incoming TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; + std::cout << ": Logging incoming TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; #if TCPN_LOG_PACKETS == 2 if (pack->size >= 32) DumpPacket(pack->pBuffer, 32); @@ -663,7 +663,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) { struct in_addr in; in.s_addr = GetrIP(); CoutTimestamp(true); - std::cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; + std::cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl; #if TCPN_LOG_PACKETS == 2 if (pack->size >= 32) DumpPacket(pack->pBuffer, 32); diff --git a/common/Item.cpp b/common/Item.cpp index ff54f0426..9dd1071f6 100644 --- a/common/Item.cpp +++ b/common/Item.cpp @@ -54,7 +54,7 @@ static inline int32 GetNextItemInstSerialNumber() { } ItemInst::ItemInst(const Item_Struct* item, int16 charges) { - m_use_type = ItemUseNormal; + m_use_type = ItemInstNormal; m_item = item; m_charges = charges; m_price = 0; @@ -76,7 +76,7 @@ ItemInst::ItemInst(const Item_Struct* item, int16 charges) { } ItemInst::ItemInst(SharedDatabase *db, uint32 item_id, int16 charges) { - m_use_type = ItemUseNormal; + m_use_type = ItemInstNormal; m_item = db->GetItem(item_id); m_charges = charges; m_price = 0; @@ -220,10 +220,10 @@ ItemInst* ItemInst::Clone() const } // Query item type -bool ItemInst::IsType(ItemClass item_class) const +bool ItemInst::IsType(ItemClassTypes item_class) const { // Check usage type - if ((m_use_type == ItemUseWorldContainer) && (item_class == ItemClassContainer)) + if ((m_use_type == ItemInstWorldContainer) && (item_class == ItemClassContainer)) return true; if (!m_item) @@ -340,8 +340,8 @@ bool ItemInst::IsAmmo() const { if(!m_item) return false; if((m_item->ItemType == ItemTypeArrow) || - (m_item->ItemType == ItemTypeThrowing) || - (m_item->ItemType == ItemTypeThrowingv2)) + (m_item->ItemType == ItemTypeLargeThrowing) || + (m_item->ItemType == ItemTypeSmallThrowing)) return true; return false; @@ -1201,7 +1201,7 @@ int16 Inventory::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, boo if (inst && inst->IsType(ItemClassContainer) && inst->GetItem()->BagSize >= min_size) { - if(inst->GetItem()->BagType == BagType_Quiver && inst->GetItem()->ItemType != ItemTypeArrow) + if(inst->GetItem()->BagType == BagTypeQuiver && inst->GetItem()->ItemType != ItemTypeArrow) { continue; } @@ -1790,26 +1790,26 @@ int16 Inventory::CalcSlotFromMaterial(uint8 material) { switch(material) { - case MATERIAL_HEAD: + case MaterialHead: return SLOT_HEAD; - case MATERIAL_CHEST: + case MaterialChest: return SLOT_CHEST; - case MATERIAL_ARMS: + case MaterialArms: return SLOT_ARMS; - case MATERIAL_BRACER: + case MaterialWrist: return SLOT_BRACER01; // there's 2 bracers, only one bracer material - case MATERIAL_HANDS: + case MaterialHands: return SLOT_HANDS; - case MATERIAL_LEGS: + case MaterialLegs: return SLOT_LEGS; - case MATERIAL_FEET: + case MaterialFeet: return SLOT_FEET; - case MATERIAL_PRIMARY: + case MaterialPrimary: return SLOT_PRIMARY; - case MATERIAL_SECONDARY: + case MaterialSecondary: return SLOT_SECONDARY; default: - return -1; + return SLOT_INVALID; } } @@ -1818,26 +1818,26 @@ uint8 Inventory::CalcMaterialFromSlot(int16 equipslot) switch(equipslot) { case SLOT_HEAD: - return MATERIAL_HEAD; + return MaterialHead; case SLOT_CHEST: - return MATERIAL_CHEST; + return MaterialChest; case SLOT_ARMS: - return MATERIAL_ARMS; + return MaterialArms; case SLOT_BRACER01: case SLOT_BRACER02: - return MATERIAL_BRACER; + return MaterialWrist; case SLOT_HANDS: - return MATERIAL_HANDS; + return MaterialHands; case SLOT_LEGS: - return MATERIAL_LEGS; + return MaterialLegs; case SLOT_FEET: - return MATERIAL_FEET; + return MaterialFeet; case SLOT_PRIMARY: - return MATERIAL_PRIMARY; + return MaterialPrimary; case SLOT_SECONDARY: - return MATERIAL_SECONDARY; + return MaterialSecondary; default: - return 0xFF; + return _MaterialInvalid; } } @@ -1861,9 +1861,9 @@ bool Inventory::CanItemFitInContainer(const Item_Struct *ItemToTry, const Item_S if(ItemToTry->Size > Container->BagSize) return false; - if((Container->BagType == BagType_Quiver) && (ItemToTry->ItemType != ItemTypeArrow)) return false; + if((Container->BagType == BagTypeQuiver) && (ItemToTry->ItemType != ItemTypeArrow)) return false; - if((Container->BagType == BagType_Bandolier) && (ItemToTry->ItemType != ItemTypeThrowingv2)) return false; + if((Container->BagType == BagTypeBandolier) && (ItemToTry->ItemType != ItemTypeSmallThrowing)) return false; return true; } diff --git a/common/Item.h b/common/Item.h index 47eb7556a..33f0ff12f 100644 --- a/common/Item.h +++ b/common/Item.h @@ -39,13 +39,15 @@ class EvolveInfo; // Stores information about an evolving item family #include "../common/timer.h" // Helper typedefs -typedef std::list::const_iterator iter_queue; +typedef std::list::const_iterator iter_queue; typedef std::map::const_iterator iter_inst; typedef std::map::const_iterator iter_contents; -namespace ItemField { - enum { - source=0, +namespace ItemField +{ + enum + { + source = 0, #define F(x) x, #include "item_fieldlist.h" #undef F @@ -69,10 +71,10 @@ namespace ItemField { #define MAX_ITEMS_PER_BAG 10 // Specifies usage type for item inside ItemInst -enum ItemUseType +enum ItemInstTypes { - ItemUseNormal, - ItemUseWorldContainer + ItemInstNormal = 0, + ItemInstWorldContainer }; typedef enum { @@ -263,7 +265,7 @@ public: ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0); - ItemInst(ItemUseType use_type) { + ItemInst(ItemInstTypes use_type) { m_use_type = use_type; m_item = nullptr; m_charges = 0; @@ -285,7 +287,7 @@ public: ~ItemInst(); // Query item type - bool IsType(ItemClass item_class) const; + bool IsType(ItemClassTypes item_class) const; // Can item be stacked? bool IsStackable() const; @@ -421,7 +423,7 @@ protected: void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; } - ItemUseType m_use_type; // Usage type for item + ItemInstTypes m_use_type; // Usage type for item const Item_Struct* m_item; // Ptr to item data int16 m_charges; // # of charges for chargeable items uint32 m_price; // Bazaar /trader price diff --git a/common/TCPConnection.cpp b/common/TCPConnection.cpp index 5fe7b7ba8..e576f953a 100644 --- a/common/TCPConnection.cpp +++ b/common/TCPConnection.cpp @@ -539,7 +539,7 @@ bool TCPConnection::Process() { if (!RecvData(errbuf)) { struct in_addr in; in.s_addr = GetrIP(); - //cout << inet_ntoa(in) << ":" << GetrPort() << ": " << errbuf << endl; + //std::cout << inet_ntoa(in) << ":" << GetrPort() << ": " << errbuf << std::endl; return false; } /* we break to do the send */ diff --git a/common/TCPServer.h b/common/TCPServer.h index 2ed2e24de..d3eef2e70 100644 --- a/common/TCPServer.h +++ b/common/TCPServer.h @@ -91,7 +91,7 @@ protected: T *data = *cur; if (data->IsFree() && (!data->CheckNetActive())) { #if EQN_DEBUG >= 4 - cout << "TCPConnection Connection deleted." << endl; + std::cout << "TCPConnection Connection deleted." << std::endl; #endif delete data; cur = m_list.erase(cur); diff --git a/common/database.cpp b/common/database.cpp index 8559bc940..1299c199a 100644 --- a/common/database.cpp +++ b/common/database.cpp @@ -199,18 +199,18 @@ bool Database::CheckBannedIPs(const char* loginIP) char errbuf[MYSQL_ERRMSG_SIZE]; char *query = 0; MYSQL_RES *result; - //cout << "Checking against Banned IPs table."<< endl; //Lieka: Debugging + //std::cout << "Checking against Banned IPs table."<< std::endl; //Lieka: Debugging if (RunQuery(query, MakeAnyLenString(&query, "SELECT ip_address FROM Banned_IPs WHERE ip_address='%s'", loginIP), errbuf, &result)) { safe_delete_array(query); if (mysql_num_rows(result) != 0) { - //cout << loginIP << " was present in the banned IPs table" << endl; //Lieka: Debugging + //std::cout << loginIP << " was present in the banned IPs table" << std::endl; //Lieka: Debugging mysql_free_result(result); return true; } else { - //cout << loginIP << " was not present in the banned IPs table." << endl; //Lieka: Debugging + //std::cout << loginIP << " was not present in the banned IPs table." << std::endl; //Lieka: Debugging mysql_free_result(result); return false; } diff --git a/common/deity.h b/common/deity.h index f7a44f5a3..486d17263 100644 --- a/common/deity.h +++ b/common/deity.h @@ -18,48 +18,149 @@ #ifndef DEITY_H #define DEITY_H +#include "types.h" +#include + +// NOTE: This code is not fully implemented since there are no references in the existing code + /* -** Diety List +** Diety types +** +** (ref: eqstr_us.txt) +** +** (Another orphaned enumeration...) */ -#define DEITY_AGNOSTIC 396 //drop the high bit for 140 -#define DEITY_BRELL 202 -#define DEITY_CAZIC 203 -#define DEITY_EROLLSI 204 -#define DEITY_BRISTLE 205 -#define DEITY_INNY 206 -#define DEITY_KARANA 207 -#define DEITY_MITH 208 -#define DEITY_PREXUS 209 -#define DEITY_QUELLIOUS 210 -#define DEITY_RALLOS 211 -#define DEITY_SOLUSEK 213 -#define DEITY_TRIBUNAL 214 -#define DEITY_TUNARE 215 +enum DeityTypes +{ +/*----*/ DeityUnknown = 0, +/*----*/ DeityAgnostic_LB = 140, +/*3251*/ DeityBertoxxulous = 201, +/*3262*/ DeityBrellSirilis, +/*3253*/ DeityCazicThule, +/*3256*/ DeityErollisiMarr, +/*3252*/ DeityBristlebane, +/*3254*/ DeityInnoruuk, +/*3255*/ DeityKarana, +/*3257*/ DeityMithanielMarr, +/*3259*/ DeityPrexus, +/*3260*/ DeityQuellious, +/*3266*/ DeityRallosZek, +/*3258*/ DeityRodcetNife, +/*3261*/ DeitySolusekRo, +/*3263*/ DeityTheTribunal, +/*3264*/ DeityTunare, +/*3265*/ DeityVeeshan, +/*3250*/ DeityAgnostic = 396 +}; -//Guessed: -#define DEITY_BERTOX 201 -#define DEITY_RODCET 212 -#define DEITY_VEESHAN 216 - -/* on items: - *All 0 -AGNOSTIC 1 -BERTOX 2 -BRELL 4 -CAZIC 8 -EROLLSI 16 -BRISTLE 32 -INNY 64 -KARANA 128 -MITH 256 -PREXUS 512 -QUELLIOUS 1024 -RALLOS 2048 -RODCET 4096 -SOLUSEK 8192 -TRIBUNAL 16384 -TUNARE 32768 -VEESHAN 65536 +/* +** Deity type bits +** +** (New orphan, but make use of it!) */ +enum DeityTypeBits : uint32 +{ + BIT_DeityAll = 0x00000000, + BIT_DeityAgnostic = 0x00000001, + BIT_DeityBertoxxulous = 0x00000002, + BIT_DeityBrellSirilis = 0x00000004, + BIT_DeityCazicThule = 0x00000008, + BIT_DeityErollisiMarr = 0x00000010, + BIT_DeityBristlebane = 0x00000020, + BIT_DeityInnoruuk = 0x00000040, + BIT_DeityKarana = 0x00000080, + BIT_DeityMithanielMarr = 0x00000100, + BIT_DeityPrexus = 0x00000200, + BIT_DeityQuellious = 0x00000400, + BIT_DeityRallosZek = 0x00000800, + BIT_DeityRodcetNife = 0x00001000, + BIT_DeitySolusekRo = 0x00002000, + BIT_DeityTheTribunal = 0x00004000, + BIT_DeityTunare = 0x00008000, + BIT_DeityVeeshan = 0x00010000 +}; + +static DeityTypeBits ConvertDeityToBitDeity(DeityTypes deity) +{ + switch(deity) + { + case DeityBertoxxulous: { return BIT_DeityBertoxxulous; } + case DeityBrellSirilis: { return BIT_DeityBrellSirilis; } + case DeityCazicThule: { return BIT_DeityCazicThule; } + case DeityErollisiMarr: { return BIT_DeityErollisiMarr; } + case DeityBristlebane: { return BIT_DeityBristlebane; } + case DeityInnoruuk: { return BIT_DeityInnoruuk; } + case DeityKarana: { return BIT_DeityKarana; } + case DeityMithanielMarr: { return BIT_DeityMithanielMarr; } + case DeityPrexus: { return BIT_DeityPrexus; } + case DeityQuellious: { return BIT_DeityQuellious; } + case DeityRallosZek: { return BIT_DeityRallosZek; } + case DeityRodcetNife: { return BIT_DeityRodcetNife; } + case DeitySolusekRo: { return BIT_DeitySolusekRo; } + case DeityTheTribunal: { return BIT_DeityTheTribunal; } + case DeityTunare: { return BIT_DeityTunare; } + case DeityVeeshan: { return BIT_DeityVeeshan; } + case DeityAgnostic_LB: + case DeityAgnostic: { return BIT_DeityAgnostic; } + default: { break; } + }; + + return BIT_DeityAll; +}; + +static DeityTypes ConvertBitDeityToDeity(DeityTypeBits deity_bit) +{ + switch(deity_bit) + { + case BIT_DeityAgnostic: { return DeityAgnostic; } + case BIT_DeityBertoxxulous: { return DeityBertoxxulous; } + case BIT_DeityBrellSirilis: { return DeityBrellSirilis; } + case BIT_DeityCazicThule: { return DeityCazicThule; } + case BIT_DeityErollisiMarr: { return DeityErollisiMarr; } + case BIT_DeityBristlebane: { return DeityBristlebane; } + case BIT_DeityInnoruuk: { return DeityInnoruuk; } + case BIT_DeityKarana: { return DeityKarana; } + case BIT_DeityMithanielMarr: { return DeityMithanielMarr; } + case BIT_DeityPrexus: { return DeityPrexus; } + case BIT_DeityQuellious: { return DeityQuellious; } + case BIT_DeityRallosZek: { return DeityRallosZek; } + case BIT_DeityRodcetNife: { return DeityRodcetNife; } + case BIT_DeitySolusekRo: { return DeitySolusekRo; } + case BIT_DeityTheTribunal: { return DeityTheTribunal; } + case BIT_DeityTunare: { return DeityTunare; } + case BIT_DeityVeeshan: { return DeityVeeshan; } + default: { break; } + }; + + return DeityUnknown; +}; + +static std::string GetDeityName(DeityTypes deity) +{ + switch(deity) + { + case DeityBertoxxulous: { return "Bertoxxulous"; } + case DeityBrellSirilis: { return "Brell Serilis"; } + case DeityCazicThule: { return "Cazic-Thule"; } + case DeityErollisiMarr: { return "Erollisi Marr"; } + case DeityBristlebane: { return "Bristlebane"; } + case DeityInnoruuk: { return "Innoruuk"; } + case DeityKarana: { return "Karana"; } + case DeityMithanielMarr: { return "Mithaniel Marr"; } + case DeityPrexus: { return "Prexus"; } + case DeityQuellious: { return "Quellious"; } + case DeityRallosZek: { return "Rallos Zek"; } + case DeityRodcetNife: { return "Rodcet Nife"; } + case DeitySolusekRo: { return "Solusek Ro"; } + case DeityTheTribunal: { return "The Tribunal"; } + case DeityTunare: { return "Tunare"; } + case DeityVeeshan: { return "Veeshan"; } + case DeityAgnostic_LB: + case DeityAgnostic: { return "Agnostic"; } + default: { break; } + }; + + return "Unknown"; +}; #endif diff --git a/common/eq_constants.h b/common/eq_constants.h index 1c5248461..d612017ad 100644 --- a/common/eq_constants.h +++ b/common/eq_constants.h @@ -27,150 +27,186 @@ */ enum ItemAttributes : uint32 { - ItemAttr_None = 0x00000000, - ItemAttr_Lore = 0x00000001, - ItemAttr_Artifact = 0x00000002, - ItemAttr_Summoned = 0x00000004, - ItemAttr_Magic = 0x00000008, - ItemAttr_Augment = 0x00000010, - ItemAttr_PendingLore = 0x00000020, - ItemAttr_Unknown = 0xFFFFFFFF + ItemAttrNone = 0x00000000, + ItemAttrLore = 0x00000001, + ItemAttrArtifact = 0x00000002, + ItemAttrSummoned = 0x00000004, + ItemAttrMagic = 0x00000008, + ItemAttrAugment = 0x00000010, + ItemAttrPendingLore = 0x00000020, + ItemAttrUnknown = 0xFFFFFFFF }; /* -** Item types +** Item class types ** */ -enum ItemClass +enum ItemClassTypes { - ItemClassCommon = 0, - ItemClassContainer = 1, - ItemClassBook = 2 + ItemClassCommon = 0, + ItemClassContainer, + ItemClassBook, + _ItemClassCount }; /* -** Item uses +** Item use types ** +** (ref: database and eqstr_us.txt) +** +** (Looking at a recent database, it's possible that some of the item values may be off [10-27-2013] -U) */ -enum ItemTypes +enum ItemUseTypes : uint8 { - ItemType1HS = 0, - ItemType2HS = 1, - ItemTypePierce = 2, - ItemType1HB = 3, - ItemType2HB = 4, - ItemTypeBow = 5, - //6 - ItemTypeThrowing = 7, - ItemTypeShield = 8, - //9 - ItemTypeArmor = 10, - ItemTypeUnknon = 11, //A lot of random crap has this item use. - ItemTypeLockPick = 12, - ItemTypeFood = 14, - ItemTypeDrink = 15, - ItemTypeLightSource = 16, - ItemTypeStackable = 17, //Not all stackable items are this use... - ItemTypeBandage = 18, - ItemTypeThrowingv2 = 19, - ItemTypeSpell = 20, //spells and tomes - ItemTypePotion = 21, - ItemTypeWindInstr = 23, - ItemTypeStringInstr = 24, - ItemTypeBrassInstr = 25, - ItemTypeDrumInstr = 26, - ItemTypeArrow = 27, - ItemTypeJewlery = 29, - ItemTypeSkull = 30, - ItemTypeTome = 31, - ItemTypeNote = 32, - ItemTypeKey = 33, - ItemTypeCoin = 34, - ItemType2HPierce = 35, - ItemTypeFishingPole = 36, - ItemTypeFishingBait = 37, - ItemTypeAlcohol = 38, - ItemTypeCompass = 40, - ItemTypePoison = 42, //might be wrong, but includes poisons - ItemTypeHand2Hand = 45, - ItemUseSinging = 50, - ItemUseAllInstruments = 51, - ItemTypeCharm = 52, - ItemTypeAugment = 54, - ItemTypeAugmentSolvent = 55, - ItemTypeAugmentDistill = 56 +/*9138*/ ItemType1HSlash = 0, +/*9141*/ ItemType2HSlash, +/*9140*/ ItemType1HPiercing, +/*9139*/ ItemType1HBlunt, +/*9142*/ ItemType2HBlunt, +/*5504*/ ItemTypeBow, +/*----*/ ItemTypeUnknown1, +/*----*/ ItemTypeLargeThrowing, +/*5505*/ ItemTypeShield, +/*5506*/ ItemTypeScroll, +/*5507*/ ItemTypeArmor, +/*5508*/ ItemTypeMisc, // a lot of random crap has this item use. +/*7564*/ ItemTypeLockPick, +/*----*/ ItemTypeUnknown2, +/*5509*/ ItemTypeFood, +/*5510*/ ItemTypeDrink, +/*5511*/ ItemTypeLight, +/*5512*/ ItemTypeCombinable, // not all stackable items are this use... +/*5513*/ ItemTypeBandage, +/*----*/ ItemTypeSmallThrowing, +/*----*/ ItemTypeSpell, // spells and tomes +/*5514*/ ItemTypePotion, +/*----*/ ItemTypeUnknown3, +/*0406*/ ItemTypeWindInstrument, +/*0407*/ ItemTypeStringedInstrument, +/*0408*/ ItemTypeBrassInstrument, +/*0405*/ ItemTypePercussionInstrument, +/*5515*/ ItemTypeArrow, +/*----*/ ItemTypeUnknown4, +/*5521*/ ItemTypeJewelry, +/*----*/ ItemTypeSkull, +/*5516*/ ItemTypeBook, // skill-up tomes/books? (would probably need a pp flag if true...) +/*5517*/ ItemTypeNote, +/*5518*/ ItemTypeKey, +/*----*/ ItemTypeCoin, +/*5520*/ ItemType2HPiercing, +/*----*/ ItemTypeFishingPole, +/*----*/ ItemTypeFishingBait, +/*5519*/ ItemTypeAlcohol, +/*----*/ ItemTypeKey2, // keys and satchels?? (questable keys?) +/*----*/ ItemTypeCompass, +/*----*/ ItemTypeUnknown5, +/*----*/ ItemTypePoison, // might be wrong, but includes poisons +/*----*/ ItemTypeUnknown6, +/*----*/ ItemTypeUnknown7, +/*5522*/ ItemTypeMartial, +/*----*/ ItemTypeUnknown8, +/*----*/ ItemTypeUnknown9, +/*----*/ ItemTypeUnknown10, +/*----*/ ItemTypeUnknown11, +/*----*/ ItemTypeSinging, +/*5750*/ ItemTypeAllInstrumentTypes, +/*5776*/ ItemTypeCharm, +/*----*/ ItemTypeDye, +/*----*/ ItemTypeAugmentation, +/*----*/ ItemTypeAugmentationSolvent, +/*----*/ ItemTypeAugmentationDistiller, +/*----*/ ItemTypeUnknown12, +/*----*/ ItemTypeFellowshipKit, +/*----*/ ItemTypeUnknown13, +/*----*/ ItemTypeRecipe, +/*----*/ ItemTypeAdvancedRecipe, +/*----*/ ItemTypeJournal, // only one(1) database entry +/*----*/ ItemTypeAltCurrency, // alt-currency (as opposed to coinage) +/*5881*/ ItemTypePerfectedAugmentationDistiller, +/*----*/ _ItemTypeCount + +/* + Unknowns: + + Mounts? + Ornamentations? + GuildBanners? + Collectible? + Placeable? + (others?) +*/ }; /* -** Container types +** Container use types ** ** This correlates to world 'object.type' (object.h/Object.cpp) as well as Item_Struct.BagType ** ** (ref: database, web forums and eqstr_us.txt) */ -enum ContainerTypes : uint8 +enum ContainerUseTypes : uint8 { -/*3400*/ BagType_SmallBag = 0, -/*3401*/ BagType_LargeBag, -/*3402*/ BagType_Quiver, -/*3403*/ BagType_BeltPouch, -/*3404*/ BagType_WristPouch, -/*3405*/ BagType_BackPack, -/*3406*/ BagType_SmallChest, -/*3407*/ BagType_LargeChest, -/*----*/ BagType_Bandolier, // <*Database Reference Only> -/*3408*/ BagType_MedicineBag, -/*3409*/ BagType_ToolBox, -/*3410*/ BagType_Lexicon, -/*3411*/ BagType_Mortar, -/*3412*/ BagType_SelfDusting, // Quest container (Auto-clear contents?) -/*3413*/ BagType_MixingBowl, -/*3414*/ BagType_Oven, -/*3415*/ BagType_SewingKit, -/*3416*/ BagType_Forge, -/*3417*/ BagType_FletchingKit, -/*3418*/ BagType_BrewBarrel, -/*3419*/ BagType_JewelersKit, -/*3420*/ BagType_PotteryWheel, -/*3421*/ BagType_Kiln, -/*3422*/ BagType_Keymaker, // (no database entries as of peq rev 69) -/*3423*/ BagType_WizardsLexicon, -/*3424*/ BagType_MagesLexicon, -/*3425*/ BagType_NecromancersLexicon, -/*3426*/ BagType_EnchantersLexicon, -/*----*/ BagType_Unknown01, // (a coin pouch/purse?) (no database entries as of peq rev 69) -/*----*/ BagType_ConcordanceofResearch, // <*Database Reference Only> -/*3427*/ BagType_AlwaysWorks, // Quest container (Never-fail combines?) -/*3428*/ BagType_KoadaDalForge, // High Elf -/*3429*/ BagType_TeirDalForge, // Dark Elf -/*3430*/ BagType_OggokForge, // Ogre -/*3431*/ BagType_StormguardForge, // Dwarf -/*3432*/ BagType_AkanonForge, // Gnome -/*3433*/ BagType_NorthmanForge, // Barbarian -/*----*/ BagType_Unknown02, // (no database entries as of peq rev 69) -/*3434*/ BagType_CabilisForge, // Iksar -/*3435*/ BagType_FreeportForge, // Human 1 -/*3436*/ BagType_RoyalQeynosForge, // Human 2 -/*3439*/ BagType_HalflingTailoringKit, -/*3438*/ BagType_ErudTailoringKit, -/*3440*/ BagType_FierDalTailoringKit, // Wood Elf -/*3441*/ BagType_FierDalFletchingKit, // Wood Elf -/*3437*/ BagType_IksarPotteryWheel, -/*3442*/ BagType_TackleBox, -/*3443*/ BagType_TrollForge, -/*3445*/ BagType_FierDalForge, // Wood Elf -/*3444*/ BagType_ValeForge, // Halfling -/*3446*/ BagType_ErudForge, -/*----*/ BagType_TradersSatchel, // <*Database Reference Only> (db: Yellow Trader's Satchel Token?) -/*5785*/ BagType_GuktaForge, // Froglok (no database entries as of peq rev 69) -/*3359*/ BagType_AugmentationSealer, -/*----*/ BagType_IceCreamChurn, // <*Database Reference Only> -/*6325*/ BagType_Transformationmold, // Ornamentation -/*6340*/ BagType_Detransformationmold, // Ornamentation Stripper -/*5400*/ BagType_Unattuner, -/*7684*/ BagType_TradeskillBag, -/*7692*/ BagType_CollectibleBag, -/*----*/ BagType_Count +/*3400*/ BagTypeSmallBag = 0, +/*3401*/ BagTypeLargeBag, +/*3402*/ BagTypeQuiver, +/*3403*/ BagTypeBeltPouch, +/*3404*/ BagTypeWristPouch, +/*3405*/ BagTypeBackPack, +/*3406*/ BagTypeSmallChest, +/*3407*/ BagTypeLargeChest, +/*----*/ BagTypeBandolier, // <*Database Reference Only> +/*3408*/ BagTypeMedicineBag, +/*3409*/ BagTypeToolBox, +/*3410*/ BagTypeLexicon, +/*3411*/ BagTypeMortar, +/*3412*/ BagTypeSelfDusting, // Quest container (Auto-clear contents?) +/*3413*/ BagTypeMixingBowl, +/*3414*/ BagTypeOven, +/*3415*/ BagTypeSewingKit, +/*3416*/ BagTypeForge, +/*3417*/ BagTypeFletchingKit, +/*3418*/ BagTypeBrewBarrel, +/*3419*/ BagTypeJewelersKit, +/*3420*/ BagTypePotteryWheel, +/*3421*/ BagTypeKiln, +/*3422*/ BagTypeKeymaker, // (no database entries as of peq rev 69) +/*3423*/ BagTypeWizardsLexicon, +/*3424*/ BagTypeMagesLexicon, +/*3425*/ BagTypeNecromancersLexicon, +/*3426*/ BagTypeEnchantersLexicon, +/*----*/ BagTypeUnknown1, // (a coin pouch/purse?) (no database entries as of peq rev 69) +/*----*/ BagTypeConcordanceofResearch, // <*Database Reference Only> +/*3427*/ BagTypeAlwaysWorks, // Quest container (Never-fail combines?) +/*3428*/ BagTypeKoadaDalForge, // High Elf +/*3429*/ BagTypeTeirDalForge, // Dark Elf +/*3430*/ BagTypeOggokForge, // Ogre +/*3431*/ BagTypeStormguardForge, // Dwarf +/*3432*/ BagTypeAkanonForge, // Gnome +/*3433*/ BagTypeNorthmanForge, // Barbarian +/*----*/ BagTypeUnknown2, // (no database entries as of peq rev 69) +/*3434*/ BagTypeCabilisForge, // Iksar +/*3435*/ BagTypeFreeportForge, // Human 1 +/*3436*/ BagTypeRoyalQeynosForge, // Human 2 +/*3439*/ BagTypeHalflingTailoringKit, +/*3438*/ BagTypeErudTailoringKit, +/*3440*/ BagTypeFierDalTailoringKit, // Wood Elf +/*3441*/ BagTypeFierDalFletchingKit, // Wood Elf +/*3437*/ BagTypeIksarPotteryWheel, +/*3442*/ BagTypeTackleBox, +/*3443*/ BagTypeTrollForge, +/*3445*/ BagTypeFierDalForge, // Wood Elf +/*3444*/ BagTypeValeForge, // Halfling +/*3446*/ BagTypeErudForge, +/*----*/ BagTypeTradersSatchel, // <*Database Reference Only> (db: Yellow Trader's Satchel Token?) +/*5785*/ BagTypeGuktaForge, // Froglok (no database entries as of peq rev 69) +/*3359*/ BagTypeAugmentationSealer, +/*----*/ BagTypeIceCreamChurn, // <*Database Reference Only> +/*6325*/ BagTypeTransformationmold, // Ornamentation +/*6340*/ BagTypeDetransformationmold, // Ornamentation Stripper +/*5400*/ BagTypeUnattuner, +/*7684*/ BagTypeTradeskillBag, +/*7692*/ BagTypeCollectibleBag, +/*----*/ _BagTypeCount }; /* @@ -230,35 +266,6 @@ typedef enum { _eaMaxAppearance } EmuAppearance; -/* -** Diety types -** -** (ref: eqstr_us.txt) -** -** (Another orphaned enumeration...) -*/ -enum DeityTypes -{ -/*----*/ Deity_Unknown = 0, -/*3251*/ Deity_Bertoxxulous = 201, -/*3262*/ Deity_BrellSirilis, -/*3253*/ Deity_CazicThule, -/*3256*/ Deity_ErollisiMarr, -/*3252*/ Deity_Bristlebane, -/*3254*/ Deity_Innoruuk, -/*3255*/ Deity_Karana, -/*3257*/ Deity_MithanielMarr, -/*3259*/ Deity_Prexus, -/*3260*/ Deity_Quellious, -/*3266*/ Deity_RallosZek, -/*3258*/ Deity_RodcetNife, -/*3261*/ Deity_SolusekRo, -/*3263*/ Deity_TheTribunal, -/*3264*/ Deity_Tunare, -/*3265*/ Deity_Veeshan, -/*3250*/ Deity_Agnostic = 396 -}; - // msg_type's for custom usercolors #define MT_Say 256 #define MT_Tell 257 @@ -526,7 +533,8 @@ enum RecastTimerTypes RecTimer_16, RecTimer_17, RecTimer_18, - RecTimer_ModRod // 19 + RecTimer_ModRod, // 19 + _RecTimerCount }; enum GroupUpdateAction @@ -539,101 +547,116 @@ enum GroupUpdateAction GUA_Started = 9 }; -//0x1c is something... -static const uint8 FallingDamageType = 0xFC; -static const uint8 SpellDamageType = 0xe7; -static const uint8 DamageTypeUnknown = 0xFF; +static const uint8 DamageTypeSomething = 0x1C; //0x1c is something... +static const uint8 DamageTypeFalling = 0xFC; +static const uint8 DamageTypeSpell = 0xE7; +static const uint8 DamageTypeUnknown = 0xFF; -//indexed by 'SkillType' -static const uint8 SkillDamageTypes[HIGHEST_SKILL+1] = { - /* _1H_BLUNT */ 0, - /* _1H_SLASHING */ 1, - /* _2H_BLUNT */ 0, - /* _2H_SLASHING */ 1, - /* ABJURE */ SpellDamageType, - /* ALTERATION */ SpellDamageType, - /* APPLY_POISON */ DamageTypeUnknown, - /* ARCHERY */ 7, - /* BACKSTAB */ 8, - /* BIND_WOUND */ DamageTypeUnknown, - /* BASH */ 10, - /* BLOCKSKILL */ DamageTypeUnknown, - /* BRASS_INSTRUMENTS */ SpellDamageType, - /* CHANNELING */ DamageTypeUnknown, - /* CONJURATION */ SpellDamageType, - /* DEFENSE */ DamageTypeUnknown, - /* DISARM */ DamageTypeUnknown, - /* DISARM_TRAPS */ DamageTypeUnknown, - /* DIVINATION */ SpellDamageType, - /* DODGE */ DamageTypeUnknown, - /* DOUBLE_ATTACK */ DamageTypeUnknown, - /* DRAGON_PUNCH */ 21, - /* DUAL_WIELD */ DamageTypeUnknown, - /* EAGLE_STRIKE */ 23, - /* EVOCATION */ SpellDamageType, - /* FEIGN_DEATH */ 4, - /* FLYING_KICK */ 30, - /* FORAGE */ DamageTypeUnknown, - /* HAND_TO_HAND */ 4, - /* HIDE */ DamageTypeUnknown, - /* KICK */ 30, - /* MEDITATE */ DamageTypeUnknown, - /* MEND */ DamageTypeUnknown, - /* OFFENSE */ DamageTypeUnknown, - /* PARRY */ DamageTypeUnknown, - /* PICK_LOCK */ DamageTypeUnknown, - /* PIERCING */ 36, - /* RIPOSTE */ DamageTypeUnknown, - /* ROUND_KICK */ 30, - /* SAFE_FALL */ DamageTypeUnknown, - /* SENSE_HEADING */ DamageTypeUnknown, - /* SINGING */ SpellDamageType, - /* SNEAK */ DamageTypeUnknown, - /* SPECIALIZE_ABJURE */ DamageTypeUnknown, - /* SPECIALIZE_ALTERATION */ DamageTypeUnknown, - /* SPECIALIZE_CONJURATION */ DamageTypeUnknown, - /* SPECIALIZE_DIVINATION */ DamageTypeUnknown, - /* SPECIALIZE_EVOCATION */ DamageTypeUnknown, - /* PICK_POCKETS */ DamageTypeUnknown, - /* STRINGED_INSTRUMENTS */ SpellDamageType, - /* SWIMMING */ DamageTypeUnknown, - /* THROWING */ 51, - /* TIGER_CLAW */ 23, - /* TRACKING */ DamageTypeUnknown, - /* WIND_INSTRUMENTS */ SpellDamageType, - /* FISHING */ DamageTypeUnknown, - /* MAKE_POISON */ DamageTypeUnknown, - /* TINKERING */ DamageTypeUnknown, - /* RESEARCH */ DamageTypeUnknown, - /* ALCHEMY */ DamageTypeUnknown, - /* BAKING */ DamageTypeUnknown, - /* TAILORING */ DamageTypeUnknown, - /* SENSE_TRAPS */ DamageTypeUnknown, - /* BLACKSMITHING */ DamageTypeUnknown, - /* FLETCHING */ DamageTypeUnknown, - /* BREWING */ DamageTypeUnknown, - /* ALCOHOL_TOLERANCE */ DamageTypeUnknown, - /* BEGGING */ DamageTypeUnknown, - /* JEWELRY_MAKING */ DamageTypeUnknown, - /* POTTERY */ DamageTypeUnknown, - /* PERCUSSION_INSTRUMENTS */ SpellDamageType, - /* INTIMIDATION */ DamageTypeUnknown, - /* BERSERKING */ DamageTypeUnknown, - /* TAUNT */ DamageTypeUnknown, - /* FRENZY */ 74 +/* +** Skill damage types +** +** (indexed by 'Skill' of SkillUseTypes) +*/ +static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated +{ +/*1HBlunt*/ 0, +/*1HSlashing*/ 1, +/*2HBlunt*/ 0, +/*2HSlashing*/ 1, +/*Abjuration*/ DamageTypeSpell, +/*Alteration*/ DamageTypeSpell, +/*ApplyPoison*/ DamageTypeUnknown, +/*Archery*/ 7, +/*Backstab*/ 8, +/*BindWound*/ DamageTypeUnknown, +/*Bash*/ 10, +/*Block*/ DamageTypeUnknown, +/*BrassInstruments*/ DamageTypeSpell, +/*Channeling*/ DamageTypeUnknown, +/*Conjuration*/ DamageTypeSpell, +/*Defense*/ DamageTypeUnknown, +/*Disarm*/ DamageTypeUnknown, +/*DisarmTraps*/ DamageTypeUnknown, +/*Divination*/ DamageTypeSpell, +/*Dodge*/ DamageTypeUnknown, +/*DoubleAttack*/ DamageTypeUnknown, +/*DragonPunch*/ 21, +/*DualWield*/ DamageTypeUnknown, +/*EagleStrike*/ 23, +/*Evocation*/ DamageTypeSpell, +/*FeignDeath*/ 4, +/*FlyingKick*/ 30, +/*Forage*/ DamageTypeUnknown, +/*HandtoHand*/ 4, +/*Hide*/ DamageTypeUnknown, +/*Kick*/ 30, +/*Meditate*/ DamageTypeUnknown, +/*Mend*/ DamageTypeUnknown, +/*Offense*/ DamageTypeUnknown, +/*Parry*/ DamageTypeUnknown, +/*PickLock*/ DamageTypeUnknown, +/*1HPiercing*/ 36, +/*Riposte*/ DamageTypeUnknown, +/*RoundKick*/ 30, +/*SafeFall*/ DamageTypeUnknown, +/*SsenseHeading*/ DamageTypeUnknown, +/*Singing*/ DamageTypeSpell, +/*Sneak*/ DamageTypeUnknown, +/*SpecializeAbjure*/ DamageTypeUnknown, +/*SpecializeAlteration*/ DamageTypeUnknown, +/*SpecializeConjuration*/ DamageTypeUnknown, +/*SpecializeDivination*/ DamageTypeUnknown, +/*SpecializeEvocation*/ DamageTypeUnknown, +/*PickPockets*/ DamageTypeUnknown, +/*StringedInstruments*/ DamageTypeSpell, +/*Swimming*/ DamageTypeUnknown, +/*Throwing*/ 51, +/*TigerClaw*/ 23, +/*Tracking*/ DamageTypeUnknown, +/*WindInstruments*/ DamageTypeSpell, +/*Fishing*/ DamageTypeUnknown, +/*MakePoison*/ DamageTypeUnknown, +/*Tinkering*/ DamageTypeUnknown, +/*Research*/ DamageTypeUnknown, +/*Alchemy*/ DamageTypeUnknown, +/*Baking*/ DamageTypeUnknown, +/*Tailoring*/ DamageTypeUnknown, +/*SenseTraps*/ DamageTypeUnknown, +/*Blacksmithing*/ DamageTypeUnknown, +/*Fletching*/ DamageTypeUnknown, +/*Brewing*/ DamageTypeUnknown, +/*AlcoholTolerance*/ DamageTypeUnknown, +/*Begging*/ DamageTypeUnknown, +/*JewelryMaking*/ DamageTypeUnknown, +/*Pottery*/ DamageTypeUnknown, +/*PercussionInstruments*/ DamageTypeSpell, +/*Intimidation*/ DamageTypeUnknown, +/*Berserking*/ DamageTypeUnknown, +/*Taunt*/ DamageTypeUnknown, +/*Frenzy*/ 74 //, +// /*RemoveTrap*/ DamageTypeUnknown, // Needs research (set for SenseTrap value) +// /*TripleAttack*/ DamageTypeUnknown, // Needs research (set for DoubleAttack value) +// /*2HPiercing*/ 36 // Needs research (set for 1HPiercing value - similar to slash/blunt) }; -// Indexing positions into item material arrays -#define MATERIAL_HEAD 0 -#define MATERIAL_CHEST 1 -#define MATERIAL_ARMS 2 -#define MATERIAL_BRACER 3 -#define MATERIAL_HANDS 4 -#define MATERIAL_LEGS 5 -#define MATERIAL_FEET 6 -#define MATERIAL_PRIMARY 7 -#define MATERIAL_SECONDARY 8 -#define MAX_MATERIALS 9 //number of equipables +/* +** Material use slots +** +*/ +enum MaterialUseSlots : uint8 +{ + MaterialHead = 0, + MaterialChest, + MaterialArms, + MaterialWrist, + MaterialHands, + MaterialLegs, + MaterialFeet, + MaterialPrimary, + MaterialSecondary, + _MaterialCount, + _MaterialInvalid = 255 +}; // Used for worn NPC inventory tracking. NPCs don't use // augments, so only the basic slots need to be kept track of. diff --git a/common/eq_packet_structs.h b/common/eq_packet_structs.h index 29c5eb030..758decc45 100644 --- a/common/eq_packet_structs.h +++ b/common/eq_packet_structs.h @@ -270,7 +270,7 @@ struct Spawn_Struct { /*0225*/ uint32 equip_primary; // Equipment: Primary Visual /*0229*/ uint32 equip_secondary; // Equipment: Secondary Visual } equip; - /*0197*/ uint32 equipment[MAX_MATERIALS]; // Array elements correspond to struct equipment above + /*0197*/ uint32 equipment[_MaterialCount]; // Array elements correspond to struct equipment above }; /*0233*/ float runspeed; // Speed when running /*0036*/ uint8 afk; // 0=no, 1=afk @@ -316,7 +316,7 @@ union /*0376*/ Color_Struct color_primary; // Color of primary item /*0380*/ Color_Struct color_secondary; // Color of secondary item } equipment_colors; - /*0348*/ Color_Struct colors[MAX_MATERIALS]; // Array elements correspond to struct equipment_colors above + /*0348*/ Color_Struct colors[_MaterialCount]; // Array elements correspond to struct equipment_colors above }; /*0384*/ uint8 lfg; // 0=off, 1=lfg on /*0385*/ @@ -787,7 +787,7 @@ struct SuspendedMinion_Struct /*002*/ uint32 HP; /*006*/ uint32 Mana; /*010*/ SpellBuff_Struct Buffs[BUFF_COUNT]; - /*510*/ uint32 Items[MAX_MATERIALS]; + /*510*/ uint32 Items[_MaterialCount]; /*546*/ char Name[64]; /*610*/ }; @@ -802,7 +802,7 @@ struct SuspendedMinion_Struct static const uint32 MAX_PP_LANGUAGE = 28; static const uint32 MAX_PP_SPELLBOOK = 480; // Increased to 480 to support SoF static const uint32 MAX_PP_MEMSPELL = 9; -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 240; static const uint32 MAX_GROUP_MEMBERS = 6; static const uint32 MAX_RECAST_TYPES = 20; @@ -892,9 +892,9 @@ struct PlayerProfile_Struct /*0304*/ uint8 ability_time_minutes; /*0305*/ uint8 ability_time_hours; //place holder /*0306*/ uint8 unknown0306[6]; // @bp Spacer/Flag? -/*0312*/ uint32 item_material[MAX_MATERIALS]; // Item texture/material of worn/held items +/*0312*/ uint32 item_material[_MaterialCount]; // Item texture/material of worn/held items /*0348*/ uint8 unknown0348[44]; -/*0392*/ Color_Struct item_tint[MAX_MATERIALS]; +/*0392*/ Color_Struct item_tint[_MaterialCount]; /*0428*/ AA_Array aa_array[MAX_PP_AA_ARRAY]; /*2348*/ float unknown2384; //seen ~128, ~47 /*2352*/ char servername[32]; // length probably not right @@ -940,9 +940,9 @@ struct PlayerProfile_Struct /*4760*/ int32 silver_cursor; // Silver on cursor /*4764*/ int32 copper_cursor; // Copper on cursor /*4768*/ int32 platinum_shared; // Platinum shared between characters -/*4772*/ uint8 unknown4808[24]; // @bp unknown skills? -/*4796*/ uint32 skills[MAX_PP_SKILL]; -/*5096*/ uint8 unknown5132[284]; // @bp unknown skills? +/*4772*/ uint8 unknown4808[24]; +/*4796*/ uint32 skills[MAX_PP_SKILL]; // [400] List of skills // 100 dword buffer +/*5196*/ uint8 unknown5132[184]; /*5380*/ uint32 pvp2; // /*5384*/ uint32 unknown5420; // /*5388*/ uint32 pvptype; // @@ -2013,7 +2013,7 @@ struct Illusion_Struct { //size: 256 - SoF /*092*/ uint32 drakkin_heritage; // /*096*/ uint32 drakkin_tattoo; // /*100*/ uint32 drakkin_details; // -/*104*/ uint32 armor_tint[MAX_MATERIALS]; // +/*104*/ uint32 armor_tint[_MaterialCount]; // /*140*/ uint8 eyecolor1; // Field Not Identified in any Illusion Struct /*141*/ uint8 eyecolor2; // Field Not Identified in any Illusion Struct /*142*/ uint8 unknown138[114]; // @@ -3257,7 +3257,7 @@ struct DyeStruct struct Color_Struct secondary; // or this } dyes; - struct Color_Struct dye[MAX_MATERIALS]; + struct Color_Struct dye[_MaterialCount]; }; }; diff --git a/common/eqtime.cpp b/common/eqtime.cpp index f052a7e2d..7e1eb9f5d 100644 --- a/common/eqtime.cpp +++ b/common/eqtime.cpp @@ -144,7 +144,7 @@ bool EQTime::saveFile(const char *filename) return false; } //Enable for debugging - //cout << "SAVE: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << endl; + //std::cout << "SAVE: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl; of << EQT_VERSION << std::endl; of << (long)eqTime.start_eqtime.day << std::endl; of << (long)eqTime.start_eqtime.hour << std::endl; @@ -194,7 +194,7 @@ bool EQTime::loadFile(const char *filename) in.ignore(80, '\n'); in >> eqTime.start_realtime; //Enable for debugging... - //cout << "LOAD: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << endl; + //std::cout << "LOAD: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl; in.close(); return true; } diff --git a/common/extprofile.h b/common/extprofile.h index 74e9a89c3..114983444 100644 --- a/common/extprofile.h +++ b/common/extprofile.h @@ -41,7 +41,7 @@ struct ExtendedProfile_Struct { uint16 old_pet_hp; uint16 old_pet_mana; SpellBuff_Struct pet_buffs[BUFF_COUNT]; - uint32 pet_items[MAX_MATERIALS]; + uint32 pet_items[_MaterialCount]; char merc_name[64]; uint32 aa_effects; diff --git a/common/linked_list.h b/common/linked_list.h index fe8755d40..246677db4 100644 --- a/common/linked_list.h +++ b/common/linked_list.h @@ -337,7 +337,7 @@ ListElement::ListElement(const TYPE& d) template ListElement::~ListElement() { -// cout << "ListElement::~ListElement()" << endl; +// std::cout << "ListElement::~ListElement()" << std::endl; if (data != 0) safe_delete(data); diff --git a/common/packet_dump.cpp b/common/packet_dump.cpp index ec8d94024..a9c70b493 100644 --- a/common/packet_dump.cpp +++ b/common/packet_dump.cpp @@ -78,7 +78,7 @@ void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) { else { ascii[j++] = '.'; } -// cout << setfill(0) << setw(2) << hex << (int)buf[i] << " "; +// std::cout << std::setfill(0) << std::setw(2) << std::hex << (int)buf[i] << " "; // unknown intent [CODEBUG] } uint32 k = ((i-skip)-1)%cols; if (k < 8) diff --git a/common/packet_dump_file.cpp b/common/packet_dump_file.cpp index ed0269283..8e0e3c274 100644 --- a/common/packet_dump_file.cpp +++ b/common/packet_dump_file.cpp @@ -80,7 +80,7 @@ void oldFileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, u } sprintf(output, "%02X ",(unsigned char)buf[i]); logfile << output; -// logfile << setfill(0) << setw(2) << hex << (int)buf[i] << " "; + //logfile << std::setfill(0) << std::setw(2) << std::hex << (int)buf[i] << " "; // unknown intent [CODEBUG] } logfile << std::endl << std::endl; } @@ -115,7 +115,7 @@ void FileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, uint else { ascii[j++] = '.'; } -// logfile << setfill(0) << setw(2) << hex << (int)buf[i] << " "; + //logfile << std::setfill(0) << std::setw(2) << std::hex << (int)buf[i] << " "; // unknown intent [CODEBUG] } uint32 k = ((i-skip)-1)%cols; if (k < 8) diff --git a/common/patches/Client62.cpp b/common/patches/Client62.cpp index ad6276648..ae8eb7e42 100644 --- a/common/patches/Client62.cpp +++ b/common/patches/Client62.cpp @@ -265,7 +265,9 @@ ENCODE(OP_PlayerProfile) { OUT(gold_cursor); OUT(silver_cursor); OUT(copper_cursor); - OUT_array(skills, structs::MAX_PP_SKILL); + + OUT_array(skills, structs::MAX_PP_SKILL); // 1:1 direct copy (100 dword) + OUT(toxicity); OUT(thirst_level); OUT(hunger_level); diff --git a/common/patches/Client62_structs.h b/common/patches/Client62_structs.h index c03777610..ded2078b1 100644 --- a/common/patches/Client62_structs.h +++ b/common/patches/Client62_structs.h @@ -626,7 +626,7 @@ struct RaidLeadershipAA_Struct { static const uint32 MAX_PP_LANGUAGE = 28; static const uint32 MAX_PP_SPELLBOOK = 400; static const uint32 MAX_PP_MEMSPELL = 9; -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 240; static const uint32 MAX_GROUP_MEMBERS = 6; struct PlayerProfile_Struct @@ -722,9 +722,9 @@ struct PlayerProfile_Struct /*4760*/ int32 silver_cursor; // Silver on cursor /*4764*/ int32 copper_cursor; // Copper on cursor /*4768*/ int32 platinum_shared; // Platinum shared between characters -/*4772*/ uint8 unknown3812[24]; // @bp unknown skills? -/*4796*/ uint32 skills[MAX_PP_SKILL]; -/*5096*/ uint8 unknown5096[284]; // @bp unknown skills? +/*4772*/ uint8 unknown3812[24]; +/*4796*/ uint32 skills[MAX_PP_SKILL]; // 100 dword buffer +/*5196*/ uint8 unknown5096[184]; /*5380*/ uint32 pvp2; // /*5384*/ uint32 unknown4420; // /*5388*/ uint32 pvptype; // diff --git a/common/patches/RoF.cpp b/common/patches/RoF.cpp index fbfbcc94b..3577fb6f3 100644 --- a/common/patches/RoF.cpp +++ b/common/patches/RoF.cpp @@ -717,7 +717,7 @@ ENCODE(OP_SendCharInfo) { eq2->gender = emu->gender[r]; eq2->face = emu->face[r]; int k; - for(k = 0; k < MAX_MATERIALS; k++) { + for(k = 0; k < _MaterialCount; k++) { eq2->equip[k].equip0 = emu->equip[r][k]; eq2->equip[k].equip1 = 0; eq2->equip[k].equip2 = 0; @@ -1020,16 +1020,19 @@ ENCODE(OP_PlayerProfile) outapp->WriteUInt32(structs::MAX_PP_SKILL); - for(uint32 r = 0; r < MAX_PP_SKILL; r++) + for(uint32 r = 0; r < structs::MAX_PP_SKILL; r++) { outapp->WriteUInt32(emu->skills[r]); } + // deprecated // Write zeroes for the rest of the skills + /* for(uint32 r = 0; r < structs::MAX_PP_SKILL - MAX_PP_SKILL; r++) { outapp->WriteUInt32(emu->skills[r]); } + */ outapp->WriteUInt32(25); // Unknown count @@ -2015,13 +2018,13 @@ ENCODE(OP_ZoneSpawns) VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_PRIMARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialPrimary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_SECONDARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialSecondary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); diff --git a/common/patches/RoF_structs.h b/common/patches/RoF_structs.h index 194bbdad0..cf8f1e804 100644 --- a/common/patches/RoF_structs.h +++ b/common/patches/RoF_structs.h @@ -112,7 +112,7 @@ static const uint32 MAX_NUMBER_GUILDS = 1500; static const uint32 MAX_PP_LANGUAGE = 32; // was 25 static const uint32 MAX_PP_SPELLBOOK = 720; // was 480 static const uint32 MAX_PP_MEMSPELL = 16; // was 12 -static const uint32 MAX_PP_SKILL = 100; // was 75 +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 300; static const uint32 MAX_PP_DISCIPLINES = 200; // was 100 static const uint32 MAX_GROUP_MEMBERS = 6; diff --git a/common/patches/SoD.cpp b/common/patches/SoD.cpp index 517479b48..cadd4b8a8 100644 --- a/common/patches/SoD.cpp +++ b/common/patches/SoD.cpp @@ -335,7 +335,7 @@ ENCODE(OP_SendCharInfo) { eq2->haircolor = emu->haircolor[r]; eq2->face = emu->face[r]; int k; - for(k = 0; k < MAX_MATERIALS; k++) { + for(k = 0; k < _MaterialCount; k++) { eq2->equip[k].equip0 = emu->equip[r][k]; eq2->equip[k].equip1 = 0; eq2->equip[k].itemid = 0; @@ -535,7 +535,9 @@ ENCODE(OP_PlayerProfile) { OUT(gold_cursor); OUT(silver_cursor); OUT(copper_cursor); - OUT_array(skills, structs::MAX_PP_SKILL); + + OUT_array(skills, structs::MAX_PP_SKILL); // 1:1 direct copy (100 dword) + // OUT(unknown04760[236]); OUT(toxicity); OUT(thirst_level); @@ -1216,11 +1218,11 @@ ENCODE(OP_ZoneSpawns) { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_PRIMARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialPrimary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_SECONDARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialSecondary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); } diff --git a/common/patches/SoD_structs.h b/common/patches/SoD_structs.h index 2f1dcd990..685e8f77f 100644 --- a/common/patches/SoD_structs.h +++ b/common/patches/SoD_structs.h @@ -740,7 +740,7 @@ struct BindStruct { static const uint32 MAX_PP_LANGUAGE = 25; // static const uint32 MAX_PP_SPELLBOOK = 480; // Confirmed 60 pages on Live now static const uint32 MAX_PP_MEMSPELL = 10; //was 9 now 10 on Live -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 300; //was 299 static const uint32 MAX_GROUP_MEMBERS = 6; static const uint32 MAX_RECAST_TYPES = 20; @@ -860,8 +860,8 @@ struct PlayerProfile_Struct /*06484*/ uint32 gold_cursor; // Gold Pieces on cursor /*06488*/ uint32 silver_cursor; // Silver Pieces on cursor /*06492*/ uint32 copper_cursor; // Copper Pieces on cursor -/*06496*/ uint32 skills[MAX_PP_SKILL]; // [300] List of skills -/*06796*/ uint8 unknown04760[236]; +/*06496*/ uint32 skills[MAX_PP_SKILL]; // [400] List of skills // 100 dword buffer +/*06896*/ uint8 unknown04760[136]; /*07032*/ uint32 toxicity; // Potion Toxicity (15=too toxic, each potion adds 3) /*07036*/ uint32 thirst_level; // Drink (ticks till next drink) /*07040*/ uint32 hunger_level; // Food (ticks till next eat) diff --git a/common/patches/SoF.cpp b/common/patches/SoF.cpp index b7e1dac2f..0262858d5 100644 --- a/common/patches/SoF.cpp +++ b/common/patches/SoF.cpp @@ -334,7 +334,7 @@ ENCODE(OP_SendCharInfo) { eq2->haircolor = emu->haircolor[r]; eq2->face = emu->face[r]; int k; - for(k = 0; k < MAX_MATERIALS; k++) { + for(k = 0; k < _MaterialCount; k++) { eq2->equip[k].equip0 = emu->equip[r][k]; eq2->equip[k].equip1 = 0; eq2->equip[k].itemid = 0; @@ -534,7 +534,9 @@ ENCODE(OP_PlayerProfile) { OUT(gold_cursor); OUT(silver_cursor); OUT(copper_cursor); - OUT_array(skills, structs::MAX_PP_SKILL); + + OUT_array(skills, structs::MAX_PP_SKILL); // 1:1 direct copy (100 dword) + // OUT(unknown04760[236]); OUT(toxicity); OUT(thirst_level); diff --git a/common/patches/SoF_structs.h b/common/patches/SoF_structs.h index 7a778767d..3f9b6af8f 100644 --- a/common/patches/SoF_structs.h +++ b/common/patches/SoF_structs.h @@ -718,7 +718,7 @@ struct BindStruct { static const uint32 MAX_PP_LANGUAGE = 25; // static const uint32 MAX_PP_SPELLBOOK = 480; // Confirmed 60 pages on Live now static const uint32 MAX_PP_MEMSPELL = 10; //was 9 now 10 on Live -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 300; //was 299 static const uint32 MAX_GROUP_MEMBERS = 6; static const uint32 MAX_RECAST_TYPES = 20; @@ -837,8 +837,8 @@ struct PlayerProfile_Struct //23576 Octets /*06484*/ uint32 gold_cursor; // Gold Pieces on cursor /*06488*/ uint32 silver_cursor; // Silver Pieces on cursor /*06492*/ uint32 copper_cursor; // Copper Pieces on cursor -/*06496*/ uint32 skills[MAX_PP_SKILL]; // [300] List of skills -/*06796*/ uint8 unknown04760[236]; +/*06496*/ uint32 skills[MAX_PP_SKILL]; // [400] List of skills // 100 dword buffer +/*06896*/ uint8 unknown04760[136]; /*07032*/ uint32 toxicity; // Potion Toxicity (15=too toxic, each potion adds 3) /*07036*/ uint32 thirst_level; // Drink (ticks till next drink) /*07040*/ uint32 hunger_level; // Food (ticks till next eat) diff --git a/common/patches/Titanium.cpp b/common/patches/Titanium.cpp index 7def0b246..2f0e6a607 100644 --- a/common/patches/Titanium.cpp +++ b/common/patches/Titanium.cpp @@ -269,7 +269,9 @@ ENCODE(OP_PlayerProfile) { OUT(gold_cursor); OUT(silver_cursor); OUT(copper_cursor); - OUT_array(skills, structs::MAX_PP_SKILL); + + OUT_array(skills, structs::MAX_PP_SKILL); // 1:1 direct copy (100 dword) + // OUT(unknown04760[236]); OUT(toxicity); OUT(thirst_level); diff --git a/common/patches/Titanium_structs.h b/common/patches/Titanium_structs.h index cdd7fccf8..0298ca630 100644 --- a/common/patches/Titanium_structs.h +++ b/common/patches/Titanium_structs.h @@ -648,7 +648,7 @@ struct BindStruct { static const uint32 MAX_PP_LANGUAGE = 28; static const uint32 MAX_PP_SPELLBOOK = 400; static const uint32 MAX_PP_MEMSPELL = 9; -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 240; static const uint32 MAX_GROUP_MEMBERS = 6; static const uint32 MAX_RECAST_TYPES = 20; @@ -752,8 +752,8 @@ struct PlayerProfile_Struct /*04448*/ uint32 gold_cursor; // Gold Pieces on cursor /*04452*/ uint32 silver_cursor; // Silver Pieces on cursor /*04456*/ uint32 copper_cursor; // Copper Pieces on cursor -/*04460*/ uint32 skills[MAX_PP_SKILL]; // List of skills -/*04760*/ uint8 unknown04760[236]; +/*04460*/ uint32 skills[MAX_PP_SKILL]; // [400] List of skills // 100 dword buffer +/*04860*/ uint8 unknown04760[136]; /*04996*/ uint32 toxicity; // Potion Toxicity (15=too toxic, each potion adds 3) /*05000*/ uint32 thirst_level; // Drink (ticks till next drink) /*05004*/ uint32 hunger_level; // Food (ticks till next eat) diff --git a/common/patches/Underfoot.cpp b/common/patches/Underfoot.cpp index ddfe24347..0a17ef9e6 100644 --- a/common/patches/Underfoot.cpp +++ b/common/patches/Underfoot.cpp @@ -336,7 +336,7 @@ ENCODE(OP_SendCharInfo) { eq2->haircolor = emu->haircolor[r]; eq2->face = emu->face[r]; int k; - for(k = 0; k < MAX_MATERIALS; k++) { + for(k = 0; k < _MaterialCount; k++) { eq2->equip[k].equip0 = emu->equip[r][k]; eq2->equip[k].equip1 = 0; eq2->equip[k].itemid = 0; @@ -549,7 +549,9 @@ ENCODE(OP_PlayerProfile) { OUT(gold_cursor); OUT(silver_cursor); OUT(copper_cursor); - OUT_array(skills, structs::MAX_PP_SKILL); + + OUT_array(skills, structs::MAX_PP_SKILL); // 1:1 direct copy (100 dword) + // OUT(unknown04760[236]); OUT(toxicity); OUT(thirst_level); @@ -1228,11 +1230,11 @@ ENCODE(OP_ZoneSpawns) { VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_PRIMARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialPrimary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); - VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MATERIAL_SECONDARY]); + VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment[MaterialSecondary]); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); VARSTRUCT_ENCODE_TYPE(uint32, Buffer, 0); } diff --git a/common/patches/Underfoot_structs.h b/common/patches/Underfoot_structs.h index daa4a0533..07d3660a3 100644 --- a/common/patches/Underfoot_structs.h +++ b/common/patches/Underfoot_structs.h @@ -764,7 +764,7 @@ struct BindStruct { static const uint32 MAX_PP_LANGUAGE = 25; // static const uint32 MAX_PP_SPELLBOOK = 480; // Confirmed 60 pages on Underfoot now static const uint32 MAX_PP_MEMSPELL = 10; //was 9 now 10 on Underfoot -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = _SkillPacketArraySize; // 100 - actual skills buffer size static const uint32 MAX_PP_AA_ARRAY = 300; //was 299 static const uint32 MAX_GROUP_MEMBERS = 6; static const uint32 MAX_RECAST_TYPES = 20; @@ -886,8 +886,8 @@ struct PlayerProfile_Struct /*07332*/ uint32 gold_cursor; // Gold Pieces on cursor /*07336*/ uint32 silver_cursor; // Silver Pieces on cursor /*07340*/ uint32 copper_cursor; // Copper Pieces on cursor -/*07344*/ uint32 skills[MAX_PP_SKILL]; // [300] List of skills -/*07644*/ uint8 unknown07644[236]; +/*07344*/ uint32 skills[MAX_PP_SKILL]; // [400] List of skills // 100 dword buffer +/*07744*/ uint8 unknown07644[136]; /*07880*/ uint32 toxicity; // Potion Toxicity (15=too toxic, each potion adds 3) /*07884*/ uint32 thirst_level; // Drink (ticks till next drink) /*07888*/ uint32 hunger_level; // Food (ticks till next eat) diff --git a/common/seperator.h b/common/seperator.h index f6438fe5d..2524748d9 100644 --- a/common/seperator.h +++ b/common/seperator.h @@ -57,7 +57,7 @@ public: return; for (i=0; i HIGHEST_SKILL) - sp[tempid].skill = BEGGING; /* not much better we can do. */ + sp[tempid].skill = SkillBegging; /* not much better we can do. */ // can probably be changed to client-based 'SkillNone' once activated else - sp[tempid].skill = (SkillType) tmp_skill; + sp[tempid].skill = (SkillUseTypes) tmp_skill; sp[tempid].zonetype=atoi(row[101]); sp[tempid].EnvironmentType=atoi(row[102]); sp[tempid].TimeOfDay=atoi(row[103]); diff --git a/common/shareddb.h b/common/shareddb.h index ab7a1fce7..05c3db6ef 100644 --- a/common/shareddb.h +++ b/common/shareddb.h @@ -104,8 +104,8 @@ public: void LoadSkillCaps(void *data); bool LoadSkillCaps(); - uint16 GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level); - uint8 GetTrainLevel(uint8 Class_, SkillType Skill, uint8 Level); + uint16 GetSkillCap(uint8 Class_, SkillUseTypes Skill, uint8 Level); + uint8 GetTrainLevel(uint8 Class_, SkillUseTypes Skill, uint8 Level); int GetMaxSpellID(); void LoadSpells(void *data, int max_spells); diff --git a/common/skills.h b/common/skills.h index 0b0c6e025..c6df0091b 100644 --- a/common/skills.h +++ b/common/skills.h @@ -18,7 +18,165 @@ #ifndef SKILLS_H #define SKILLS_H -// Correct Skill Numbers as of 4-14-2002 +/* +** This is really messed up... Are we using SkillTypes as a pseudo repository? The 76th skill really throws +** things for standardization... +** +** Below is an attempt to clean this up a little... +*/ + +/* +** Skill use types +** +** (ref: eqstr_us.txt [05-10-2013]) +*/ +enum SkillUseTypes : uint32 +{ +/*13855*/ Skill1HBlunt = 0, +/*13856*/ Skill1HSlashing, +/*13857*/ Skill2HBlunt, +/*13858*/ Skill2HSlashing, +/*13859*/ SkillAbjuration, +/*13861*/ SkillAlteration, +/*13862*/ SkillApplyPoison, +/*13863*/ SkillArchery, +/*13864*/ SkillBackstab, +/*13866*/ SkillBindWound, +/*13867*/ SkillBash, +/*13871*/ SkillBlock, +/*13872*/ SkillBrassInstruments, +/*13874*/ SkillChanneling, +/*13875*/ SkillConjuration, +/*13876*/ SkillDefense, +/*13877*/ SkillDisarm, +/*13878*/ SkillDisarmTraps, +/*13879*/ SkillDivination, +/*13880*/ SkillDodge, +/*13881*/ SkillDoubleAttack, +/*13882*/ SkillDragonPunch, /*13924 SkillTailRake*/ +/*13883*/ SkillDualWield, +/*13884*/ SkillEagleStrike, +/*13885*/ SkillEvocation, +/*13886*/ SkillFeignDeath, +/*13888*/ SkillFlyingKick, +/*13889*/ SkillForage, +/*13890*/ SkillHandtoHand, +/*13891*/ SkillHide, +/*13893*/ SkillKick, +/*13894*/ SkillMeditate, +/*13895*/ SkillMend, +/*13896*/ SkillOffense, +/*13897*/ SkillParry, +/*13899*/ SkillPickLock, +/*13900*/ Skill1HPiercing, // Changed in RoF2(05-10-2013) +/*13903*/ SkillRiposte, +/*13904*/ SkillRoundKick, +/*13905*/ SkillSafeFall, +/*13906*/ SkillSenseHeading, +/*13908*/ SkillSinging, +/*13909*/ SkillSneak, +/*13910*/ SkillSpecializeAbjure, // No idea why they truncated this one..especially when there are longer ones... +/*13911*/ SkillSpecializeAlteration, +/*13912*/ SkillSpecializeConjuration, +/*13913*/ SkillSpecializeDivination, +/*13914*/ SkillSpecializeEvocation, +/*13915*/ SkillPickPockets, +/*13916*/ SkillStringedInstruments, +/*13917*/ SkillSwimming, +/*13919*/ SkillThrowing, +/*13920*/ SkillTigerClaw, +/*13921*/ SkillTracking, +/*13923*/ SkillWindInstruments, +/*13854*/ SkillFishing, +/*13853*/ SkillMakePoison, +/*13852*/ SkillTinkering, +/*13851*/ SkillResearch, +/*13850*/ SkillAlchemy, +/*13865*/ SkillBaking, +/*13918*/ SkillTailoring, +/*13907*/ SkillSenseTraps, +/*13870*/ SkillBlacksmithing, +/*13887*/ SkillFletching, +/*13873*/ SkillBrewing, +/*13860*/ SkillAlcoholTolerance, +/*13868*/ SkillBegging, +/*13892*/ SkillJewelryMaking, +/*13901*/ SkillPottery, +/*13898*/ SkillPercussionInstruments, +/*13922*/ SkillIntimidation, +/*13869*/ SkillBerserking, +/*13902*/ SkillTaunt, +/*05837*/ SkillFrenzy, // This appears to be the only listed one not grouped with the others + +// SoF+ specific skills +// /*03670*/ SkillRemoveTraps, +// /*13049*/ SkillTripleAttack, + +// RoF2+ specific skills +// /*00789*/ Skill2HPiercing, +// /*01216*/ SkillNone, // This needs to move down as new skills are added + +// Skill Counts +// /*-----*/ _SkillCount_62 = 75, // use for Ti and earlier max skill checks +// /*-----*/ _SkillCount_SoF = 77, // use for SoF thru RoF1 max skill checks +// /*-----*/ _SkillCount_RoF2 = 78, // use for RoF2 max skill checks + +// Support values +// /*-----*/ _SkillServerArraySize = _SkillCount_RoF2, // Should reflect last client '_SkillCount' +/*-----*/ _SkillPacketArraySize = 100, // Currently supported clients appear to iterate full 100 dword buffer range + +// Superfluous additions to SkillUseTypes..server-use only +// /*-----*/ ExtSkillGenericTradeskill = 100 + +/* ([EQClientVersion] [0] - Unknown, [3] - SoF, [7] - RoF2[05-10-2013]) + [Skill] [index] | [0] [1] [2] [3] [4] [5] [6] [7] + Frenzy (05837) | --- 074 074 074 074 074 074 074 + Remove Traps (03670) | --- --- --- 075 075 075 075 075 + Triple Attack (13049) | --- --- --- 076 076 076 076 076 + 2H Piercing (00789) | --- --- --- --- --- --- --- 077 +*/ + +/* + [SkillCaps.txt] (SoF+) + a^b^c^d(^e) (^e is RoF+, but cursory glance appears to be all zeros) + + a - Class + b - Skill + c - Level + d - Max Value + (e - Unknown) +*/ + +/* + NOTE: Disregard this until it is sorted out + + I changed (tradeskill==75) to ExtSkillGenericTradeskill in tradeskills.cpp for both instances. If it's a pseudo-enumeration of + an AA ability, then use the 'ExtSkill' ('ExtentedSkill') prefix with a value >= 100. (current implementation) + + We probably need to recode ALL of the skill checks to use the new Skill2HPiercing and ensure that the animation value is + properly changed in the patch files. As far as earlier clients using this new skill, it can be done, but we just need to ensure + that skill address is not inadvertently passed to the client..and we can just send an actual message for the skill-up. Use of a + command can tell the player what that particular skill value is. + + Nothing on SkillTripleAttack just yet..haven't looked into its current implementation. + + In addition to the above re-coding, we're probably going to need to rework the database pp blob to reserve space for the current + 100-dword buffer allocation. This way, we can just add new ones without having to rework it each time. + + -U +*/ +}; + +// temporary until it can be sorted out... +#define HIGHEST_SKILL SkillFrenzy + +// TODO: add string return for skill names + +/* +** Old typedef enumeration +** +*/ +/* Correct Skill Numbers as of 4-14-2002 typedef enum { _1H_BLUNT = 0, _1H_SLASHING = 1, @@ -99,6 +257,6 @@ typedef enum { } SkillType; #define HIGHEST_SKILL FRENZY +*/ #endif - diff --git a/common/spdat.h b/common/spdat.h index 27dfb4ef2..225dbf0f1 100644 --- a/common/spdat.h +++ b/common/spdat.h @@ -641,7 +641,7 @@ struct SPDat_Spell_Struct /* 086 */ int effectid[EFFECT_COUNT]; // Spell's effects /* 098 */ SpellTargetType targettype; // Spell's Target /* 099 */ int basediff; // base difficulty fizzle adjustment -/* 100 */ SkillType skill; +/* 100 */ SkillUseTypes skill; /* 101 */ int8 zonetype; // 01=Outdoors, 02=dungeons, ff=Any /* 102 */ int8 EnvironmentType; /* 103 */ int8 TimeOfDay; diff --git a/utils/player_profile_set/player_profile_set/eq_player_structs.h b/utils/player_profile_set/player_profile_set/eq_player_structs.h index 7b4137dc8..e732757a4 100644 --- a/utils/player_profile_set/player_profile_set/eq_player_structs.h +++ b/utils/player_profile_set/player_profile_set/eq_player_structs.h @@ -738,7 +738,7 @@ struct BindStruct { static const uint32 MAX_PP_LANGUAGE = 28; static const uint32 MAX_PP_SPELLBOOK = 400; static const uint32 MAX_PP_MEMSPELL = 9; -static const uint32 MAX_PP_SKILL = 75; +static const uint32 MAX_PP_SKILL = 100; static const uint32 MAX_PP_AA_ARRAY = 240; static const uint32 MAX_GROUP_MEMBERS = 6; @@ -878,7 +878,7 @@ struct PlayerProfile_Struct /*4768*/ sint32 platinum_shared; // Platinum shared between characters /*4772*/ uint8 unknown3812[24]; // @bp unknown skills? /*4796*/ uint32 skills[MAX_PP_SKILL]; -/*5096*/ uint8 unknown5096[284]; // @bp unknown skills? +/*5196*/ uint8 unknown5096[184]; // @bp unknown skills? /*5380*/ int32 pvp2; // /*5384*/ int32 unknown4420; // /*5388*/ int32 pvptype; // diff --git a/utils/sql/git/required/2013_10_31_Recipe_disabling.sql b/utils/sql/git/required/2013_10_31_Recipe_disabling.sql new file mode 100644 index 000000000..14bd7d7ff --- /dev/null +++ b/utils/sql/git/required/2013_10_31_Recipe_disabling.sql @@ -0,0 +1 @@ +ALTER TABLE `tradeskill_recipe` ADD `enabled` tinyint(1) NOT NULL DEFAULT '1'; diff --git a/world/client.cpp b/world/client.cpp index da213ef92..fd45567c6 100644 --- a/world/client.cpp +++ b/world/client.cpp @@ -1446,7 +1446,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc) SetRacialLanguages( &pp ); // bUsh SetRaceStartingSkills( &pp ); // bUsh SetClassStartingSkills( &pp ); // bUsh - pp.skills[SENSE_HEADING] = 200; + pp.skills[SkillSenseHeading] = 200; // Some one fucking fix this to use a field name. -Doodman //pp.unknown3596[28] = 15; // @bp: This is to enable disc usage // strcpy(pp.servername, WorldConfig::get()->ShortName.c_str()); @@ -1835,26 +1835,26 @@ void Client::SetClassStartingSkills( PlayerProfile_Struct *pp ) { for(uint32 i = 0; i <= HIGHEST_SKILL; ++i) { if(pp->skills[i] == 0) { - if(i >= SPECIALIZE_ABJURE && i <= SPECIALIZE_EVOCATION) { + if(i >= SkillSpecializeAbjure && i <= SkillSpecializeEvocation) { continue; } - if(i == MAKE_POISON || - i == TINKERING || - i == RESEARCH || - i == ALCHEMY || - i == BAKING || - i == TAILORING || - i == BLACKSMITHING || - i == FLETCHING || - i == BREWING || - i == POTTERY || - i == JEWELRY_MAKING || - i == BEGGING) { + if(i == SkillMakePoison || + i == SkillTinkering || + i == SkillResearch || + i == SkillAlchemy || + i == SkillBaking || + i == SkillTailoring || + i == SkillBlacksmithing || + i == SkillFletching || + i == SkillBrewing || + i == SkillPottery || + i == SkillJewelryMaking || + i == SkillBegging) { continue; } - pp->skills[i] = database.GetSkillCap(pp->class_, (SkillType)i, 1); + pp->skills[i] = database.GetSkillCap(pp->class_, (SkillUseTypes)i, 1); } } } @@ -1878,41 +1878,41 @@ void Client::SetRaceStartingSkills( PlayerProfile_Struct *pp ) } case DARK_ELF: { - pp->skills[HIDE] = 50; + pp->skills[SkillHide] = 50; break; } case FROGLOK: { - pp->skills[SWIMMING] = 125; + pp->skills[SkillSwimming] = 125; break; } case GNOME: { - pp->skills[TINKERING] = 50; + pp->skills[SkillTinkering] = 50; break; } case HALFLING: { - pp->skills[HIDE] = 50; - pp->skills[SNEAK] = 50; + pp->skills[SkillHide] = 50; + pp->skills[SkillSneak] = 50; break; } case IKSAR: { - pp->skills[FORAGE] = 50; - pp->skills[SWIMMING] = 100; + pp->skills[SkillForage] = 50; + pp->skills[SkillSwimming] = 100; break; } case WOOD_ELF: { - pp->skills[FORAGE] = 50; - pp->skills[HIDE] = 50; + pp->skills[SkillForage] = 50; + pp->skills[SkillHide] = 50; break; } case VAHSHIR: { - pp->skills[SAFE_FALL] = 50; - pp->skills[SNEAK] = 50; + pp->skills[SkillSafeFall] = 50; + pp->skills[SkillSneak] = 50; break; } } diff --git a/world/worlddb.cpp b/world/worlddb.cpp index 9099060ee..ab8f6099a 100644 --- a/world/worlddb.cpp +++ b/world/worlddb.cpp @@ -197,11 +197,11 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct* cs->cs_colors[char_num][material].color = color; // the weapons are kept elsewhere - if ((material==MATERIAL_PRIMARY) || (material==MATERIAL_SECONDARY)) + if ((material==MaterialPrimary) || (material==MaterialSecondary)) { if(strlen(item->GetItem()->IDFile) > 2) { uint32 idfile=atoi(&item->GetItem()->IDFile[2]); - if (material==MATERIAL_PRIMARY) + if (material==MaterialPrimary) cs->primary[char_num]=idfile; else cs->secondary[char_num]=idfile; diff --git a/zone/AA.cpp b/zone/AA.cpp index 71af74de0..171f397d3 100644 --- a/zone/AA.cpp +++ b/zone/AA.cpp @@ -432,7 +432,7 @@ void Client::HandleAAAction(aaID activate) { int curhp = GetTarget()->GetHP(); target = aaTargetCurrent; GetTarget()->HealDamage(curhp, this); - Death(this, 0, SPELL_UNKNOWN, HAND_TO_HAND); + Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand); } break; diff --git a/zone/MobAI.cpp b/zone/MobAI.cpp index 773c720aa..7840444c0 100644 --- a/zone/MobAI.cpp +++ b/zone/MobAI.cpp @@ -846,9 +846,9 @@ void Client::AI_Process() if (ExtraAttackChanceBonus && GetTarget()) { ItemInst *wpn = GetInv().GetItem(SLOT_PRIMARY); if(wpn){ - if(wpn->GetItem()->ItemType == ItemType2HS || - wpn->GetItem()->ItemType == ItemType2HB || - wpn->GetItem()->ItemType == ItemType2HPierce ) + if(wpn->GetItem()->ItemType == ItemType2HSlash || + wpn->GetItem()->ItemType == ItemType2HBlunt || + wpn->GetItem()->ItemType == ItemType2HPiercing ) { if(MakeRandomInt(0, 100) < ExtraAttackChanceBonus) { @@ -885,7 +885,7 @@ void Client::AI_Process() float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -1312,8 +1312,8 @@ void Mob::AI_Process() { { int myclass = GetClass(); //can only dual wield without a weapon if your a monk - if(GetSpecialAbility(SPECATK_INNATE_DW) || (GetEquipment(MATERIAL_SECONDARY) != 0 && GetLevel() > 29) || myclass == MONK || myclass == MONKGM) { - float DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel()) / 400.0f; + if(GetSpecialAbility(SPECATK_INNATE_DW) || (GetEquipment(MaterialSecondary) != 0 && GetLevel() > 29) || myclass == MONK || myclass == MONKGM) { + float DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel()) / 400.0f; if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability) { Attack(target, 14); diff --git a/zone/Object.cpp b/zone/Object.cpp index c4a8b0b3b..1f4dc3654 100644 --- a/zone/Object.cpp +++ b/zone/Object.cpp @@ -218,7 +218,7 @@ Object::Object(const char *model, float x, float y, float z, float heading, uint user = nullptr; last_user = nullptr; ItemInst* inst = nullptr; - inst = new ItemInst(ItemUseWorldContainer); + inst = new ItemInst(ItemInstWorldContainer); // Initialize members m_id = 0; diff --git a/zone/attack.cpp b/zone/attack.cpp index f93e2f265..1c2c52b2d 100644 --- a/zone/attack.cpp +++ b/zone/attack.cpp @@ -53,7 +53,7 @@ extern WorldServer worldserver; extern EntityList entity_list; extern Zone* zone; -bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapon) +bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon) { // Determine animation int type = 0; @@ -64,51 +64,51 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo #endif switch (item->ItemType) { - case ItemType1HS: // 1H Slashing + case ItemType1HSlash: // 1H Slashing { - skillinuse = _1H_SLASHING; + skillinuse = Skill1HSlashing; type = anim1HWeapon; break; } - case ItemType2HS: // 2H Slashing + case ItemType2HSlash: // 2H Slashing { - skillinuse = _2H_SLASHING; + skillinuse = Skill2HSlashing; type = anim2HSlashing; break; } - case ItemTypePierce: // Piercing + case ItemType1HPiercing: // Piercing { - skillinuse = PIERCING; + skillinuse = Skill1HPiercing; type = animPiercing; break; } - case ItemType1HB: // 1H Blunt + case ItemType1HBlunt: // 1H Blunt { - skillinuse = _1H_BLUNT; + skillinuse = Skill1HBlunt; type = anim1HWeapon; break; } - case ItemType2HB: // 2H Blunt + case ItemType2HBlunt: // 2H Blunt { - skillinuse = _2H_BLUNT; + skillinuse = Skill2HBlunt; type = anim2HWeapon; break; } - case ItemType2HPierce: // 2H Piercing + case ItemType2HPiercing: // 2H Piercing { - skillinuse = PIERCING; + skillinuse = Skill1HPiercing; // change to Skill2HPiercing once activated type = anim2HWeapon; break; } - case ItemTypeHand2Hand: + case ItemTypeMartial: { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; break; } default: { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; break; } @@ -118,37 +118,37 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo switch (skillinuse) { - case _1H_SLASHING: // 1H Slashing + case Skill1HSlashing: // 1H Slashing { type = anim1HWeapon; break; } - case _2H_SLASHING: // 2H Slashing + case Skill2HSlashing: // 2H Slashing { type = anim2HSlashing; break; } - case PIERCING: // Piercing + case Skill1HPiercing: // Piercing { type = animPiercing; break; } - case _1H_BLUNT: // 1H Blunt + case Skill1HBlunt: // 1H Blunt { type = anim1HWeapon; break; } - case _2H_BLUNT: // 2H Blunt + case Skill2HBlunt: // 2H Blunt { type = anim2HWeapon; break; } - case 99: // 2H Piercing + case 99: // 2H Piercing // change to Skill2HPiercing once activated { type = anim2HWeapon; break; } - case HAND_TO_HAND: + case SkillHandtoHand: { type = animHand2Hand; break; @@ -161,7 +161,7 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo }// switch } else { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; } @@ -175,7 +175,7 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo // called when a mob is attacked, does the checks to see if it's a hit // and does other mitigation checks. 'this' is the mob being attacked. -bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chance_mod) +bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 chance_mod) { /*/ //Reworked a lot of this code to achieve better balance at higher levels. @@ -254,7 +254,7 @@ bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chanc if(defender->IsClient()) { - chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(DEFENSE) - defender->GetSkill(DEFENSE))); + chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense))); mlog(COMBAT__TOHIT, "Chance to hit after weapon falloff calc (defense) %.2f", chancetohit); } @@ -314,7 +314,7 @@ bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chanc chancetohit += ((chancetohit * hitBonus) / 100.0f); - if(skillinuse == ARCHERY) + if(skillinuse == SkillArchery) chancetohit -= (chancetohit * RuleR(Combat, ArcheryHitPenalty)) / 100.0f; chancetohit = mod_hit_chance(chancetohit, skillinuse, attacker); @@ -389,9 +389,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (CanRiposte && damage > 0 && CanThisClassRiposte() && !other->BehindMob(this, other->GetX(), other->GetY())) { riposte_chance = (100.0f + (float)defender->aabonuses.RiposteChance + (float)defender->spellbonuses.RiposteChance + (float)defender->itembonuses.RiposteChance) / 100.0f; - skill = GetSkill(RIPOSTE); + skill = GetSkill(SkillRiposte); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(RIPOSTE, other, -10); + CastToClient()->CheckIncreaseSkill(SkillRiposte, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -429,9 +429,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) float block_chance = 0.0f; if (damage > 0 && CanThisClassBlock() && (!other->BehindMob(this, other->GetX(), other->GetY()) || bBlockFromRear)) { block_chance = (100.0f + (float)spellbonuses.IncreaseBlockChance + (float)itembonuses.IncreaseBlockChance) / 100.0f; - skill = CastToClient()->GetSkill(BLOCKSKILL); + skill = CastToClient()->GetSkill(SkillBlock); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(BLOCKSKILL, other, -10); + CastToClient()->CheckIncreaseSkill(SkillBlock, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -465,7 +465,7 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if(equiped2) { uint8 TwoHandBlunt = CastToClient()->m_inv.GetItem(13)->GetItem()->ItemType; float bonusStaffBlock = 0.0f; - if(TwoHandBlunt == ItemType2HB) { + if(TwoHandBlunt == ItemType2HBlunt) { bonusStaffBlock = aabonuses.TwoHandBluntBlock + spellbonuses.TwoHandBluntBlock + itembonuses.TwoHandBluntBlock; RollTable[1] += bonusStaffBlock; @@ -480,9 +480,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassParry() && !other->BehindMob(this, other->GetX(), other->GetY())) { parry_chance = (100.0f + (float)defender->spellbonuses.ParryChance + (float)defender->itembonuses.ParryChance) / 100.0f; - skill = CastToClient()->GetSkill(PARRY); + skill = CastToClient()->GetSkill(SkillParry); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(PARRY, other, -10); + CastToClient()->CheckIncreaseSkill(SkillParry, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -503,9 +503,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassDodge() && !other->BehindMob(this, other->GetX(), other->GetY())) { dodge_chance = (100.0f + (float)defender->spellbonuses.DodgeChance + (float)defender->itembonuses.DodgeChance) / 100.0f; - skill = CastToClient()->GetSkill(DODGE); + skill = CastToClient()->GetSkill(SkillDodge); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(DODGE, other, -10); + CastToClient()->CheckIncreaseSkill(SkillDodge, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -644,11 +644,11 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac mitigation_rating = 0.0; if(GetClass() == WIZARD || GetClass() == MAGICIAN || GetClass() == NECROMANCER || GetClass() == ENCHANTER) { - mitigation_rating = ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1; + mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1; } else { - mitigation_rating = ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1; + mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1; } mitigation_rating *= 0.847; @@ -656,11 +656,11 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac if(attacker->IsClient()) { - attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(OFFENSE)*1.345)); + attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(SkillOffense)*1.345)); } else { - attack_rating = (attacker->GetATK() + (attacker->GetSkill(OFFENSE)*1.345) + ((attacker->GetSTR()-66) * 0.9)); + attack_rating = (attacker->GetATK() + (attacker->GetSkill(SkillOffense)*1.345) + ((attacker->GetSTR()-66) * 0.9)); } attack_rating = attacker->mod_attack_rating(attack_rating, this); @@ -1156,7 +1156,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b // calculate attack_skill and skillinuse depending on hand and weapon // also send Packet to near clients - SkillType skillinuse; + SkillUseTypes skillinuse; AttackAnimation(skillinuse, Hand, weapon); mlog(COMBAT__ATTACKS, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse); @@ -1192,7 +1192,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b max_hit = (RuleI(Combat, HitCapPre20)); CheckIncreaseSkill(skillinuse, other, -15); - CheckIncreaseSkill(OFFENSE, other, -15); + CheckIncreaseSkill(SkillOffense, other, -15); // *************************************************************** @@ -1385,7 +1385,7 @@ void Mob::Heal() SendHPUpdate(); } -void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) +void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(dead || IsCorpse()) return; @@ -1407,7 +1407,7 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ //Don't do PvP mitigation if the caster is damaging himself if(other && other->IsClient() && (other != this) && damage > 0) { int PvPMitigation = 100; - if(attack_skill == ARCHERY) + if(attack_skill == SkillArchery) PvPMitigation = 80; else PvPMitigation = 67; @@ -1423,11 +1423,11 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ if (damage > 0) { if (spell_id == SPELL_UNKNOWN) - CheckIncreaseSkill(DEFENSE, other, -15); + CheckIncreaseSkill(SkillDefense, other, -15); } } -bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) +bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { if(!ClientFinishedLoading()) return false; @@ -1743,13 +1743,13 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool FaceTarget(GetTarget()); - SkillType skillinuse = HAND_TO_HAND; + SkillUseTypes skillinuse = SkillHandtoHand; if (Hand == 13) { - skillinuse = static_cast(GetPrimSkill()); + skillinuse = static_cast(GetPrimSkill()); OffHandAtk(false); } if (Hand == 14) { - skillinuse = static_cast(GetSecSkill()); + skillinuse = static_cast(GetSecSkill()); OffHandAtk(true); } @@ -1771,31 +1771,33 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool } switch(weapon->ItemType){ - case ItemType1HS: - skillinuse = _1H_SLASHING; + case ItemType1HSlash: + skillinuse = Skill1HSlashing; break; - case ItemType2HS: - skillinuse = _2H_SLASHING; + case ItemType2HSlash: + skillinuse = Skill2HSlashing; break; - case ItemTypePierce: - case ItemType2HPierce: - skillinuse = PIERCING; + case ItemType1HPiercing: + //skillinuse = Skill1HPiercing; + //break; + case ItemType2HPiercing: + skillinuse = Skill1HPiercing; // change to Skill2HPiercing once activated break; - case ItemType1HB: - skillinuse = _1H_BLUNT; + case ItemType1HBlunt: + skillinuse = Skill1HBlunt; break; - case ItemType2HB: - skillinuse = _2H_BLUNT; + case ItemType2HBlunt: + skillinuse = Skill2HBlunt; break; case ItemTypeBow: - skillinuse = ARCHERY; + skillinuse = SkillArchery; break; - case ItemTypeThrowing: - case ItemTypeThrowingv2: - skillinuse = THROWING; + case ItemTypeLargeThrowing: + case ItemTypeSmallThrowing: + skillinuse = SkillThrowing; break; default: - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; break; } } @@ -1807,9 +1809,10 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool ItemInst weapon_inst(weapon, charges); AttackAnimation(skillinuse, Hand, &weapon_inst); + // Remove this once Skill2HPiercing is activated //Work-around for there being no 2HP skill - We use 99 for the 2HB animation and 36 for pierce messages if(skillinuse == 99) - skillinuse = static_cast(36); + skillinuse = static_cast(36); //basically "if not immune" then do the attack if((weapon_damage) > 0) { @@ -1996,7 +1999,7 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool return false; } -void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { +void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(spell_id==0) spell_id = SPELL_UNKNOWN; @@ -2039,7 +2042,7 @@ void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ski } } -bool NPC::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) { +bool NPC::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { mlog(COMBAT__HITS, "Fatal blow dealt by %s with %d damage, spell %d, skill %d", killerMob->GetName(), damage, spell, attack_skill); Mob *oos = nullptr; @@ -2600,7 +2603,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) { } DS -= DS * attacker->itembonuses.DSMitigation / 100; } - attacker->Damage(this, -DS, spellid, ABJURE/*hackish*/, false); + attacker->Damage(this, -DS, spellid, SkillAbjuration/*hackish*/, false); //we can assume there is a spell now EQApplicationPacket* outapp = new EQApplicationPacket(OP_Damage, sizeof(CombatDamage_Struct)); CombatDamage_Struct* cds = (CombatDamage_Struct*)outapp->pBuffer; @@ -2627,7 +2630,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) { if(rev_ds < 0) { mlog(COMBAT__HITS, "Applying Reverse Damage Shield of value %d to %s", rev_ds, attacker->GetName()); - attacker->Damage(this, -rev_ds, rev_ds_spell_id, ABJURE/*hackish*/, false); //"this" (us) will get the hate, etc. not sure how this works on Live, but it'll works for now, and tanks will love us for this + attacker->Damage(this, -rev_ds, rev_ds_spell_id, SkillAbjuration/*hackish*/, false); //"this" (us) will get the hate, etc. not sure how this works on Live, but it'll works for now, and tanks will love us for this //do we need to send a damage packet here also? } } @@ -2650,7 +2653,7 @@ uint8 Mob::GetWeaponDamageBonus( const Item_Struct *Weapon ) // Assert: This function should not be called unless the player is a melee class, as casters do not receive a damage bonus. - if( Weapon == nullptr || Weapon->ItemType == ItemType1HS || Weapon->ItemType == ItemType1HB || Weapon->ItemType == ItemTypeHand2Hand || Weapon->ItemType == ItemTypePierce ) + if( Weapon == nullptr || Weapon->ItemType == ItemType1HSlash || Weapon->ItemType == ItemType1HBlunt || Weapon->ItemType == ItemTypeMartial || Weapon->ItemType == ItemType1HPiercing ) { // The weapon in the player's main (primary) hand is a one-handed weapon, or there is no item equipped at all. // @@ -3285,12 +3288,12 @@ bool Client::CheckDoubleAttack(bool tripleAttack) { //Check for bonuses that give you a double attack chance regardless of skill (ie Bestial Frenzy/Harmonious Attack AA) uint16 bonusGiveDA = aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack; - if(!HasSkill(DOUBLE_ATTACK) && !bonusGiveDA) + if(!HasSkill(SkillDoubleAttack) && !bonusGiveDA) return false; float chance = 0.0f; - uint16 skill = GetSkill(DOUBLE_ATTACK); + uint16 skill = GetSkill(SkillDoubleAttack); int16 bonusDA = aabonuses.DoubleAttackChance + spellbonuses.DoubleAttackChance + itembonuses.DoubleAttackChance; @@ -3317,9 +3320,9 @@ bool Client::CheckDoubleAttack(bool tripleAttack) { return false; } -void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const SkillType skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic) { +void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const SkillUseTypes skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic) { // This method is called with skill_used=ABJURE for Damage Shield damage. - bool FromDamageShield = (skill_used == ABJURE); + bool FromDamageShield = (skill_used == SkillAbjuration); mlog(COMBAT__HITS, "Applying damage %d done by %s with skill %d and spell %d, avoidable? %s, is %sa buff tic in slot %d", damage, attacker?attacker->GetName():"NOBODY", skill_used, spell_id, avoidable?"yes":"no", iBuffTic?"":"not ", buffslot); @@ -3334,7 +3337,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons // only apply DS if physical damage (no spell damage) // damage shield calls this function with spell_id set, so its unavoidable - if (attacker && damage > 0 && spell_id == SPELL_UNKNOWN && skill_used != ARCHERY && skill_used != THROWING) { + if (attacker && damage > 0 && spell_id == SPELL_UNKNOWN && skill_used != SkillArchery && skill_used != SkillThrowing) { DamageShield(attacker); if (spellbonuses.DamageShield) @@ -3450,7 +3453,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons } //check stun chances if bashing - if (damage > 0 && ((skill_used == BASH || skill_used == KICK) && attacker)) + if (damage > 0 && ((skill_used == SkillBash || skill_used == SkillKick) && attacker)) { // NPCs can stun with their bash/kick as soon as they recieve it. // Clients can stun mobs under level 56 with their bash/kick when they get level 55 or greater. @@ -3646,8 +3649,8 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons void Mob::HealDamage(uint32 amount, Mob* caster) { - uint32 maxhp = GetMaxHP(); - uint32 curhp = GetHP(); + int32 maxhp = GetMaxHP(); + int32 curhp = GetHP(); uint32 acthealed = 0; if(caster && amount > 0) @@ -3821,16 +3824,16 @@ void Mob::TryDefensiveProc(const ItemInst* weapon, Mob *on, uint16 hand, int dam if (bSkillProc && damage < 0){ if (damage == -1) - TrySkillProc(on, BLOCKSKILL, ProcChance); + TrySkillProc(on, SkillBlock, ProcChance); if (damage == -2) - TrySkillProc(on, PARRY, ProcChance); + TrySkillProc(on, SkillParry, ProcChance); if (damage == -3) - TrySkillProc(on, RIPOSTE, ProcChance); + TrySkillProc(on, SkillRiposte, ProcChance); if (damage == -4) - TrySkillProc(on, DODGE, ProcChance); + TrySkillProc(on, SkillDodge, ProcChance); } } @@ -3935,7 +3938,7 @@ void Mob::TryWeaponProc(const ItemInst *inst, const Item_Struct* weapon, Mob *on bool bRangedAttack = false; if (weapon != nullptr) { - if (weapon->ItemType == ItemTypeBow || weapon->ItemType == ItemTypeThrowing || weapon->ItemType == ItemTypeThrowingv2) { + if (weapon->ItemType == ItemTypeBow || weapon->ItemType == ItemTypeLargeThrowing || weapon->ItemType == ItemTypeSmallThrowing) { bRangedAttack = true; } } @@ -3944,8 +3947,8 @@ void Mob::TryWeaponProc(const ItemInst *inst, const Item_Struct* weapon, Mob *on if(weapon) { if(weapon->ItemType == ItemTypeArrow || - weapon->ItemType == ItemTypeThrowing || - weapon->ItemType == ItemTypeThrowingv2 || + weapon->ItemType == ItemTypeLargeThrowing || + weapon->ItemType == ItemTypeSmallThrowing || weapon->ItemType == ItemTypeBow) { isRanged = true; @@ -4109,10 +4112,10 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack critChance += RuleI(Combat, WarBerBaseCritChance); } - if(skill == ARCHERY && GetClass() == RANGER && GetSkill(ARCHERY) >= 65) + if(skill == SkillArchery && GetClass() == RANGER && GetSkill(SkillArchery) >= 65) critChance += 6; - if(skill == THROWING && GetClass() == ROGUE && GetSkill(THROWING) >= 65) + if(skill == SkillThrowing && GetClass() == ROGUE && GetSkill(SkillThrowing) >= 65) critChance += 6; int CritChanceBonus = GetCriticalChanceBonus(skill); @@ -4178,7 +4181,7 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack } -bool Mob::TryFinishingBlow(Mob *defender, SkillType skillinuse) +bool Mob::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse) { if (!defender) @@ -4271,7 +4274,7 @@ bool Mob::HasDied() { return Result; } -uint16 Mob::GetDamageTable(SkillType skillinuse) +uint16 Mob::GetDamageTable(SkillUseTypes skillinuse) { if(GetLevel() <= 51) { diff --git a/zone/beacon.h b/zone/beacon.h index 071bb8cc8..32709fdf2 100644 --- a/zone/beacon.h +++ b/zone/beacon.h @@ -31,8 +31,8 @@ public: ~Beacon(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { return true; } - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; } virtual bool HasRaid() { return false; } diff --git a/zone/bonuses.cpp b/zone/bonuses.cpp index ca0a35b1f..18ad2dc8f 100644 --- a/zone/bonuses.cpp +++ b/zone/bonuses.cpp @@ -29,6 +29,7 @@ #include "QuestParserCollection.h" #include #include +#include #ifndef WIN32 #include #include "../common/unix.h" @@ -531,7 +532,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAu void Client::CalcEdibleBonuses(StatBonuses* newbon) { #if EQDEBUG >= 11 - cout<<"Client::CalcEdibleBonuses(StatBonuses* newbon)"<GetItem()->ItemType; //is this the best way to do this? switch(type) { - case ItemType1HS: // 1H Slashing + case ItemType1HSlash: // 1H Slashing { - skill = _1H_SLASHING; + skill = Skill1HSlashing; break; } - case ItemType2HS: // 2H Slashing + case ItemType2HSlash: // 2H Slashing { - skill = _2H_SLASHING; + skill = Skill2HSlashing; break; } - case ItemTypePierce: // Piercing + case ItemType1HPiercing: // Piercing { - skill = PIERCING; + skill = Skill1HPiercing; break; } - case ItemType1HB: // 1H Blunt + case ItemType1HBlunt: // 1H Blunt { - skill = _1H_BLUNT; + skill = Skill1HBlunt; break; } - case ItemType2HB: // 2H Blunt + case ItemType2HBlunt: // 2H Blunt { - skill = _2H_BLUNT; + skill = Skill2HBlunt; break; } - case ItemType2HPierce: // 2H Piercing + case ItemType2HPiercing: // 2H Piercing { - skill = PIERCING; + skill = Skill1HPiercing; // change to Skill2HPiercing once activated break; } - case ItemTypeHand2Hand: // Hand to Hand + case ItemTypeMartial: // Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } default: // All other types default to Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } } @@ -1348,7 +1348,7 @@ uint16 Bot::GetPrimarySkillValue() return GetSkill(skill); } -uint16 Bot::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Bot::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } @@ -1358,7 +1358,7 @@ uint16 Bot::GetTotalATK() uint16 WornCap = itembonuses.ATK; if(IsBot()) { - AttackRating = ((WornCap * 1.342) + (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); + AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement(); if (AttackRating < 10) @@ -1376,7 +1376,7 @@ uint16 Bot::GetATKRating() { uint16 AttackRating = 0; if(IsBot()) { - AttackRating = (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); + AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); if (AttackRating < 10) AttackRating = 10; @@ -3206,7 +3206,7 @@ void Bot::BotRangedAttack(Mob* other) { return; } - SendItemAnimation(other, Ammo, ARCHERY); + SendItemAnimation(other, Ammo, SkillArchery); DoArcheryAttackDmg(GetTarget(), rangedItem, ammoItem); @@ -3248,13 +3248,13 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) { uint16 bonusGiveDA = aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack; // If you don't have the double attack skill, return - if(!GetSkill(DOUBLE_ATTACK) && !(GetClass() == BARD || GetClass() == BEASTLORD)) + if(!GetSkill(SkillDoubleAttack) && !(GetClass() == BARD || GetClass() == BEASTLORD)) return false; // You start with no chance of double attacking float chance = 0.0f; - uint16 skill = GetSkill(DOUBLE_ATTACK); + uint16 skill = GetSkill(SkillDoubleAttack); int16 bonusDA = aabonuses.DoubleAttackChance + spellbonuses.DoubleAttackChance + itembonuses.DoubleAttackChance; @@ -3281,15 +3281,15 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) { return false; } -void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) +void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) { if (!CanDoSpecialAttack(other)) return; //For spells using skill value 98 (feral swipe ect) server sets this to 67 automatically. //Kayen: This is unlikely to be completely accurate but use OFFENSE skill value for these effects. - if (skillinuse == BEGGING) - skillinuse = OFFENSE; + if (skillinuse == SkillBegging) + skillinuse = SkillOffense; int damage = 0; uint32 hate = 0; @@ -3351,7 +3351,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil else damage = -5; - if(skillinuse == BASH){ + if(skillinuse == SkillBash){ const ItemInst* inst = GetBotItem(SLOT_SECONDARY); const Item_Struct* botweapon = 0; if(inst) @@ -3367,8 +3367,8 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil other->AddToHateList(this, hate); bool CanSkillProc = true; - if (skillinuse == OFFENSE){ //Hack to allow damage to display. - skillinuse = TIGER_CLAW; //'strike' your opponent - Arbitrary choice for message. + if (skillinuse == SkillOffense){ //Hack to allow damage to display. + skillinuse = SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message. CanSkillProc = false; //Disable skill procs } @@ -3377,7 +3377,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil if (HasDied()) return; - if((skillinuse == DRAGON_PUNCH) && GetAA(aaDragonPunch) && MakeRandomInt(0, 99) < 25){ + if((skillinuse == SkillDragonPunch) && GetAA(aaDragonPunch) && MakeRandomInt(0, 99) < 25){ SpellFinished(904, other, 10, 0, -1, spells[904].ResistDiff); other->Stun(100); } @@ -3388,26 +3388,26 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil } } -void Bot::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { +void Bot::ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg) { int item_slot = -1; //1: Apply bonus from AC (BOOT/SHIELD/HANDS) est. 40AC=6dmg switch (skill){ - case FLYING_KICK: - case ROUND_KICK: - case KICK: + case SkillFlyingKick: + case SkillRoundKick: + case SkillKick: item_slot = SLOT_FEET; break; - case BASH: + case SkillBash: item_slot = SLOT_SECONDARY; break; - case DRAGON_PUNCH: - case EAGLE_STRIKE: - case TIGER_CLAW: + case SkillDragonPunch: + case SkillEagleStrike: + case SkillTigerClaw: item_slot = SLOT_HANDS; break; } @@ -3802,9 +3802,9 @@ void Bot::AI_Process() { if (GetTarget() && ExtraAttackChanceBonus) { ItemInst *wpn = GetBotItem(SLOT_PRIMARY); if(wpn){ - if(wpn->GetItem()->ItemType == ItemType2HS || - wpn->GetItem()->ItemType == ItemType2HB || - wpn->GetItem()->ItemType == ItemType2HPierce ) + if(wpn->GetItem()->ItemType == ItemType2HSlash || + wpn->GetItem()->ItemType == ItemType2HBlunt || + wpn->GetItem()->ItemType == ItemType2HPiercing ) { if(MakeRandomInt(0, 100) < ExtraAttackChanceBonus) { @@ -3843,11 +3843,11 @@ void Bot::AI_Process() { bIsFist = false; } - if(bIsFist || ((weapontype != ItemType2HS) && (weapontype != ItemType2HPierce) && (weapontype != ItemType2HB))) { + if(bIsFist || ((weapontype != ItemType2HSlash) && (weapontype != ItemType2HPiercing) && (weapontype != ItemType2HBlunt))) { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -4127,7 +4127,7 @@ void Bot::PetAIProcess() { { if(botPet->GetOwner()->GetLevel() >= 24) { - float DualWieldProbability = (botPet->GetSkill(DUAL_WIELD) + botPet->GetLevel()) / 400.0f; + float DualWieldProbability = (botPet->GetSkill(SkillDualWield) + botPet->GetLevel()) / 400.0f; DualWieldProbability -= MakeRandomFloat(0, 1); if(DualWieldProbability < 0){ botPet->Attack(botPet->GetTarget(), 14); @@ -4584,8 +4584,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_HANDS] = item->Material; - ns->spawn.colors[MATERIAL_HANDS].color = GetEquipmentColor(MATERIAL_HANDS); + ns->spawn.equipment[MaterialHands] = item->Material; + ns->spawn.colors[MaterialHands].color = GetEquipmentColor(MaterialHands); } } @@ -4593,8 +4593,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_HEAD] = item->Material; - ns->spawn.colors[MATERIAL_HEAD].color = GetEquipmentColor(MATERIAL_HEAD); + ns->spawn.equipment[MaterialHead] = item->Material; + ns->spawn.colors[MaterialHead].color = GetEquipmentColor(MaterialHead); } } @@ -4602,8 +4602,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_ARMS] = item->Material; - ns->spawn.colors[MATERIAL_ARMS].color = GetEquipmentColor(MATERIAL_ARMS); + ns->spawn.equipment[MaterialArms] = item->Material; + ns->spawn.colors[MaterialArms].color = GetEquipmentColor(MaterialArms); } } @@ -4611,8 +4611,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_BRACER] = item->Material; - ns->spawn.colors[MATERIAL_BRACER].color = GetEquipmentColor(MATERIAL_BRACER); + ns->spawn.equipment[MaterialWrist] = item->Material; + ns->spawn.colors[MaterialWrist].color = GetEquipmentColor(MaterialWrist); } } @@ -4620,8 +4620,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_BRACER] = item->Material; - ns->spawn.colors[MATERIAL_BRACER].color = GetEquipmentColor(MATERIAL_BRACER); + ns->spawn.equipment[MaterialWrist] = item->Material; + ns->spawn.colors[MaterialWrist].color = GetEquipmentColor(MaterialWrist); } } @@ -4629,8 +4629,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_CHEST] = item->Material; - ns->spawn.colors[MATERIAL_CHEST].color = GetEquipmentColor(MATERIAL_CHEST); + ns->spawn.equipment[MaterialChest] = item->Material; + ns->spawn.colors[MaterialChest].color = GetEquipmentColor(MaterialChest); } } @@ -4638,8 +4638,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_LEGS] = item->Material; - ns->spawn.colors[MATERIAL_LEGS].color = GetEquipmentColor(MATERIAL_LEGS); + ns->spawn.equipment[MaterialLegs] = item->Material; + ns->spawn.colors[MaterialLegs].color = GetEquipmentColor(MaterialLegs); } } @@ -4647,8 +4647,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { if(inst) { item = inst->GetItem(); if(item) { - ns->spawn.equipment[MATERIAL_FEET] = item->Material; - ns->spawn.colors[MATERIAL_FEET].color = GetEquipmentColor(MATERIAL_FEET); + ns->spawn.equipment[MaterialFeet] = item->Material; + ns->spawn.colors[MaterialFeet].color = GetEquipmentColor(MaterialFeet); } } @@ -4657,8 +4657,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { item = inst->GetItem(); if(item) { if(strlen(item->IDFile) > 2) - ns->spawn.equipment[MATERIAL_PRIMARY] = atoi(&item->IDFile[2]); - ns->spawn.colors[MATERIAL_PRIMARY].color = GetEquipmentColor(MATERIAL_PRIMARY); + ns->spawn.equipment[MaterialPrimary] = atoi(&item->IDFile[2]); + ns->spawn.colors[MaterialPrimary].color = GetEquipmentColor(MaterialPrimary); } } @@ -4667,8 +4667,8 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) { item = inst->GetItem(); if(item) { if(strlen(item->IDFile) > 2) - ns->spawn.equipment[MATERIAL_SECONDARY] = atoi(&item->IDFile[2]); - ns->spawn.colors[MATERIAL_SECONDARY].color = GetEquipmentColor(MATERIAL_SECONDARY); + ns->spawn.equipment[MaterialSecondary] = atoi(&item->IDFile[2]); + ns->spawn.colors[MaterialSecondary].color = GetEquipmentColor(MaterialSecondary); } } } @@ -5431,8 +5431,8 @@ void Bot::BotRemoveEquipItem(int slot) { if(materialFromSlot != 0xFF) { equipment[slot] = 0; // npc has more than just material slots. Valid material should mean valid inventory index SendWearChange(materialFromSlot); - if(materialFromSlot == MATERIAL_CHEST) - SendWearChange(MATERIAL_ARMS); + if(materialFromSlot == MaterialChest) + SendWearChange(MaterialArms); } } } @@ -6039,9 +6039,9 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli how_many_slots++; if(!GetBotItem(j)) { if(j == SLOT_PRIMARY) { - if((mWeaponItem->ItemType == ItemType2HS) || (mWeaponItem->ItemType == ItemType2HB) || (mWeaponItem->ItemType == ItemType2HPierce)) { + if((mWeaponItem->ItemType == ItemType2HSlash) || (mWeaponItem->ItemType == ItemType2HBlunt) || (mWeaponItem->ItemType == ItemType2HPiercing)) { if(GetBotItem(SLOT_SECONDARY)) { - if(mWeaponItem && (mWeaponItem->ItemType == ItemType2HS) || (mWeaponItem->ItemType == ItemType2HB) || (mWeaponItem->ItemType == ItemType2HPierce)) { + if(mWeaponItem && (mWeaponItem->ItemType == ItemType2HSlash) || (mWeaponItem->ItemType == ItemType2HBlunt) || (mWeaponItem->ItemType == ItemType2HPiercing)) { if(client->CheckLoreConflict(GetBotItem(SLOT_SECONDARY)->GetItem())) { failedLoreCheck = true; } @@ -6076,7 +6076,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli if(success) { if(GetBotItem(SLOT_PRIMARY)) { ItemInst* remove_item = GetBotItem(SLOT_PRIMARY); - if((remove_item->GetItem()->ItemType == ItemType2HS) || (remove_item->GetItem()->ItemType == ItemType2HB) || (remove_item->GetItem()->ItemType == ItemType2HPierce)) { + if((remove_item->GetItem()->ItemType == ItemType2HSlash) || (remove_item->GetItem()->ItemType == ItemType2HBlunt) || (remove_item->GetItem()->ItemType == ItemType2HPiercing)) { BotTradeSwapItem(client, SLOT_PRIMARY, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false); } } @@ -6110,7 +6110,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli } if(!failedLoreCheck) { if(j == SLOT_PRIMARY) { - if((mWeaponItem->ItemType == ItemType2HS) || (mWeaponItem->ItemType == ItemType2HB) || (mWeaponItem->ItemType == ItemType2HPierce)) { + if((mWeaponItem->ItemType == ItemType2HSlash) || (mWeaponItem->ItemType == ItemType2HBlunt) || (mWeaponItem->ItemType == ItemType2HPiercing)) { if(GetBotItem(SLOT_SECONDARY)) { if(client->CheckLoreConflict(GetBotItem(SLOT_SECONDARY)->GetItem())) { failedLoreCheck = true; @@ -6144,7 +6144,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli } if(success && GetBotItem(SLOT_PRIMARY)) { ItemInst* remove_item = GetBotItem(SLOT_PRIMARY); - if((remove_item->GetItem()->ItemType == ItemType2HS) || (remove_item->GetItem()->ItemType == ItemType2HB) || (remove_item->GetItem()->ItemType == ItemType2HPierce)) { + if((remove_item->GetItem()->ItemType == ItemType2HSlash) || (remove_item->GetItem()->ItemType == ItemType2HBlunt) || (remove_item->GetItem()->ItemType == ItemType2HPiercing)) { BotTradeSwapItem(client, SLOT_PRIMARY, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false); } } @@ -6195,7 +6195,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli } } -bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { +bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { if(!NPC::Death(killerMob, damage, spell_id, attack_skill)) return false; @@ -6300,7 +6300,7 @@ bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillType attack_ return true; } -void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { +void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(spell_id==0) spell_id = SPELL_UNKNOWN; @@ -6425,7 +6425,7 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b // calculate attack_skill and skillinuse depending on hand and weapon // also send Packet to near clients - SkillType skillinuse; + SkillUseTypes skillinuse; AttackAnimation(skillinuse, Hand, weapon); mlog(COMBAT__ATTACKS, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse); @@ -7828,7 +7828,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (CanRiposte && damage > 0 && CanThisClassRiposte() && !other->BehindMob(this, other->GetX(), other->GetY())) { riposte_chance = (100.0f + (float)defender->GetAABonuses().RiposteChance + (float)defender->GetSpellBonuses().RiposteChance + (float)defender->GetItemBonuses().RiposteChance) / 100.0f; - skill = GetSkill(RIPOSTE); + skill = GetSkill(SkillRiposte); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetDEX()/200); @@ -7864,7 +7864,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) float block_chance = 0.0f; if (damage > 0 && CanThisClassBlock() && (!other->BehindMob(this, other->GetX(), other->GetY()) || bBlockFromRear)) { block_chance = (100.0f + (float)spellbonuses.IncreaseBlockChance + (float)itembonuses.IncreaseBlockChance) / 100.0f; - skill = GetSkill(BLOCKSKILL); + skill = GetSkill(SkillBlock); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/35.0 + (GetDEX()/200); @@ -7897,7 +7897,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if(equiped2) { uint8 TwoHandBlunt = GetBotItem(SLOT_PRIMARY)->GetItem()->ItemType; float bonusStaffBlock = 0.0f; - if(TwoHandBlunt == ItemType2HB) { + if(TwoHandBlunt == ItemType2HBlunt) { bonusStaffBlock = aabonuses.TwoHandBluntBlock + spellbonuses.TwoHandBluntBlock + itembonuses.TwoHandBluntBlock; RollTable[1] = RollTable[0] + bonusStaffBlock; @@ -7912,7 +7912,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassParry() && !other->BehindMob(this, other->GetX(), other->GetY())) { parry_chance = (100.0f + (float)defender->GetSpellBonuses().ParryChance + (float)defender->GetItemBonuses().ParryChance) / 100.0f; - skill = GetSkill(PARRY); + skill = GetSkill(SkillParry); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetDEX()/200); @@ -7931,7 +7931,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassDodge() && !other->BehindMob(this, other->GetX(), other->GetY())) { dodge_chance = (100.0f + (float)defender->GetSpellBonuses().DodgeChance + (float)defender->GetItemBonuses().DodgeChance) / 100.0f; - skill = GetSkill(DODGE); + skill = GetSkill(SkillDodge); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetAGI()/200); @@ -7981,7 +7981,7 @@ int Bot::GetMonkHandToHandDamage(void) // Have a look to see if we have epic fists on uint32 botWeaponId = INVALID_ID; - botWeaponId = CastToNPC()->GetEquipment(MATERIAL_HANDS); + botWeaponId = CastToNPC()->GetEquipment(MaterialHands); if(botWeaponId == 10652) { //Monk Epic ID return 9; } @@ -8001,7 +8001,7 @@ int Bot::GetMonkHandToHandDamage(void) return damage[Level]; } -bool Bot::TryFinishingBlow(Mob *defender, SkillType skillinuse) +bool Bot::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse) { if (!defender) return false; @@ -8058,7 +8058,7 @@ void Bot::DoRiposte(Mob* defender) { } } -void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { +void Bot::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { //this really should go through the same code as normal melee damage to //pick up all the special behavior there @@ -8066,7 +8066,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int if(hate_override > -1) hate = hate_override; - if(skill == BASH) { + if(skill == SkillBash) { const ItemInst* inst = GetBotItem(SLOT_SECONDARY); const Item_Struct* botweapon = 0; if(inst) @@ -8086,7 +8086,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int else{ bool CanRiposte = true; - if(skill == THROWING && skill == ARCHERY) + if(skill == SkillThrowing || skill == SkillArchery) // changed from '&&' CanRiposte = false; who->AvoidDamage(this, max_damage, CanRiposte); @@ -8138,7 +8138,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) { const Item_Struct* botpiercer = nullptr; if(inst) botpiercer = inst->GetItem(); - if(!botpiercer || (botpiercer->ItemType != ItemTypePierce)) { + if(!botpiercer || (botpiercer->ItemType != ItemType1HPiercing)) { Say("I can't backstab with this weapon!"); return; } @@ -8175,7 +8175,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) { else { RogueBackstab(other); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA @@ -8195,7 +8195,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) { //we can stab from any angle, we do min damage though. RogueBackstab(other, true); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA if(other->GetHP() > 0) @@ -8241,12 +8241,12 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) if(primaryweapondamage > 0){ if(level > 25){ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + ((level-25)/3) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + ((level-25)/3) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } else{ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } // determine minimum hits @@ -8260,7 +8260,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) min_hit = (level * ( level*5 - 105)) / 100; } - if(!other->CheckHitChance(this, BACKSTAB, 0)) { + if(!other->CheckHitChance(this, SkillBackstab, 0)) { ndamage = 0; } else{ @@ -8284,7 +8284,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) ndamage = -5; } - DoSpecialAttackDamage(other, BACKSTAB, ndamage, min_hit, hate, ReuseTime); + DoSpecialAttackDamage(other, SkillBackstab, ndamage, min_hit, hate, ReuseTime); DoAnim(animPiercing); } @@ -8293,10 +8293,10 @@ void Bot::RogueAssassinate(Mob* other) ItemInst* botweaponInst = GetBotItem(SLOT_PRIMARY); if(botweaponInst) { if(GetWeaponDamage(other, botweaponInst)) { - other->Damage(this, 32000, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, 32000, SPELL_UNKNOWN, SkillBackstab); } else { - other->Damage(this, -5, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, -5, SPELL_UNKNOWN, SkillBackstab); } } @@ -8381,26 +8381,26 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { bool canBash = false; if((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) // Racial Slam || (m_inv.GetItem(SLOT_SECONDARY) && m_inv.GetItem(SLOT_SECONDARY)->GetItem()->ItemType == ItemTypeShield) //Using Shield - || (m_inv.GetItem(SLOT_PRIMARY) && (m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HS - || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HB - || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HPierce) + || (m_inv.GetItem(SLOT_PRIMARY) && (m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HSlash + || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HBlunt + || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HPiercing) && GetAA(aa2HandBash) >= 1)) { //Using 2 hand weapon, but has AA 2 Hand Bash canBash = true; } if(!canBash || MakeRandomInt(0, 100) > 25) { //tested on live, warrior mobs both kick and bash, kick about 75% of the time, casting doesn't seem to make a difference. - skill_to_use = KICK; + skill_to_use = SkillKick; } else { - skill_to_use = BASH; + skill_to_use = SkillBash; } } case RANGER: case BEASTLORD: - skill_to_use = KICK; + skill_to_use = SkillKick; break; case BERSERKER: - skill_to_use = FRENZY; + skill_to_use = SkillFrenzy; break; case CLERIC: case SHADOWKNIGHT: @@ -8408,42 +8408,42 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { if(level >= RuleI(Combat, NPCBashKickLevel)){ if((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) // Racial Slam || (m_inv.GetItem(SLOT_SECONDARY) && m_inv.GetItem(SLOT_SECONDARY)->GetItem()->ItemType == ItemTypeShield) //Using Shield - || (m_inv.GetItem(SLOT_PRIMARY) && (m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HS - || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HB - || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HPierce) + || (m_inv.GetItem(SLOT_PRIMARY) && (m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HSlash + || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HBlunt + || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HPiercing) && GetAA(aa2HandBash) >= 1)) { //Using 2 hand weapon, but has AA 2 Hand Bash - skill_to_use = BASH; + skill_to_use = SkillBash; } } break; case MONK: if(GetLevel() >= 30) { - skill_to_use = FLYING_KICK; + skill_to_use = SkillFlyingKick; } else if(GetLevel() >= 25) { - skill_to_use = DRAGON_PUNCH; + skill_to_use = SkillDragonPunch; } else if(GetLevel() >= 20) { - skill_to_use = EAGLE_STRIKE; + skill_to_use = SkillEagleStrike; } else if(GetLevel() >= 10) { - skill_to_use = TIGER_CLAW; + skill_to_use = SkillTigerClaw; } else if(GetLevel() >= 5) { - skill_to_use = ROUND_KICK; + skill_to_use = SkillRoundKick; } else { - skill_to_use = KICK; + skill_to_use = SkillKick; } break; case ROGUE: - skill_to_use = BACKSTAB; + skill_to_use = SkillBackstab; break; } @@ -8451,7 +8451,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { return; - if(skill_to_use == BASH) + if(skill_to_use == SkillBash) { if (target!=this) { @@ -8462,7 +8462,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { dmg = -5; } else{ - if(!target->CheckHitChance(this, BASH, 0)) { + if(!target->CheckHitChance(this, SkillBash, 0)) { dmg = 0; } else{ @@ -8477,7 +8477,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { reuse = BashReuseTime * 1000; //reuse = (reuse*HasteModifier)/100; - DoSpecialAttackDamage(target, BASH, dmg, 1,-1,reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1,-1,reuse); did_attack = true; @@ -8488,13 +8488,13 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { } } - if(skill_to_use == FRENZY) + if(skill_to_use == SkillFrenzy) { int AtkRounds = 3; int skillmod = 0; - if(MaxSkill(FRENZY) > 0) - skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + if(MaxSkill(SkillFrenzy) > 0) + skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; @@ -8517,7 +8517,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , reuse, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , reuse, true); } AtkRounds--; } @@ -8527,7 +8527,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { } } - if(skill_to_use == KICK) + if(skill_to_use == SkillKick) { if(target!=this) { @@ -8537,7 +8537,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { dmg = -5; } else{ - if(!target->CheckHitChance(this, KICK, 0)) { + if(!target->CheckHitChance(this, SkillKick, 0)) { dmg = 0; } else{ @@ -8550,17 +8550,17 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1,-1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1,-1, reuse); did_attack = true; } } - if(skill_to_use == FLYING_KICK || - skill_to_use == DRAGON_PUNCH || - skill_to_use == EAGLE_STRIKE || - skill_to_use == TIGER_CLAW || - skill_to_use == ROUND_KICK) + if(skill_to_use == SkillFlyingKick || + skill_to_use == SkillDragonPunch || + skill_to_use == SkillEagleStrike || + skill_to_use == SkillTigerClaw || + skill_to_use == SkillRoundKick) { reuse = MonkSpecialAttack(target, skill_to_use) - 1; MonkSpecialAttack(target, skill_to_use); @@ -8569,7 +8569,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100))) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(target, MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -8586,7 +8586,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { did_attack = true; } - if(skill_to_use == BACKSTAB) + if(skill_to_use == SkillBackstab) { reuse = BackstabReuseTime * 1000; did_attack = true; @@ -8600,10 +8600,10 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { classattack_timer.Start(reuse*HasteModifier/100); } -bool Bot::TryHeadShot(Mob* defender, SkillType skillInUse) { +bool Bot::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) { bool Result = false; - if(defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == ARCHERY) && (GetClass() == RANGER) && (GetLevel() >= 62)) { + if(defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == SkillArchery) && (GetClass() == RANGER) && (GetLevel() >= 62)) { int defenderLevel = defender->GetLevel(); int rangerLevel = GetLevel(); // Bot Ranger Headshot AA through level 85(Underfoot) @@ -9027,16 +9027,16 @@ void Bot::SetAttackTimer() { //if we have a 2H weapon in our main hand, no dual if(PrimaryWeapon != nullptr) { if( PrimaryWeapon->ItemClass == ItemClassCommon - && (PrimaryWeapon->ItemType == ItemType2HS - || PrimaryWeapon->ItemType == ItemType2HB - || PrimaryWeapon->ItemType == ItemType2HPierce)) { + && (PrimaryWeapon->ItemType == ItemType2HSlash + || PrimaryWeapon->ItemType == ItemType2HBlunt + || PrimaryWeapon->ItemType == ItemType2HPiercing)) { attack_dw_timer.Disable(); continue; } } //clients must have the skill to use it... - if(!GetSkill(DUAL_WIELD)) { + if(!GetSkill(SkillDualWield)) { attack_dw_timer.Disable(); continue; } @@ -9052,7 +9052,7 @@ void Bot::SetAttackTimer() { ItemToUse = nullptr; } // Check to see if skill is valid - else if((ItemToUse->ItemType > ItemTypeThrowing) && (ItemToUse->ItemType != ItemTypeHand2Hand) && (ItemToUse->ItemType != ItemType2HPierce)) { + else if((ItemToUse->ItemType > ItemTypeLargeThrowing) && (ItemToUse->ItemType != ItemTypeMartial) && (ItemToUse->ItemType != ItemType2HPiercing)) { //no weapon ItemToUse = nullptr; } @@ -9088,7 +9088,7 @@ void Bot::SetAttackTimer() { if(speed < RuleI(Combat, MinHastedDelay)) speed = RuleI(Combat, MinHastedDelay); - if(ItemToUse && (ItemToUse->ItemType == ItemTypeBow || ItemToUse->ItemType == ItemTypeThrowing)) + if(ItemToUse && (ItemToUse->ItemType == ItemTypeBow || ItemToUse->ItemType == ItemTypeLargeThrowing)) { /*if(IsClient()) { @@ -10610,7 +10610,7 @@ int32 Bot::CalcManaRegen() { BuffFadeBySitModifier(); if(botclass != WARRIOR && botclass != MONK && botclass != ROGUE && botclass != BERSERKER) { - regen = (((GetSkill(MEDITATE) / 10) + (level - (level / 4))) / 4) + 4; + regen = (((GetSkill(SkillMeditate) / 10) + (level - (level / 4))) / 4) + 4; regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; } else @@ -11430,17 +11430,17 @@ void Bot::CalcItemBonuses() if(itembonuses.haste < itemtmp->Haste) itembonuses.haste = itemtmp->Haste; if(GetClass() == BARD && itemtmp->BardValue != 0) { - if(itemtmp->BardType == ItemTypeBrassInstr) + if(itemtmp->BardType == ItemTypeBrassInstrument) itembonuses.brassMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeDrumInstr) + else if(itemtmp->BardType == ItemTypePercussionInstrument) itembonuses.percussionMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemUseSinging) + else if(itemtmp->BardType == ItemTypeSinging) itembonuses.singingMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeStringInstr) + else if(itemtmp->BardType == ItemTypeStringedInstrument) itembonuses.stringedMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeWindInstr) + else if(itemtmp->BardType == ItemTypeWindInstrument) itembonuses.windMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemUseAllInstruments) { + else if(itemtmp->BardType == ItemTypeAllInstrumentTypes) { itembonuses.brassMod += itemtmp->BardValue; itembonuses.percussionMod += itemtmp->BardValue; itembonuses.singingMod += itemtmp->BardValue; @@ -11514,17 +11514,17 @@ void Bot::CalcItemBonuses() if(itembonuses.haste < itemtmp->Haste) itembonuses.haste = itemtmp->Haste; if(GetClass() == BARD && itemtmp->BardValue != 0) { - if(itemtmp->BardType == ItemTypeBrassInstr) + if(itemtmp->BardType == ItemTypeBrassInstrument) itembonuses.brassMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeDrumInstr) + else if(itemtmp->BardType == ItemTypePercussionInstrument) itembonuses.percussionMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemUseSinging) + else if(itemtmp->BardType == ItemTypeSinging) itembonuses.singingMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeStringInstr) + else if(itemtmp->BardType == ItemTypeStringedInstrument) itembonuses.stringedMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemTypeWindInstr) + else if(itemtmp->BardType == ItemTypeWindInstrument) itembonuses.windMod += itemtmp->BardValue; - else if(itemtmp->BardType == ItemUseAllInstruments) { + else if(itemtmp->BardType == ItemTypeAllInstrumentTypes) { itembonuses.brassMod += itemtmp->BardValue; itembonuses.percussionMod += itemtmp->BardValue; itembonuses.singingMod += itemtmp->BardValue; @@ -11572,7 +11572,7 @@ void Bot::CalcBotStats(bool showtext) { // Test Code if(GetClass() == BARD) GetBotOwner()->Message(15, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", - GetSkill(BRASS_INSTRUMENTS), GetSkill(PERCUSSION_INSTRUMENTS), GetSkill(SINGING), GetSkill(STRINGED_INSTRUMENTS), GetSkill(WIND_INSTRUMENTS)); + GetSkill(SkillBrassInstruments), GetSkill(SkillPercussionInstruments), GetSkill(SkillSinging), GetSkill(SkillStringedInstruments), GetSkill(SkillWindInstruments)); } /*if(this->Save()) @@ -11591,11 +11591,11 @@ void Bot::CalcBotStats(bool showtext) { // Test Code if(GetClass() == BARD) { GetBotOwner()->Message(15, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", - GetSkill(BRASS_INSTRUMENTS) + GetBrassMod(), - GetSkill(PERCUSSION_INSTRUMENTS) + GetPercMod(), - GetSkill(SINGING) + GetSingMod(), - GetSkill(STRINGED_INSTRUMENTS) + GetStringMod(), - GetSkill(WIND_INSTRUMENTS) + GetWindMod()); + GetSkill(SkillBrassInstruments) + GetBrassMod(), + GetSkill(SkillPercussionInstruments) + GetPercMod(), + GetSkill(SkillSinging) + GetSingMod(), + GetSkill(SkillStringedInstruments) + GetStringMod(), + GetSkill(SkillWindInstruments) + GetWindMod()); GetBotOwner()->Message(15, "Bard Skill Mods-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", GetBrassMod(), GetPercMod(), GetSingMod(), GetStringMod(), GetWindMod()); } } @@ -12235,7 +12235,7 @@ void Bot::ProcessBotCommands(Client *c, const Seperator *sep) { c->Message(15, "I need something for my %s (Item %i)", equipped[i], i); continue; } - if((i == 13) && ((item2->ItemType == ItemType2HS) || (item2->ItemType == ItemType2HB) || (item2->ItemType == ItemType2HPierce))) { + if((i == 13) && ((item2->ItemType == ItemType2HSlash) || (item2->ItemType == ItemType2HBlunt) || (item2->ItemType == ItemType2HPiercing))) { is2Hweapon = true; } @@ -15061,7 +15061,7 @@ void Bot::ProcessBotCommands(Client *c, const Seperator *sep) { c->Message(13, "You must target a bot that you own."); if(targetedBot) { - if(targetedBot->GetSkill(TAUNT) > 0) { + if(targetedBot->GetSkill(SkillTaunt) > 0) { if(toggle) taunt = !targetedBot->taunting; @@ -16336,16 +16336,16 @@ void EntityList::BotPickLock(Bot* rogue) float bonus1 = 0.0f; float bonus2 = 0.0f; - float skill = rogue->GetSkill(PICK_LOCK); + float skill = rogue->GetSkill(SkillPickLock); if(item1) { // Hand slot item - if(item1->GetItem()->SkillModType == PICK_LOCK) { + if(item1->GetItem()->SkillModType == SkillPickLock) { bonus1 = skill * (((float)item1->GetItem()->SkillModValue) / 100.0f); } } if(item2) { // Primary slot item - if(item2->GetItem()->SkillModType == PICK_LOCK) { + if(item2->GetItem()->SkillModType == SkillPickLock) { bonus2 = skill * (((float)item2->GetItem()->SkillModValue) / 100.0f); } } diff --git a/zone/bot.h b/zone/bot.h index 9d6fc2ae5..2330bf366 100644 --- a/zone/bot.h +++ b/zone/bot.h @@ -134,8 +134,8 @@ public: Bot(uint32 botID, uint32 botOwnerCharacterID, uint32 botSpellsID, double totalPlayTime, uint32 lastZoneId, NPCType npcTypeData); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return (GetRaid() ? true : false); } @@ -169,23 +169,23 @@ public: virtual float GetProcChances(float &ProcBonus, float &ProcChance, uint16 weapon_speed, uint16 hand); virtual bool AvoidDamage(Mob* other, int32 &damage, bool CanRiposte); virtual int GetMonkHandToHandDamage(void); - virtual bool TryFinishingBlow(Mob *defender, SkillType skillinuse); + virtual bool TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse); virtual void DoRiposte(Mob* defender); - inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(OFFENSE)) * 9 / 10); } + inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); } inline virtual int16 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; } uint16 GetTotalATK(); uint16 GetATKRating(); uint16 GetPrimarySkillValue(); - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } - virtual void DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + virtual void DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); virtual void TryBackstab(Mob *other,int ReuseTime = 10); virtual void RogueBackstab(Mob* other, bool min_damage = false, int ReuseTime = 10); virtual void RogueAssassinate(Mob* other); virtual void DoClassAttacks(Mob *target, bool IsRiposte=false); - virtual bool TryHeadShot(Mob* defender, SkillType skillInUse); - virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); - virtual void ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg); + virtual bool TryHeadShot(Mob* defender, SkillUseTypes skillInUse); + virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); + virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg); bool CanDoSpecialAttack(Mob *other); virtual int32 CheckAggroAmount(uint16 spellid); virtual void CalcBonuses(); diff --git a/zone/botspellsai.cpp b/zone/botspellsai.cpp index 3f0f25bd8..bd2a5ad34 100644 --- a/zone/botspellsai.cpp +++ b/zone/botspellsai.cpp @@ -978,7 +978,7 @@ bool Bot::AI_IdleCastCheck() { if (AIautocastspell_timer->Check(false)) { #if MobAI_DEBUG_Spells >= 25 - cout << "Non-Engaged autocast check triggered: " << this->GetCleanName() << endl; + std::cout << "Non-Engaged autocast check triggered: " << this->GetCleanName() << std::endl; // cout undefine [CODEBUG] #endif AIautocastspell_timer->Disable(); //prevent the timer from going off AGAIN while we are casting. diff --git a/zone/client.cpp b/zone/client.cpp index 699bd3136..b043536b3 100644 --- a/zone/client.cpp +++ b/zone/client.cpp @@ -721,7 +721,7 @@ void Client::QueuePacket(const EQApplicationPacket* app, bool ack_req, CLIENT_CO void Client::FastQueuePacket(EQApplicationPacket** app, bool ack_req, CLIENT_CONN_STATUS required_state) { - //cout << "Sending: 0x" << hex << setw(4) << setfill('0') << (*app)->GetOpcode() << dec << ", size=" << (*app)->size << endl; + //std::cout << "Sending: 0x" << std::hex << std::setw(4) << std::setfill('0') << (*app)->GetOpcode() << std::dec << ", size=" << (*app)->size << std::endl; // if the program doesnt care about the status or if the status isnt what we requested if (required_state != CLIENT_CONNECTINGALL && client_state != required_state) { @@ -1386,7 +1386,7 @@ bool Client::UpdateLDoNPoints(int32 points, uint32 theme) return(false); } -void Client::SetSkill(SkillType skillid, uint16 value) { +void Client::SetSkill(SkillUseTypes skillid, uint16 value) { if (skillid > HIGHEST_SKILL) return; m_pp.skills[skillid] = value; // We need to be able to #setskill 254 and 255 to reset skills @@ -1419,7 +1419,7 @@ void Client::IncreaseLanguageSkill(int skill_id, int value) { Message_StringID( MT_Skills, LANG_SKILL_IMPROVED ); //Notify client } -void Client::AddSkill(SkillType skillid, uint16 value) { +void Client::AddSkill(SkillUseTypes skillid, uint16 value) { if (skillid > HIGHEST_SKILL) return; value = GetRawSkill(skillid) + value; @@ -1745,7 +1745,7 @@ void Client::SendManaUpdatePacket() { SendEnduranceUpdate(); } - //cout << "Sending mana update: " << (cur_mana - last_reported_mana) << endl; + //std::cout << "Sending mana update: " << (cur_mana - last_reported_mana) << std::endl; if (last_reported_mana != cur_mana || last_reported_endur != cur_end) { @@ -1858,53 +1858,53 @@ void Client::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) const ItemInst* inst = nullptr; if ((inst = m_inv[SLOT_HANDS]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_HANDS] = item->Material; - ns->spawn.colors[MATERIAL_HANDS].color = GetEquipmentColor(MATERIAL_HANDS); + ns->spawn.equipment[MaterialHands] = item->Material; + ns->spawn.colors[MaterialHands].color = GetEquipmentColor(MaterialHands); } if ((inst = m_inv[SLOT_HEAD]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_HEAD] = item->Material; - ns->spawn.colors[MATERIAL_HEAD].color = GetEquipmentColor(MATERIAL_HEAD); + ns->spawn.equipment[MaterialHead] = item->Material; + ns->spawn.colors[MaterialHead].color = GetEquipmentColor(MaterialHead); } if ((inst = m_inv[SLOT_ARMS]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_ARMS] = item->Material; - ns->spawn.colors[MATERIAL_ARMS].color = GetEquipmentColor(MATERIAL_ARMS); + ns->spawn.equipment[MaterialArms] = item->Material; + ns->spawn.colors[MaterialArms].color = GetEquipmentColor(MaterialArms); } if ((inst = m_inv[SLOT_BRACER01]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_BRACER]= item->Material; - ns->spawn.colors[MATERIAL_BRACER].color = GetEquipmentColor(MATERIAL_BRACER); + ns->spawn.equipment[MaterialWrist]= item->Material; + ns->spawn.colors[MaterialWrist].color = GetEquipmentColor(MaterialWrist); } if ((inst = m_inv[SLOT_BRACER02]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_BRACER]= item->Material; - ns->spawn.colors[MATERIAL_BRACER].color = GetEquipmentColor(MATERIAL_BRACER); + ns->spawn.equipment[MaterialWrist]= item->Material; + ns->spawn.colors[MaterialWrist].color = GetEquipmentColor(MaterialWrist); } if ((inst = m_inv[SLOT_CHEST]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_CHEST] = item->Material; - ns->spawn.colors[MATERIAL_CHEST].color = GetEquipmentColor(MATERIAL_CHEST); + ns->spawn.equipment[MaterialChest] = item->Material; + ns->spawn.colors[MaterialChest].color = GetEquipmentColor(MaterialChest); } if ((inst = m_inv[SLOT_LEGS]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_LEGS] = item->Material; - ns->spawn.colors[MATERIAL_LEGS].color = GetEquipmentColor(MATERIAL_LEGS); + ns->spawn.equipment[MaterialLegs] = item->Material; + ns->spawn.colors[MaterialLegs].color = GetEquipmentColor(MaterialLegs); } if ((inst = m_inv[SLOT_FEET]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); - ns->spawn.equipment[MATERIAL_FEET] = item->Material; - ns->spawn.colors[MATERIAL_FEET].color = GetEquipmentColor(MATERIAL_FEET); + ns->spawn.equipment[MaterialFeet] = item->Material; + ns->spawn.colors[MaterialFeet].color = GetEquipmentColor(MaterialFeet); } if ((inst = m_inv[SLOT_PRIMARY]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); if (strlen(item->IDFile) > 2) - ns->spawn.equipment[MATERIAL_PRIMARY] = atoi(&item->IDFile[2]); + ns->spawn.equipment[MaterialPrimary] = atoi(&item->IDFile[2]); } if ((inst = m_inv[SLOT_SECONDARY]) && inst->IsType(ItemClassCommon)) { item = inst->GetItem(); if (strlen(item->IDFile) > 2) - ns->spawn.equipment[MATERIAL_SECONDARY] = atoi(&item->IDFile[2]); + ns->spawn.equipment[MaterialSecondary] = atoi(&item->IDFile[2]); } //these two may be related to ns->spawn.texture @@ -2295,7 +2295,7 @@ uint64 Client::GetAllMoney() { (static_cast(m_pp.platinum_shared) * 1000))))); } -bool Client::CheckIncreaseSkill(SkillType skillid, Mob *against_who, int chancemodi) { +bool Client::CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi) { if (IsAIControlled()) // no skillups while chamred =p return false; if (skillid > HIGHEST_SKILL) @@ -2357,24 +2357,24 @@ void Client::CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill) { } } -bool Client::HasSkill(SkillType skill_id) const { +bool Client::HasSkill(SkillUseTypes skill_id) const { return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id)); } -bool Client::CanHaveSkill(SkillType skill_id) const { +bool Client::CanHaveSkill(SkillUseTypes skill_id) const { return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0); //if you don't have it by max level, then odds are you never will? } -uint16 Client::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Client::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } -uint8 Client::SkillTrainLevel(SkillType skillid, uint16 class_){ +uint8 Client::SkillTrainLevel(SkillUseTypes skillid, uint16 class_){ return(database.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel))); } -uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 maxSkill) +uint16 Client::GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16 maxSkill) { uint16 Result = maxSkill; @@ -2384,13 +2384,13 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max uint16 MaxSpecializations = GetAA(aaSecondaryForte) ? 2 : 1; - if(skillid >= SPECIALIZE_ABJURE && skillid <= SPECIALIZE_EVOCATION) + if(skillid >= SkillSpecializeAbjure && skillid <= SkillSpecializeEvocation) { bool HasPrimarySpecSkill = false; int NumberOfPrimarySpecSkills = 0; - for(int i = SPECIALIZE_ABJURE; i <= SPECIALIZE_EVOCATION; ++i) + for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i) { if(m_pp.skills[i] > 50) { @@ -2447,8 +2447,8 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max Message(13, "Your spell casting specializations skills have been reset. " "Only %i primary specialization skill is allowed.", MaxSpecializations); - for(int i = SPECIALIZE_ABJURE; i <= SPECIALIZE_EVOCATION; ++i) - SetSkill((SkillType)i, 1); + for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i) + SetSkill((SkillUseTypes)i, 1); Save(); @@ -2461,7 +2461,7 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max // This should possibly be handled by bonuses rather than here. switch(skillid) { - case TRACKING: + case SkillTracking: { Result += ((GetAA(aaAdvancedTracking) * 10) + (GetAA(aaTuneofPursuance) * 10)); break; @@ -2679,13 +2679,13 @@ bool Client::BindWound(Mob* bindmob, bool start, bool fail){ bind_out->type = 1; // Done QueuePacket(outapp); bind_out->type = 0; - CheckIncreaseSkill(BIND_WOUND, nullptr, 5); + CheckIncreaseSkill(SkillBindWound, nullptr, 5); int maxHPBonus = spellbonuses.MaxBindWound + itembonuses.MaxBindWound + aabonuses.MaxBindWound; int max_percent = 50 + 10 * maxHPBonus; - if(GetClass() == MONK && GetSkill(BIND_WOUND) > 200) { + if(GetClass() == MONK && GetSkill(SkillBindWound) > 200) { max_percent = 70 + 10 * maxHPBonus; } @@ -2699,10 +2699,10 @@ bool Client::BindWound(Mob* bindmob, bool start, bool fail){ int bindhps = 3; - if (GetSkill(BIND_WOUND) > 200) { - bindhps += GetSkill(BIND_WOUND)*4/10; - } else if (GetSkill(BIND_WOUND) >= 10) { - bindhps += GetSkill(BIND_WOUND)/4; + if (GetSkill(SkillBindWound) > 200) { + bindhps += GetSkill(SkillBindWound)*4/10; + } else if (GetSkill(SkillBindWound) >= 10) { + bindhps += GetSkill(SkillBindWound)/4; } //Implementation of aaMithanielsBinding is a guess (the multiplier) @@ -2762,25 +2762,25 @@ void Client::SetMaterial(int16 in_slot, uint32 item_id){ const Item_Struct* item = database.GetItem(item_id); if (item && (item->ItemClass==ItemClassCommon)) { if (in_slot==SLOT_HEAD) - m_pp.item_material[MATERIAL_HEAD] = item->Material; + m_pp.item_material[MaterialHead] = item->Material; else if (in_slot==SLOT_CHEST) - m_pp.item_material[MATERIAL_CHEST] = item->Material; + m_pp.item_material[MaterialChest] = item->Material; else if (in_slot==SLOT_ARMS) - m_pp.item_material[MATERIAL_ARMS] = item->Material; + m_pp.item_material[MaterialArms] = item->Material; else if (in_slot==SLOT_BRACER01) - m_pp.item_material[MATERIAL_BRACER] = item->Material; + m_pp.item_material[MaterialWrist] = item->Material; else if (in_slot==SLOT_BRACER02) - m_pp.item_material[MATERIAL_BRACER] = item->Material; + m_pp.item_material[MaterialWrist] = item->Material; else if (in_slot==SLOT_HANDS) - m_pp.item_material[MATERIAL_HANDS] = item->Material; + m_pp.item_material[MaterialHands] = item->Material; else if (in_slot==SLOT_LEGS) - m_pp.item_material[MATERIAL_LEGS] = item->Material; + m_pp.item_material[MaterialLegs] = item->Material; else if (in_slot==SLOT_FEET) - m_pp.item_material[MATERIAL_FEET] = item->Material; + m_pp.item_material[MaterialFeet] = item->Material; else if (in_slot==SLOT_PRIMARY) - m_pp.item_material[MATERIAL_PRIMARY] = atoi(item->IDFile+2); + m_pp.item_material[MaterialPrimary] = atoi(item->IDFile+2); else if (in_slot==SLOT_SECONDARY) - m_pp.item_material[MATERIAL_SECONDARY] = atoi(item->IDFile+2); + m_pp.item_material[MaterialSecondary] = atoi(item->IDFile+2); } } @@ -2963,25 +2963,25 @@ void Client::SetTint(int16 in_slot, uint32 color) { // Still need to reconcile bracer01 versus bracer02 void Client::SetTint(int16 in_slot, Color_Struct& color) { if (in_slot==SLOT_HEAD) - m_pp.item_tint[MATERIAL_HEAD].color=color.color; + m_pp.item_tint[MaterialHead].color=color.color; else if (in_slot==SLOT_ARMS) - m_pp.item_tint[MATERIAL_ARMS].color=color.color; + m_pp.item_tint[MaterialArms].color=color.color; else if (in_slot==SLOT_BRACER01) - m_pp.item_tint[MATERIAL_BRACER].color=color.color; + m_pp.item_tint[MaterialWrist].color=color.color; else if (in_slot==SLOT_BRACER02) - m_pp.item_tint[MATERIAL_BRACER].color=color.color; + m_pp.item_tint[MaterialWrist].color=color.color; else if (in_slot==SLOT_HANDS) - m_pp.item_tint[MATERIAL_HANDS].color=color.color; + m_pp.item_tint[MaterialHands].color=color.color; else if (in_slot==SLOT_PRIMARY) - m_pp.item_tint[MATERIAL_PRIMARY].color=color.color; + m_pp.item_tint[MaterialPrimary].color=color.color; else if (in_slot==SLOT_SECONDARY) - m_pp.item_tint[MATERIAL_SECONDARY].color=color.color; + m_pp.item_tint[MaterialSecondary].color=color.color; else if (in_slot==SLOT_CHEST) - m_pp.item_tint[MATERIAL_CHEST].color=color.color; + m_pp.item_tint[MaterialChest].color=color.color; else if (in_slot==SLOT_LEGS) - m_pp.item_tint[MATERIAL_LEGS].color=color.color; + m_pp.item_tint[MaterialLegs].color=color.color; else if (in_slot==SLOT_FEET) - m_pp.item_tint[MATERIAL_FEET].color=color.color; + m_pp.item_tint[MaterialFeet].color=color.color; } void Client::SetHideMe(bool flag) @@ -3050,25 +3050,25 @@ uint8 Client::SlotConvert(uint8 slot,bool bracer){ if(bracer) return SLOT_BRACER02; switch(slot){ - case MATERIAL_HEAD: + case MaterialHead: slot2=SLOT_HEAD; break; - case MATERIAL_CHEST: + case MaterialChest: slot2=SLOT_CHEST; break; - case MATERIAL_ARMS: + case MaterialArms: slot2=SLOT_ARMS; break; - case MATERIAL_BRACER: + case MaterialWrist: slot2=SLOT_BRACER01; break; - case MATERIAL_HANDS: + case MaterialHands: slot2=SLOT_HANDS; break; - case MATERIAL_LEGS: + case MaterialLegs: slot2=SLOT_LEGS; break; - case MATERIAL_FEET: + case MaterialFeet: slot2=SLOT_FEET; break; } @@ -3079,25 +3079,25 @@ uint8 Client::SlotConvert2(uint8 slot){ uint8 slot2=0; switch(slot){ case SLOT_HEAD: - slot2=MATERIAL_HEAD; + slot2=MaterialHead; break; case SLOT_CHEST: - slot2=MATERIAL_CHEST; + slot2=MaterialChest; break; case SLOT_ARMS: - slot2=MATERIAL_ARMS; + slot2=MaterialArms; break; case SLOT_BRACER01: - slot2=MATERIAL_BRACER; + slot2=MaterialWrist; break; case SLOT_HANDS: - slot2=MATERIAL_HANDS; + slot2=MaterialHands; break; case SLOT_LEGS: - slot2=MATERIAL_LEGS; + slot2=MaterialLegs; break; case SLOT_FEET: - slot2=MATERIAL_FEET; + slot2=MaterialFeet; break; } return slot2; @@ -3700,7 +3700,7 @@ void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const Item_ pick_out->coin = amt; pick_out->from = GetID(); pick_out->to = from->GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); if((type >= PickPocketPlatinum) && (type <= PickPocketCopper) && (amt == 0)) type = PickPocketFailed; @@ -3973,11 +3973,11 @@ void Client::UpdateLFP() { uint16 Client::GetPrimarySkillValue() { - SkillType skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill + SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill bool equiped = m_inv.GetItem(13); if (!equiped) - skill = HAND_TO_HAND; + skill = SkillHandtoHand; else { @@ -3985,44 +3985,44 @@ uint16 Client::GetPrimarySkillValue() switch (type) { - case ItemType1HS: // 1H Slashing + case ItemType1HSlash: // 1H Slashing { - skill = _1H_SLASHING; + skill = Skill1HSlashing; break; } - case ItemType2HS: // 2H Slashing + case ItemType2HSlash: // 2H Slashing { - skill = _2H_SLASHING; + skill = Skill2HSlashing; break; } - case ItemTypePierce: // Piercing + case ItemType1HPiercing: // Piercing { - skill = PIERCING; + skill = Skill1HPiercing; break; } - case ItemType1HB: // 1H Blunt + case ItemType1HBlunt: // 1H Blunt { - skill = _1H_BLUNT; + skill = Skill1HBlunt; break; } - case ItemType2HB: // 2H Blunt + case ItemType2HBlunt: // 2H Blunt { - skill = _2H_BLUNT; + skill = Skill2HBlunt; break; } - case ItemType2HPierce: // 2H Piercing + case ItemType2HPiercing: // 2H Piercing { - skill = PIERCING; + skill = Skill1HPiercing; // change to Skill2HPiercing once activated break; } - case ItemTypeHand2Hand: // Hand to Hand + case ItemTypeMartial: // Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } default: // All other types default to Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } } @@ -4037,7 +4037,7 @@ uint16 Client::GetTotalATK() uint16 WornCap = itembonuses.ATK; if(IsClient()) { - AttackRating = ((WornCap * 1.342) + (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); + AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement(); if (AttackRating < 10) @@ -4055,7 +4055,7 @@ uint16 Client::GetATKRating() { uint16 AttackRating = 0; if(IsClient()) { - AttackRating = (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); + AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); if (AttackRating < 10) AttackRating = 10; @@ -4406,7 +4406,7 @@ void Client::HandleLDoNOpen(NPC *target) AddEXP(target->GetLevel()*target->GetLevel()*2625/10, GetLevelCon(target->GetLevel())); } } - target->Death(this, 1, SPELL_UNKNOWN, HAND_TO_HAND); + target->Death(this, 1, SPELL_UNKNOWN, SkillHandtoHand); } } } @@ -4724,8 +4724,8 @@ void Client::ShowSkillsWindow() const char *WindowTitle = "Skills"; std::string WindowText; // using a map for easy alphabetizing of the skills list - std::map Skills; - std::map::iterator it; + std::map Skills; + std::map::iterator it; // this list of names must keep the same order as that in common/skills.h const char* SkillName[] = {"1H Blunt","1H Slashing","2H Blunt","2H Slashing","Abjuration","Alteration","Apply Poison","Archery", @@ -4737,7 +4737,7 @@ void Client::ShowSkillsWindow() "Alchemy","Baking","Tailoring","Sense Traps","Blacksmithing","Fletching","Brewing","Alcohol Tolerance","Begging","Jewelry Making", "Pottery","Percussion Instruments","Intimidation","Berserking","Taunt","Frenzy"}; for(int i = 0; i <= (int)HIGHEST_SKILL; i++) - Skills[SkillName[i]] = (SkillType)i; + Skills[SkillName[i]] = (SkillUseTypes)i; // print out all available skills for(it = Skills.begin(); it != Skills.end(); it++) { @@ -6122,7 +6122,7 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid made_npc->drakkin_details = GetDrakkinDetails(); made_npc->d_meele_texture1 = GetEquipmentMaterial(7); made_npc->d_meele_texture2 = GetEquipmentMaterial(8); - for (int i = 0; i < MAX_MATERIALS; i++) { + for (int i = 0; i < _MaterialCount; i++) { made_npc->armor_tint[i] = GetEquipmentColor(i); } made_npc->loottable_id = 0; diff --git a/zone/client.h b/zone/client.h index 630c65c7b..0209d422a 100644 --- a/zone/client.h +++ b/zone/client.h @@ -212,8 +212,8 @@ public: ~Client(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return (GetRaid() ? true : false); } @@ -284,7 +284,7 @@ public: void VoiceMacroReceived(uint32 Type, char *Target, uint32 MacroNumber); void SendSound(); void LearnRecipe(uint32 recipeID); - bool CanIncreaseTradeskill(SkillType tradeskill); + bool CanIncreaseTradeskill(SkillUseTypes tradeskill); EQApplicationPacket* ReturnItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type); @@ -391,7 +391,7 @@ public: virtual void CalcBonuses(); //these are all precalculated now inline virtual int16 GetAC() const { return AC; } - inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(OFFENSE)) * 9 / 10); } + inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); } inline virtual int16 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; } inline virtual int GetHaste() const { return Haste; } int GetRawACNoShield(int &shield_ac) const; @@ -650,29 +650,29 @@ public: void IncreaseSkill(int skill_id, int value = 1) { if (skill_id <= HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } } void IncreaseLanguageSkill(int skill_id, int value = 1); - virtual uint16 GetSkill(SkillType skill_id) const { if (skill_id <= HIGHEST_SKILL) { return((itembonuses.skillmod[skill_id] > 0)? m_pp.skills[skill_id]*(100 + itembonuses.skillmod[skill_id])/100 : m_pp.skills[skill_id]); } return 0; } - uint32 GetRawSkill(SkillType skill_id) const { if (skill_id <= HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; } - bool HasSkill(SkillType skill_id) const; - bool CanHaveSkill(SkillType skill_id) const; - void SetSkill(SkillType skill_num, uint16 value); - void AddSkill(SkillType skillid, uint16 value); + virtual uint16 GetSkill(SkillUseTypes skill_id) const { if (skill_id <= HIGHEST_SKILL) { return((itembonuses.skillmod[skill_id] > 0)? m_pp.skills[skill_id]*(100 + itembonuses.skillmod[skill_id])/100 : m_pp.skills[skill_id]); } return 0; } + uint32 GetRawSkill(SkillUseTypes skill_id) const { if (skill_id <= HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; } + bool HasSkill(SkillUseTypes skill_id) const; + bool CanHaveSkill(SkillUseTypes skill_id) const; + void SetSkill(SkillUseTypes skill_num, uint16 value); + void AddSkill(SkillUseTypes skillid, uint16 value); void CheckSpecializeIncrease(uint16 spell_id); void CheckSongSkillIncrease(uint16 spell_id); - bool CheckIncreaseSkill(SkillType skillid, Mob *against_who, int chancemodi = 0); + bool CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi = 0); void CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill); void SetLanguageSkill(int langid, int value); void SetHoTT(uint32 mobid); void ShowSkillsWindow(); void SendStatsWindow(Client* client, bool use_window); - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } - uint8 SkillTrainLevel(SkillType skillid, uint16 class_); + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + uint8 SkillTrainLevel(SkillUseTypes skillid, uint16 class_); void TradeskillSearchResults(const char *query, unsigned long qlen, unsigned long objtype, unsigned long someid); void SendTradeskillDetails(uint32 recipe_id); bool TradeskillExecute(DBTradeskillRecipe_Struct *spec); - void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillType tradeskill); + void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillUseTypes tradeskill); void GMKill(); inline bool IsMedding() const {return medding;} @@ -885,7 +885,7 @@ public: int GetNextAvailableSpellBookSlot(int starting_slot = 0); inline uint32 GetSpellByBookSlot(int book_slot) { return m_pp.spell_book[book_slot]; } inline bool HasSpellScribed(int spellid) { return (FindSpellBookSlotBySpellID(spellid) != -1 ? true : false); } - uint16 GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 maxSkill); + uint16 GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16 maxSkill); void SendPopupToClient(const char *Title, const char *Text, uint32 PopupID = 0, uint32 Buttons = 0, uint32 Duration = 0); void SendWindow(uint32 PopupID, uint32 NegativeID, uint32 Buttons, const char *ButtonName0, const char *ButtonName1, uint32 Duration, int title_type, Client* target, const char *Title, const char *Text, ...); bool PendingTranslocate; @@ -1153,11 +1153,11 @@ public: int16 GetActCHA() { return( std::min(GetMaxCHA(), GetCHA()) ); } void LoadAccountFlags(); void SetAccountFlag(std::string flag, std::string val); - std::string GetAccountFlag(std::string flag); float GetDamageMultiplier(SkillType); + std::string GetAccountFlag(std::string flag); float GetDamageMultiplier(SkillUseTypes); void Consume(const Item_Struct *item, uint8 type, int16 slot, bool auto_consume); - int mod_client_damage(int damage, SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other); + int mod_client_damage(int damage, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other); bool mod_client_message(char* message, uint8 chan_num); - bool mod_can_increase_skill(SkillType skillid, Mob* against_who); + bool mod_can_increase_skill(SkillUseTypes skillid, Mob* against_who); int16 mod_increase_skill_chance(int16 chance, Mob* against_who); int mod_bindwound_percent(int max_percent, Mob* bindmob); int mod_bindwound_hp(int bindhps, Mob* bindmob); @@ -1174,7 +1174,7 @@ public: int32 mod_client_xp(int32 in_exp, NPC *npc); uint32 mod_client_xp_for_level(uint32 xp, uint16 check_level); int mod_client_haste_cap(int cap); - int mod_consume(Item_Struct *item, ItemTypes type, int change); + int mod_consume(Item_Struct *item, ItemUseTypes type, int change); int mod_food_value(const Item_Struct *item, int change); int mod_drink_value(const Item_Struct *item, int change); diff --git a/zone/client_mods.cpp b/zone/client_mods.cpp index 94d7909b5..61580bc21 100644 --- a/zone/client_mods.cpp +++ b/zone/client_mods.cpp @@ -840,7 +840,7 @@ int16 Client::acmod() { int16 Client::CalcAC() { // new formula - int avoidance = (acmod() + ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)*16)/9); + int avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)*16)/9); if (avoidance < 0) avoidance = 0; @@ -848,12 +848,12 @@ int16 Client::CalcAC() { if (m_pp.class_ == WIZARD || m_pp.class_ == MAGICIAN || m_pp.class_ == NECROMANCER || m_pp.class_ == ENCHANTER) { //something is wrong with this, naked casters have the wrong natural AC // mitigation = (spellbonuses.AC/3) + (GetSkill(DEFENSE)/2) + (itembonuses.AC+1); - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); //this might be off by 4.. mitigation -= 4; } else { // mitigation = (spellbonuses.AC/4) + (GetSkill(DEFENSE)/3) + ((itembonuses.AC*4)/3); - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); if(m_pp.class_ == MONK) mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close... } @@ -892,11 +892,11 @@ int16 Client::GetACMit() { int mitigation = 0; if (m_pp.class_ == WIZARD || m_pp.class_ == MAGICIAN || m_pp.class_ == NECROMANCER || m_pp.class_ == ENCHANTER) { - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); mitigation -= 4; } else { - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); if(m_pp.class_ == MONK) mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close... } @@ -916,7 +916,7 @@ int16 Client::GetACMit() { int16 Client::GetACAvoid() { - int avoidance = (acmod() + ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)*16)/9); + int avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)*16)/9); if (avoidance < 0) avoidance = 0; @@ -1066,8 +1066,8 @@ int32 Client::CalcBaseManaRegen() int32 regen = 0; if (IsSitting() || (GetHorseId() != 0)) { - if(HasSkill(MEDITATE)) - regen = (((GetSkill(MEDITATE) / 10) + (clevel - (clevel / 4))) / 4) + 4; + if(HasSkill(SkillMeditate)) + regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4; else regen = 2; } @@ -1085,11 +1085,11 @@ int32 Client::CalcManaRegen() if (IsSitting() || (GetHorseId() != 0)) { BuffFadeBySitModifier(); - if(HasSkill(MEDITATE)) { + if(HasSkill(SkillMeditate)) { this->medding = true; - regen = (((GetSkill(MEDITATE) / 10) + (clevel - (clevel / 4))) / 4) + 4; + regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4; regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; - CheckIncreaseSkill(MEDITATE, nullptr, -5); + CheckIncreaseSkill(SkillMeditate, nullptr, -5); } else regen = 2 + spellbonuses.ManaRegen + itembonuses.ManaRegen; @@ -1803,47 +1803,47 @@ uint16 Mob::GetInstrumentMod(uint16 spell_id) const { //item mods are in 10ths of percent increases switch(spells[spell_id].skill) { - case PERCUSSION_INSTRUMENTS: + case SkillPercussionInstruments: if(itembonuses.percussionMod == 0 && spellbonuses.percussionMod == 0) effectmod = 10; - else if(GetSkill(PERCUSSION_INSTRUMENTS) == 0) + else if(GetSkill(SkillPercussionInstruments) == 0) effectmod = 10; else if(itembonuses.percussionMod > spellbonuses.percussionMod) effectmod = itembonuses.percussionMod; else effectmod = spellbonuses.percussionMod; break; - case STRINGED_INSTRUMENTS: + case SkillStringedInstruments: if(itembonuses.stringedMod == 0 && spellbonuses.stringedMod == 0) effectmod = 10; - else if(GetSkill(STRINGED_INSTRUMENTS) == 0) + else if(GetSkill(SkillStringedInstruments) == 0) effectmod = 10; else if(itembonuses.stringedMod > spellbonuses.stringedMod) effectmod = itembonuses.stringedMod; else effectmod = spellbonuses.stringedMod; break; - case WIND_INSTRUMENTS: + case SkillWindInstruments: if(itembonuses.windMod == 0 && spellbonuses.windMod == 0) effectmod = 10; - else if(GetSkill(WIND_INSTRUMENTS) == 0) + else if(GetSkill(SkillWindInstruments) == 0) effectmod = 10; else if(itembonuses.windMod > spellbonuses.windMod) effectmod = itembonuses.windMod; else effectmod = spellbonuses.windMod; break; - case BRASS_INSTRUMENTS: + case SkillBrassInstruments: if(itembonuses.brassMod == 0 && spellbonuses.brassMod == 0) effectmod = 10; - else if(GetSkill(BRASS_INSTRUMENTS) == 0) + else if(GetSkill(SkillBrassInstruments) == 0) effectmod = 10; else if(itembonuses.brassMod > spellbonuses.brassMod) effectmod = itembonuses.brassMod; else effectmod = spellbonuses.brassMod; break; - case SINGING: + case SkillSinging: if(itembonuses.singingMod == 0 && spellbonuses.singingMod == 0) effectmod = 10; else if(itembonuses.singingMod > spellbonuses.singingMod) @@ -1856,7 +1856,7 @@ uint16 Mob::GetInstrumentMod(uint16 spell_id) const { break; } - if(spells[spell_id].skill == SINGING) + if(spells[spell_id].skill == SkillSinging) { effectmod += 2*GetAA(aaSingingMastery); effectmod += 2*GetAA(aaImprovedSingingMastery); diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index 94a95cd9b..f28008ae3 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -414,14 +414,14 @@ int Client::HandlePacket(const EQApplicationPacket *app) } #if EQDEBUG >= 9 - std::cout << "Received 0x" << hex << setw(4) << setfill('0') << opcode << ", size=" << dec << app->size << std::endl; + std::cout << "Received 0x" << std::hex << std::setw(4) << std::setfill('0') << opcode << ", size=" << std::dec << app->size << std::endl; #endif #ifdef SOLAR if(0 && opcode != OP_ClientUpdate) { LogFile->write(EQEMuLog::Debug,"HandlePacket() OPCODE debug enabled client %s", GetName()); - std::cerr << "OPCODE: " << hex << setw(4) << setfill('0') << opcode << dec << ", size: " << app->size << std::endl; + std::cerr << "OPCODE: " << std::hex << std::setw(4) << std::setfill('0') << opcode << std::dec << ", size: " << app->size << std::endl; DumpPacket(app); } #endif @@ -1232,7 +1232,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) if(IsTracking() && ((x_pos!=ppu->x_pos) || (y_pos!=ppu->y_pos))){ if(MakeRandomFloat(0, 100) < 70)//should be good - CheckIncreaseSkill(TRACKING, nullptr, -20); + CheckIncreaseSkill(SkillTracking, nullptr, -20); } // Break Hide if moving without sneaking and set rewind timer if moved @@ -1275,7 +1275,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) { if(zone->watermap->InLiquid(x_pos, y_pos, z_pos)) { - CheckIncreaseSkill(SWIMMING, nullptr, -17); + CheckIncreaseSkill(SkillSwimming, nullptr, -17); } } @@ -2591,7 +2591,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) return; } - if(!HasSkill(BEGGING) || !GetTarget()) + if(!HasSkill(SkillBegging) || !GetTarget()) return; if(GetTarget()->GetClass() == LDON_TREASURE) @@ -2629,7 +2629,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) return; } - uint16 CurrentSkill = GetSkill(BEGGING); + uint16 CurrentSkill = GetSkill(SkillBegging); float ChanceToBeg=((float)(CurrentSkill/700.0f) + 0.15f) * 100; @@ -2651,7 +2651,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) } QueuePacket(outapp); safe_delete(outapp); - CheckIncreaseSkill(BEGGING, nullptr, -10); + CheckIncreaseSkill(SkillBegging, nullptr, -10); } void Client::Handle_OP_TestBuff(const EQApplicationPacket *app) @@ -2914,7 +2914,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app) if (sa->type == AT_Invis) { if(sa->parameter != 0) { - if(!HasSkill(HIDE) && GetSkill(HIDE) == 0) + if(!HasSkill(SkillHide) && GetSkill(SkillHide) == 0) { if(GetClientVersion() < EQClientSoF) { @@ -2973,7 +2973,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app) /* else if (sa->parameter == 0x05) { // Illusion - cout << "Illusion packet recv'd:" << endl; + std::cout << "Illusion packet recv'd:" << std::endl; DumpPacket(app); } */ @@ -3015,7 +3015,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app) else if (sa->type == AT_Sneak) { if(sa->parameter != 0) { - if(!HasSkill(SNEAK)) + if(!HasSkill(SkillSneak)) { char *hack_str = nullptr; MakeAnyLenString(&hack_str, "Player sent OP_SpawnAppearance with AT_Sneak: %i", sa->parameter); @@ -3099,7 +3099,7 @@ void Client::Handle_OP_Death(const EQApplicationPacket *app) return; Mob* killer = entity_list.GetMob(ds->killer_id); - Death(killer, ds->damage, ds->spell_id, (SkillType)ds->attack_skill); + Death(killer, ds->damage, ds->spell_id, (SkillUseTypes)ds->attack_skill); return; } @@ -3354,8 +3354,8 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app) //BreakInvis(); - uint16 primfeign = GetSkill(FEIGN_DEATH); - uint16 secfeign = GetSkill(FEIGN_DEATH); + uint16 primfeign = GetSkill(SkillFeignDeath); + uint16 secfeign = GetSkill(SkillFeignDeath); if (primfeign > 100) { primfeign = 100; secfeign = secfeign - 100; @@ -3373,13 +3373,13 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app) SetFeigned(true); } - CheckIncreaseSkill(FEIGN_DEATH, nullptr, 5); + CheckIncreaseSkill(SkillFeignDeath, nullptr, 5); return; } void Client::Handle_OP_Sneak(const EQApplicationPacket *app) { - if(!HasSkill(SNEAK) && GetSkill(SNEAK) == 0) { + if(!HasSkill(SkillSneak) && GetSkill(SkillSneak) == 0) { return; //You cannot sneak if you do not have sneak } @@ -3403,9 +3403,9 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app) safe_delete(outapp); } else { - CheckIncreaseSkill(SNEAK, nullptr, 5); + CheckIncreaseSkill(SkillSneak, nullptr, 5); } - float hidechance = ((GetSkill(SNEAK)/300.0f) + .25) * 100; + float hidechance = ((GetSkill(SkillSneak)/300.0f) + .25) * 100; float random = MakeRandomFloat(0, 99); if(!was && random < hidechance) { sneaking = true; @@ -3434,7 +3434,7 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app) void Client::Handle_OP_Hide(const EQApplicationPacket *app) { - if(!HasSkill(HIDE) && GetSkill(HIDE) == 0) + if(!HasSkill(SkillHide) && GetSkill(SkillHide) == 0) { //Can not be able to train hide but still have it from racial though return; //You cannot hide if you do not have hide @@ -3447,9 +3447,9 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app) int reuse = HideReuseTime - GetAA(209); p_timers.Start(pTimerHide, reuse-1); - float hidechance = ((GetSkill(HIDE)/250.0f) + .25) * 100; + float hidechance = ((GetSkill(SkillHide)/250.0f) + .25) * 100; float random = MakeRandomFloat(0, 100); - CheckIncreaseSkill(HIDE, nullptr, 5); + CheckIncreaseSkill(SkillHide, nullptr, 5); if (random < hidechance) { EQApplicationPacket* outapp = new EQApplicationPacket(OP_SpawnAppearance, sizeof(SpawnAppearance_Struct)); SpawnAppearance_Struct* sa_out = (SpawnAppearance_Struct*)outapp->pBuffer; @@ -3470,7 +3470,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app) SimpleMessage_Struct *msg=(SimpleMessage_Struct *)outapp->pBuffer; msg->color=0x010E; if (!auto_attack && entity_list.Fighting(this)) { - if (MakeRandomInt(0, 260) < (int)GetSkill(HIDE)) { + if (MakeRandomInt(0, 260) < (int)GetSkill(SkillHide)) { msg->string_id=343; entity_list.Evade(this); } else { @@ -3753,14 +3753,14 @@ void Client::Handle_OP_LDoNSenseTraps(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(SENSE_TRAPS)) + if(HasSkill(SkillSenseTraps)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(SENSE_TRAPS), LDoNTypeMechanical); + HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(SkillSenseTraps), LDoNTypeMechanical); } else Message(13, "You do not have the sense traps skill."); @@ -3772,14 +3772,14 @@ void Client::Handle_OP_LDoNDisarmTraps(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(DISARM_TRAPS)) + if(HasSkill(SkillDisarmTraps)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNDisarm(target->CastToNPC(), GetSkill(DISARM_TRAPS), LDoNTypeMechanical); + HandleLDoNDisarm(target->CastToNPC(), GetSkill(SkillDisarmTraps), LDoNTypeMechanical); } else Message(13, "You do not have the disarm trap skill."); @@ -3791,14 +3791,14 @@ void Client::Handle_OP_LDoNPickLock(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(PICK_LOCK)) + if(HasSkill(SkillPickLock)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNPickLock(target->CastToNPC(), GetSkill(PICK_LOCK), LDoNTypeMechanical); + HandleLDoNPickLock(target->CastToNPC(), GetSkill(SkillPickLock), LDoNTypeMechanical); } else Message(13, "You do not have the pick locks skill."); @@ -4643,9 +4643,9 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app) const ItemInst *inst = GetInv().GetItem(alc->from_slot); if (inst && inst->GetItem()->ItemType == ItemTypeAlcohol) { entity_list.MessageClose_StringID(this, true, 50, 0, DRINKING_MESSAGE, GetName(), inst->GetItem()->Name); - CheckIncreaseSkill(ALCOHOL_TOLERANCE, nullptr, 25); + CheckIncreaseSkill(SkillAlcoholTolerance, nullptr, 25); - int16 AlcoholTolerance = GetSkill(ALCOHOL_TOLERANCE); + int16 AlcoholTolerance = GetSkill(SkillAlcoholTolerance); int16 IntoxicationIncrease; if(GetClientVersion() < EQClientSoD) @@ -6021,7 +6021,7 @@ void Client::Handle_OP_RecipesFavorite(const EQApplicationPacket *app) " FROM tradeskill_recipe AS tr " " LEFT JOIN tradeskill_recipe_entries AS tre ON tr.id=tre.recipe_id " " LEFT JOIN (SELECT recipe_id, madecount FROM char_recipe_list WHERE char_id = %u) AS crl ON tr.id=crl.recipe_id " - " WHERE tr.id IN (%s) " + " WHERE tr.enabled <> 0 AND tr.id IN (%s) " " AND tr.must_learn & 0x20 <> 0x20 AND ((tr.must_learn & 0x3 <> 0 AND crl.madecount IS NOT NULL) OR (tr.must_learn & 0x3 = 0)) " " GROUP BY tr.id " " HAVING sum(if(tre.item_id %s AND tre.iscontainer > 0,1,0)) > 0 " @@ -6076,7 +6076,7 @@ void Client::Handle_OP_RecipesSearch(const EQApplicationPacket *app) " FROM tradeskill_recipe AS tr " " LEFT JOIN tradeskill_recipe_entries AS tre ON tr.id=tre.recipe_id " " LEFT JOIN (SELECT recipe_id, madecount FROM char_recipe_list WHERE char_id = %u) AS crl ON tr.id=crl.recipe_id " - " WHERE %s tr.trivial >= %u AND tr.trivial <= %u " + " WHERE %s tr.trivial >= %u AND tr.trivial <= %u AND tr.enabled <> 0 " " AND tr.must_learn & 0x20 <> 0x20 AND((tr.must_learn & 0x3 <> 0 AND crl.madecount IS NOT NULL) OR (tr.must_learn & 0x3 = 0)) " " GROUP BY tr.id " " HAVING sum(if(tre.item_id %s AND tre.iscontainer > 0,1,0)) > 0 " @@ -7574,7 +7574,7 @@ void Client::Handle_OP_Forage(const EQApplicationPacket *app) void Client::Handle_OP_Mend(const EQApplicationPacket *app) { - if(!HasSkill(MEND)) + if(!HasSkill(SkillMend)) return; if(!p_timers.Expired(&database, pTimerMend, false)) { @@ -7585,7 +7585,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) int mendhp = GetMaxHP() / 4; int currenthp = GetHP(); - if (MakeRandomInt(0, 199) < (int)GetSkill(MEND)) { + if (MakeRandomInt(0, 199) < (int)GetSkill(SkillMend)) { int criticalchance = 0; switch(GetAA(aaCriticalMend)){ case 1: @@ -7614,7 +7614,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) 0 skill - 25% chance to worsen 20 skill - 23% chance to worsen 50 skill - 16% chance to worsen */ - if ((GetSkill(MEND) <= 75) && (MakeRandomInt(GetSkill(MEND),100) < 75) && (MakeRandomInt(1, 3) == 1)) + if ((GetSkill(SkillMend) <= 75) && (MakeRandomInt(GetSkill(SkillMend),100) < 75) && (MakeRandomInt(1, 3) == 1)) { SetHP(currenthp > mendhp ? (GetHP() - mendhp) : 1); SendHPUpdate(); @@ -7624,7 +7624,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) Message_StringID(4,MEND_FAIL); } - CheckIncreaseSkill(MEND, nullptr, 10); + CheckIncreaseSkill(SkillMend, nullptr, 10); return; } @@ -7682,7 +7682,7 @@ void Client::Handle_OP_EnvDamage(const EQApplicationPacket *app) { mod_client_death_env(); - Death(0, 32000, SPELL_UNKNOWN, HAND_TO_HAND); + Death(0, 32000, SPELL_UNKNOWN, SkillHandtoHand); } SendHPUpdate(); return; @@ -7700,7 +7700,7 @@ void Client::Handle_OP_Damage(const EQApplicationPacket *app) // Broadcast to other clients CombatDamage_Struct* damage = (CombatDamage_Struct*)app->pBuffer; //dont send to originator of falling damage packets - entity_list.QueueClients(this, app, (damage->type==FallingDamageType)); + entity_list.QueueClients(this, app, (damage->type==DamageTypeFalling)); return; } @@ -7958,7 +7958,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) DumpPacket(app); } - if(!HasSkill(PICK_POCKETS)) + if(!HasSkill(SkillPickPockets)) { return; } @@ -7983,7 +7983,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -7996,7 +7996,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -8012,7 +8012,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -8062,10 +8062,10 @@ void Client::Handle_OP_Track(const EQApplicationPacket *app) if(GetClass() != RANGER && GetClass() != DRUID && GetClass() != BARD) return; - if( GetSkill(TRACKING)==0 ) - SetSkill(TRACKING,1); + if( GetSkill(SkillTracking)==0 ) + SetSkill(SkillTracking,1); else - CheckIncreaseSkill(TRACKING, nullptr, 15); + CheckIncreaseSkill(SkillTracking, nullptr, 15); if(!entity_list.MakeTrackPacket(this)) LogFile->write(EQEMuLog::Error, "Unable to generate OP_Track packet requested by client."); @@ -8145,7 +8145,7 @@ void Client::Handle_OP_Split(const EQApplicationPacket *app) void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) { - if (!HasSkill(SENSE_TRAPS)) + if (!HasSkill(SkillSenseTraps)) return; if(!p_timers.Expired(&database, pTimerSenseTraps, false)) { @@ -8168,10 +8168,10 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) Trap* trap = entity_list.FindNearbyTrap(this,800); - CheckIncreaseSkill(SENSE_TRAPS, nullptr); + CheckIncreaseSkill(SkillSenseTraps, nullptr); if (trap && trap->skill > 0) { - int uskill = GetSkill(SENSE_TRAPS); + int uskill = GetSkill(SkillSenseTraps); if ((MakeRandomInt(0,99) + uskill) >= (MakeRandomInt(0,99) + trap->skill*0.75)) { float xdif = trap->x - GetX(); @@ -8212,7 +8212,7 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) { - if (!HasSkill(DISARM_TRAPS)) + if (!HasSkill(SkillDisarmTraps)) return; if(!p_timers.Expired(&database, pTimerDisarmTraps, false)) { @@ -8236,7 +8236,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) Trap* trap = entity_list.FindNearbyTrap(this,60); if (trap && trap->detected) { - int uskill = GetSkill(DISARM_TRAPS); + int uskill = GetSkill(SkillDisarmTraps); if ((MakeRandomInt(0, 49) + uskill) >= (MakeRandomInt(0, 49) + trap->skill)) { Message(MT_Skills,"You disarm a trap."); @@ -8254,7 +8254,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) Message(MT_Skills,"You failed to disarm a trap."); } } - CheckIncreaseSkill(DISARM_TRAPS, nullptr); + CheckIncreaseSkill(SkillDisarmTraps, nullptr); return; } Message(MT_Skills,"You did not find any traps close enough to disarm."); @@ -8476,8 +8476,8 @@ void Client::Handle_OP_SetRunMode(const EQApplicationPacket *app) void Client::Handle_OP_SafeFallSuccess(const EQApplicationPacket *app) // bit of a misnomer, sent whenever safe fall is used (success of fail) { - if(HasSkill(SAFE_FALL)) //this should only get called if the client has safe fall, but just in case... - CheckIncreaseSkill(SAFE_FALL, nullptr); //check for skill up + if(HasSkill(SkillSafeFall)) //this should only get called if the client has safe fall, but just in case... + CheckIncreaseSkill(SkillSafeFall, nullptr); //check for skill up } void Client::Handle_OP_Heartbeat(const EQApplicationPacket *app) @@ -8708,7 +8708,7 @@ bool Client::FinishConnState2(DBAsyncWork* dbaw) { //uint32 aalen = database.GetPlayerAlternateAdv(account_id, name, &aa); //if (aalen == 0) { - // cout << "Client dropped: !GetPlayerAlternateAdv, name=" << name << endl; + // std::cout << "Client dropped: !GetPlayerAlternateAdv, name=" << name << std::endl; // return false; //} @@ -8910,8 +8910,8 @@ bool Client::FinishConnState2(DBAsyncWork* dbaw) { if(m_pp.ldon_points_available > 0x77359400) m_pp.ldon_points_available = 0x77359400; - if(GetSkill(SWIMMING) < 100) - SetSkill(SWIMMING,100); + if(GetSkill(SkillSwimming) < 100) + SetSkill(SkillSwimming,100); //pull AAs from the PP for(uint32 a=0; a < MAX_PP_AA_ARRAY; a++){ @@ -11029,12 +11029,12 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app) { } else if(GetClass() == ROGUE) { - if ((PrimaryWeapon && PrimaryWeapon->GetItem()->ItemType == ItemTypePierce) || - (SecondaryWeapon && SecondaryWeapon->GetItem()->ItemType == ItemTypePierce)) { - float SuccessChance = (GetSkill(APPLY_POISON) + GetLevel()) / 400.0f; + if ((PrimaryWeapon && PrimaryWeapon->GetItem()->ItemType == ItemType1HPiercing) || + (SecondaryWeapon && SecondaryWeapon->GetItem()->ItemType == ItemType1HPiercing)) { + float SuccessChance = (GetSkill(SkillApplyPoison) + GetLevel()) / 400.0f; double ChanceRoll = MakeRandomFloat(0, 1); - CheckIncreaseSkill(APPLY_POISON, nullptr, 10); + CheckIncreaseSkill(SkillApplyPoison, nullptr, 10); if(ChanceRoll < SuccessChance) { ApplyPoisonSuccessResult = 1; diff --git a/zone/client_process.cpp b/zone/client_process.cpp index 156301859..8bb3fd67c 100644 --- a/zone/client_process.cpp +++ b/zone/client_process.cpp @@ -314,7 +314,7 @@ bool Client::Process() { ranged_timer.Start(); } } - else if(ranged->GetItem() && (ranged->GetItem()->ItemType == ItemTypeThrowing || ranged->GetItem()->ItemType == ItemTypeThrowingv2)){ + else if(ranged->GetItem() && (ranged->GetItem()->ItemType == ItemTypeLargeThrowing || ranged->GetItem()->ItemType == ItemTypeSmallThrowing)){ if(ranged_timer.Check(false)){ if(GetTarget() && (GetTarget()->IsNPC() || GetTarget()->IsClient())){ if(!GetTarget()->BehindMob(this, GetTarget()->GetX(), GetTarget()->GetY())){ @@ -405,7 +405,7 @@ bool Client::Process() { bool tripleAttackSuccess = false; if( auto_attack_target && CanThisClassDoubleAttack() ) { - CheckIncreaseSkill(DOUBLE_ATTACK, auto_attack_target, -10); + CheckIncreaseSkill(SkillDoubleAttack, auto_attack_target, -10); if(CheckDoubleAttack()) { //should we allow rampage on double attack? if(CheckAAEffect(aaEffectRampage)) { @@ -449,9 +449,9 @@ bool Client::Process() { if (auto_attack_target && ExtraAttackChanceBonus) { ItemInst *wpn = GetInv().GetItem(SLOT_PRIMARY); if(wpn){ - if(wpn->GetItem()->ItemType == ItemType2HS || - wpn->GetItem()->ItemType == ItemType2HB || - wpn->GetItem()->ItemType == ItemType2HPierce ) + if(wpn->GetItem()->ItemType == ItemType2HSlash || + wpn->GetItem()->ItemType == ItemType2HBlunt || + wpn->GetItem()->ItemType == ItemType2HPiercing ) { if(MakeRandomInt(0, 100) < ExtraAttackChanceBonus) { @@ -494,12 +494,12 @@ bool Client::Process() { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; float random = MakeRandomFloat(0, 1); - CheckIncreaseSkill(DUAL_WIELD, auto_attack_target, -10); + CheckIncreaseSkill(SkillDualWield, auto_attack_target, -10); if (random < DualWieldProbability){ // Max 78% of DW if(CheckAAEffect(aaEffectRampage)) { entity_list.AEAttack(this, 30, 14); @@ -1589,9 +1589,9 @@ void Client::OPGMTraining(const EQApplicationPacket *app) if(DistNoRoot(*pTrainer) > USE_NPC_RANGE2) return; - SkillType sk; - for (sk = _1H_BLUNT; sk <= HIGHEST_SKILL; sk = (SkillType)(sk+1)) { - if(sk == TINKERING && GetRace() != GNOME) { + SkillUseTypes sk; + for (sk = Skill1HBlunt; sk <= HIGHEST_SKILL; sk = (SkillUseTypes)(sk+1)) { + if(sk == SkillTinkering && GetRace() != GNOME) { gmtrain->skills[sk] = 0; //Non gnomes can't tinker! } else { gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules(sk, MaxSkill(sk, GetClass(), RuleI(Character, MaxLevel))); @@ -1688,7 +1688,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) return; } - SkillType skill = (SkillType) gmskill->skill_id; + SkillUseTypes skill = (SkillUseTypes) gmskill->skill_id; if(!CanHaveSkill(skill)) { mlog(CLIENT__ERROR, "Tried to train skill %d, which is not allowed.", skill); @@ -1712,27 +1712,27 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) SetSkill(skill, t_level); } else { switch(skill) { - case BREWING: - case MAKE_POISON: - case TINKERING: - case RESEARCH: - case ALCHEMY: - case BAKING: - case TAILORING: - case BLACKSMITHING: - case FLETCHING: - case JEWELRY_MAKING: - case POTTERY: + case SkillBrewing: + case SkillMakePoison: + case SkillTinkering: + case SkillResearch: + case SkillAlchemy: + case SkillBaking: + case SkillTailoring: + case SkillBlacksmithing: + case SkillFletching: + case SkillJewelryMaking: + case SkillPottery: if(skilllevel >= RuleI(Skills, MaxTrainTradeskills)) { Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName()); return; } break; - case SPECIALIZE_ABJURE: - case SPECIALIZE_ALTERATION: - case SPECIALIZE_CONJURATION: - case SPECIALIZE_DIVINATION: - case SPECIALIZE_EVOCATION: + case SkillSpecializeAbjure: + case SkillSpecializeAlteration: + case SkillSpecializeConjuration: + case SkillSpecializeDivination: + case SkillSpecializeEvocation: if(skilllevel >= RuleI(Skills, MaxTrainSpecializations)) { Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName()); return; @@ -1749,7 +1749,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) return; } - if(gmskill->skill_id >= SPECIALIZE_ABJURE && gmskill->skill_id <= SPECIALIZE_EVOCATION) + if(gmskill->skill_id >= SkillSpecializeAbjure && gmskill->skill_id <= SkillSpecializeEvocation) { int MaxSpecSkill = GetMaxSkillAfterSpecializationRules(skill, MaxSkillValue); if (skilllevel >= MaxSpecSkill) @@ -1787,7 +1787,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) gmtsc->SkillID += 100; } else - gmtsc->NewSkill = (GetRawSkill((SkillType)gmtsc->SkillID) == 1); + gmtsc->NewSkill = (GetRawSkill((SkillUseTypes)gmtsc->SkillID) == 1); gmtsc->Cost = Cost; diff --git a/zone/command.cpp b/zone/command.cpp index 7080b4f3c..93cdf6d46 100644 --- a/zone/command.cpp +++ b/zone/command.cpp @@ -24,7 +24,7 @@ 2. Add the function in this file. 3. In the command_init function you must add a call to command_add for your function. If you want an alias for your command, add - a second call to command_add with the descriptin and access args + a second call to command_add with the description and access args set to nullptr and 0 respectively since they aren't used when adding an alias. The function pointers being equal is makes it an alias. The access level you set with command_add is only a default if @@ -445,7 +445,9 @@ int command_init(void) { command_add("xtargets", "Show your targets Extended Targets and optionally set how many xtargets they can have.", 250, command_xtargets) || command_add("zopp", "Troubleshooting command - Sends a fake item packet to you. No server reference is created.", 250, command_zopp) || command_add("augmentitem", "Force augments an item. Must have the augment item window open.", 250, command_augmentitem) || - command_add("questerrors", "Shows quest errors.", 100, command_questerrors) + command_add("questerrors", "Shows quest errors.", 100, command_questerrors) || + command_add("enablerecipe", "[recipe_id] - Enables a recipe using the recipe id.", 80, command_enablerecipe) || + command_add("disablerecipe", "[recipe_id] - Disables a recipe using the recipe id.", 80, command_disablerecipe) ) { command_deinit(); @@ -2462,7 +2464,7 @@ void command_showskills(Client *c, const Seperator *sep) t=c->GetTarget()->CastToClient(); c->Message(0, "Skills for %s", t->GetName()); - for (SkillType i=_1H_BLUNT; i <= HIGHEST_SKILL; i=(SkillType)(i+1)) + for (SkillUseTypes i=Skill1HBlunt; i <= HIGHEST_SKILL; i=(SkillUseTypes)(i+1)) c->Message(0, "Skill [%d] is at [%d]", i, t->GetSkill(i)); } @@ -2623,7 +2625,7 @@ void command_setskill(Client *c, const Seperator *sep) int skill_num = atoi(sep->arg[1]); uint16 skill_value = atoi(sep->arg[2]); if(skill_num < HIGHEST_SKILL) - c->GetTarget()->CastToClient()->SetSkill((SkillType)skill_num, skill_value); + c->GetTarget()->CastToClient()->SetSkill((SkillUseTypes)skill_num, skill_value); } } @@ -2641,7 +2643,7 @@ void command_setskillall(Client *c, const Seperator *sep) if (c->Admin() >= commandSetSkillsOther || c->GetTarget()==c || c->GetTarget()==0) { LogFile->write(EQEMuLog::Normal,"Set ALL skill request from %s, target:%s", c->GetName(), c->GetTarget()->GetName()); uint16 level = atoi(sep->arg[1]); - for(SkillType skill_num=_1H_BLUNT;skill_num <= HIGHEST_SKILL;skill_num=(SkillType)(skill_num+1)) { + for(SkillUseTypes skill_num=Skill1HBlunt;skill_num <= HIGHEST_SKILL;skill_num=(SkillUseTypes)(skill_num+1)) { c->GetTarget()->CastToClient()->SetSkill(skill_num, level); } } @@ -4586,7 +4588,7 @@ void command_damage(Client *c, const Seperator *sep) if (nkdmg > 2100000000) c->Message(0, "Enter a value less then 2,100,000,000."); else - c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, HAND_TO_HAND, false); + c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, SkillHandtoHand, false); } } @@ -5302,7 +5304,7 @@ void command_manaburn(Client *c, const Seperator *sep) int nukedmg=(c->GetMana())*2; if (nukedmg>0) { - target->Damage(c, nukedmg, 2751, ABJURE/*hackish*/); + target->Damage(c, nukedmg, 2751, SkillAbjuration/*hackish*/); c->Message(4,"You unleash an enormous blast of magical energies."); } LogFile->write(EQEMuLog::Normal,"Manaburn request from %s, damage: %d", c->GetName(), nukedmg); @@ -11042,14 +11044,14 @@ void command_max_all_skills(Client *c, const Seperator *sep) { for(int i = 0; i <= HIGHEST_SKILL; ++i) { - if(i >= SPECIALIZE_ABJURE && i <= SPECIALIZE_EVOCATION) + if(i >= SkillSpecializeAbjure && i <= SkillSpecializeEvocation) { - c->SetSkill((SkillType)i, 50); + c->SetSkill((SkillUseTypes)i, 50); } else { - int max_skill_level = database.GetSkillCap(c->GetClass(), (SkillType)i, c->GetLevel()); - c->SetSkill((SkillType)i, max_skill_level); + int max_skill_level = database.GetSkillCap(c->GetClass(), (SkillUseTypes)i, c->GetLevel()); + c->SetSkill((SkillUseTypes)i, max_skill_level); } } } @@ -11139,14 +11141,14 @@ void command_disarmtrap(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(DISARM_TRAPS)) + if(c->HasSkill(SkillDisarmTraps)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(DISARM_TRAPS), LDoNTypeMechanical); + c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(SkillDisarmTraps), LDoNTypeMechanical); } else c->Message(13, "You do not have the disarm trap skill."); @@ -11164,14 +11166,14 @@ void command_sensetrap(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(SENSE_TRAPS)) + if(c->HasSkill(SkillSenseTraps)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(SENSE_TRAPS), LDoNTypeMechanical); + c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(SkillSenseTraps), LDoNTypeMechanical); } else c->Message(13, "You do not have the sense traps skill."); @@ -11189,14 +11191,14 @@ void command_picklock(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(PICK_LOCK)) + if(c->HasSkill(SkillPickLock)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(PICK_LOCK), LDoNTypeMechanical); + c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(SkillPickLock), LDoNTypeMechanical); } else c->Message(13, "You do not have the pick locks skill."); @@ -11426,3 +11428,45 @@ void command_questerrors(Client *c, const Seperator *sep) ++iter; } } + +void command_enablerecipe(Client *c, const Seperator *sep) +{ + uint32 recipe_id = 0; + if (c) { + if (sep->argnum == 1) { + recipe_id = atoi(sep->arg[1]); + } + else { + c->Message(0, "Invalid number of arguments.\nUsage: #enablerecipe recipe_id"); + return; + } + if (recipe_id > 0) { + database.EnableRecipe(recipe_id); + c->Message(0, "Recipe enabled."); + } + else { + c->Message(0, "Invalid recipe id.\nUsage: #enablerecipe recipe_id"); + } + } +} + +void command_disablerecipe(Client *c, const Seperator *sep) +{ + uint32 recipe_id = 0; + if (c) { + if (sep->argnum == 1) { + recipe_id = atoi(sep->arg[1]); + } + else { + c->Message(0, "Invalid number of arguments.\nUsage: #disablerecipe recipe_id"); + return; + } + if (recipe_id > 0) { + database.DisableRecipe(recipe_id); + c->Message(0, "Recipe disabled."); + } + else { + c->Message(0, "Invalid recipe id.\nUsage: #disablerecipe recipe_id"); + } + } +} diff --git a/zone/command.h b/zone/command.h index cf4a72228..c8860b8a9 100644 --- a/zone/command.h +++ b/zone/command.h @@ -320,6 +320,8 @@ void command_xtargets(Client *c, const Seperator *sep); void command_zopp(Client *c, const Seperator *sep); void command_augmentitem(Client *c, const Seperator *sep); void command_questerrors(Client *c, const Seperator *sep); +void command_enablerecipe(Client *c, const Seperator *sep); +void command_disablerecipe(Client *c, const Seperator *sep); #ifdef EQPROFILE void command_profiledump(Client *c, const Seperator *sep); diff --git a/zone/corpse.h b/zone/corpse.h index 79580f71b..b9999e79b 100644 --- a/zone/corpse.h +++ b/zone/corpse.h @@ -39,8 +39,8 @@ public: ~Corpse(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { return true; } - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; } virtual bool HasRaid() { return false; } diff --git a/zone/doors.cpp b/zone/doors.cpp index e6c3c9c65..0d11206a2 100644 --- a/zone/doors.cpp +++ b/zone/doors.cpp @@ -292,12 +292,12 @@ void Doors::HandleClick(Client* sender, uint8 trigger) } else if(lockpicks != nullptr) { - if(sender->GetSkill(PICK_LOCK)) + if(sender->GetSkill(SkillPickLock)) { if(lockpicks->GetItem()->ItemType == ItemTypeLockPick) { - float modskill=sender->GetSkill(PICK_LOCK); - sender->CheckIncreaseSkill(PICK_LOCK, nullptr, 1); + float modskill=sender->GetSkill(SkillPickLock); + sender->CheckIncreaseSkill(SkillPickLock, nullptr, 1); #if EQDEBUG>=5 LogFile->write(EQEMuLog::Debug, "Client has lockpicks: skill=%f", modskill); diff --git a/zone/embparser_api.cpp b/zone/embparser_api.cpp index 0e21ba6aa..5e79b52b8 100644 --- a/zone/embparser_api.cpp +++ b/zone/embparser_api.cpp @@ -2584,7 +2584,8 @@ XS(XS__istaskappropriate) quest_manager.popup(SvPV_nolen(ST(0)), SvPV_nolen(ST(1)), popupid, buttons, duration); XSRETURN_EMPTY; - } +} + XS(XS__clearspawntimers); XS(XS__clearspawntimers) { @@ -2596,6 +2597,7 @@ XS(XS__clearspawntimers) XSRETURN_EMPTY; } + XS(XS__ze); XS(XS__ze) { @@ -2625,6 +2627,7 @@ XS(XS__we) XSRETURN_EMPTY; } + XS(XS__getlevel); XS(XS__getlevel) { @@ -3310,6 +3313,38 @@ XS(XS__crosszonemessageplayerbyname) XSRETURN_EMPTY; } +XS(XS__enablerecipe); +XS(XS__enablerecipe) +{ + dXSARGS; + + if (items != 1) { + Perl_croak(aTHX_ "Usage: enablerecipe(recipe_id)"); + } + else { + uint32 recipe_id = (uint32)SvIV(ST(0)); + quest_manager.EnableRecipe(recipe_id); + } + + XSRETURN_EMPTY; +} + +XS(XS__disablerecipe); +XS(XS__disablerecipe) +{ + dXSARGS; + + if (items != 1) { + Perl_croak(aTHX_ "Usage: disablerecipe(recipe_id)"); + } + else { + uint32 recipe_id = (uint32)SvIV(ST(0)); + quest_manager.DisableRecipe(recipe_id); + } + + XSRETURN_EMPTY; +} + /* This is the callback perl will look for to setup the quest package's XSUBs @@ -3528,7 +3563,9 @@ EXTERN_C XS(boot_quest) newXS(strcpy(buf, "crosszonesignalclientbycharid"), XS__crosszonesignalclientbycharid, file); newXS(strcpy(buf, "crosszonesignalclientbyname"), XS__crosszonesignalclientbyname, file); newXS(strcpy(buf, "crosszonemessageplayerbyname"), XS__crosszonemessageplayerbyname, file); - XSRETURN_YES; + newXS(strcpy(buf, "enablerecipe"), XS__enablerecipe, file); + newXS(strcpy(buf, "disablerecipe"), XS__disablerecipe, file); + XSRETURN_YES; } #endif diff --git a/zone/entity.cpp b/zone/entity.cpp index e19548465..29b417559 100644 --- a/zone/entity.cpp +++ b/zone/entity.cpp @@ -130,7 +130,7 @@ Trap* Entity::CastToTrap() #ifdef DEBUG if(!IsTrap()) { - //cout << "CastToTrap error" << endl; + //std::cout << "CastToTrap error" << std::endl; return 0; } #endif @@ -161,7 +161,7 @@ Object* Entity::CastToObject() { /*Group* Entity::CastToGroup() { #ifdef _EQDEBUG if(!IsGroup()) { - cout << "CastToGroup error" << endl; + std::cout << "CastToGroup error" << std::endl; DebugBreak(); return 0; } @@ -230,7 +230,7 @@ const Trap* Entity::CastToTrap() const { #ifdef DEBUG if(!IsTrap()) { - //cout << "CastToTrap error" << endl; + //std::cout << "CastToTrap error" << std::endl; return 0; } #endif @@ -3234,11 +3234,11 @@ bool EntityList::MakeTrackPacket(Client* client) float MobDistance; if(client->GetClass() == DRUID) - distance = (client->GetSkill(TRACKING)*10); + distance = (client->GetSkill(SkillTracking)*10); else if(client->GetClass() == RANGER) - distance = (client->GetSkill(TRACKING)*12); + distance = (client->GetSkill(SkillTracking)*12); else if(client->GetClass() == BARD) - distance = (client->GetSkill(TRACKING)*7); + distance = (client->GetSkill(SkillTracking)*7); if(distance <= 0) return false; if(distance<300) diff --git a/zone/forage.cpp b/zone/forage.cpp index 3bc553a92..7f9e145fb 100644 --- a/zone/forage.cpp +++ b/zone/forage.cpp @@ -294,7 +294,7 @@ void Client::GoFish() //success formula is not researched at all - int fishing_skill = GetSkill(FISHING); //will take into account skill bonuses on pole & bait + int fishing_skill = GetSkill(SkillFishing); //will take into account skill bonuses on pole & bait //make sure we still have a fishing pole on: int32 bslot = m_inv.HasItemByUse(ItemTypeFishingBait, 1, invWhereWorn|invWherePersonal); @@ -303,7 +303,7 @@ void Client::GoFish() Bait = m_inv.GetItem(bslot); //if the bait isnt equipped, need to add its skill bonus - if(bslot >= IDX_INV && Bait->GetItem()->SkillModType == FISHING) { + if(bslot >= IDX_INV && Bait->GetItem()->SkillModType == SkillFishing) { fishing_skill += Bait->GetItem()->SkillModValue; } @@ -398,16 +398,16 @@ void Client::GoFish() DeleteItemInInventory(13,0,true); } - if(CheckIncreaseSkill(FISHING, nullptr, 5)) + if(CheckIncreaseSkill(SkillFishing, nullptr, 5)) { - if(title_manager.IsNewTradeSkillTitleAvailable(FISHING, GetRawSkill(FISHING))) + if(title_manager.IsNewTradeSkillTitleAvailable(SkillFishing, GetRawSkill(SkillFishing))) NotifyNewTitlesAvailable(); } } void Client::ForageItem(bool guarantee) { - int skill_level = GetSkill(FORAGE); + int skill_level = GetSkill(SkillForage); //be wary of the string ids in switch below when changing this. uint32 common_food_ids[MAX_COMMON_FOOD_IDS] = { @@ -498,7 +498,7 @@ void Client::ForageItem(bool guarantee) { parse->EventPlayer(EVENT_FORAGE_FAILURE, this, "", 0); } - CheckIncreaseSkill(FORAGE, nullptr, 5); + CheckIncreaseSkill(SkillForage, nullptr, 5); } diff --git a/zone/inventory.cpp b/zone/inventory.cpp index eb38388d9..865eaa8e5 100644 --- a/zone/inventory.cpp +++ b/zone/inventory.cpp @@ -633,7 +633,7 @@ bool Client::TryStacking(ItemInst* item, uint8 type, bool try_worn, bool try_cur bool Client::AutoPutLootInInventory(ItemInst& inst, bool try_worn, bool try_cursor, ServerLootItem_Struct** bag_item_data) { // #1: Try to auto equip - if (try_worn && inst.IsEquipable(GetBaseRace(), GetClass()) && inst.GetItem()->ReqLevel<=level && !inst.GetItem()->Attuneable && inst.GetItem()->ItemType != ItemTypeAugment) + if (try_worn && inst.IsEquipable(GetBaseRace(), GetClass()) && inst.GetItem()->ReqLevel<=level && !inst.GetItem()->Attuneable && inst.GetItem()->ItemType != ItemTypeAugmentation) { for (int16 i = 0; i < 9999; i++) // originally (i < 22) { @@ -646,7 +646,7 @@ bool Client::AutoPutLootInInventory(ItemInst& inst, bool try_worn, bool try_curs { if( i == SLOT_PRIMARY && inst.IsWeapon() ) // If item is primary slot weapon { - if( (inst.GetItem()->ItemType == ItemType2HS) || (inst.GetItem()->ItemType == ItemType2HB) || (inst.GetItem()->ItemType == ItemType2HPierce) ) // and uses 2hs \ 2hb \ 2hp + if( (inst.GetItem()->ItemType == ItemType2HSlash) || (inst.GetItem()->ItemType == ItemType2HBlunt) || (inst.GetItem()->ItemType == ItemType2HPiercing) ) // and uses 2hs \ 2hb \ 2hp { if( m_inv[SLOT_SECONDARY] ) // and if secondary slot is not empty { @@ -657,7 +657,7 @@ bool Client::AutoPutLootInInventory(ItemInst& inst, bool try_worn, bool try_curs if( i== SLOT_SECONDARY && m_inv[SLOT_PRIMARY]) // check to see if primary slot is a two hander { uint8 use = m_inv[SLOT_PRIMARY]->GetItem()->ItemType; - if(use == ItemType2HS || use == ItemType2HB || use == ItemType2HPierce) + if(use == ItemType2HSlash || use == ItemType2HBlunt || use == ItemType2HPiercing) continue; } if diff --git a/zone/loottables.cpp b/zone/loottables.cpp index 00ff4b62d..e7adaff7e 100644 --- a/zone/loottables.cpp +++ b/zone/loottables.cpp @@ -278,38 +278,38 @@ void NPC::AddLootDrop(const Item_Struct *item2, ItemList* itemlist, int16 charge if (item2->Proc.Effect != 0) CastToMob()->AddProcToWeapon(item2->Proc.Effect, true); - eslot = MATERIAL_PRIMARY; + eslot = MaterialPrimary; } else if (foundslot == SLOT_SECONDARY && (GetOwner() != nullptr || (GetLevel() >= 13 && MakeRandomInt(0,99) < NPC_DW_CHANCE) || (item2->Damage==0)) && - (item2->ItemType == ItemType1HS || item2->ItemType == ItemType1HB || item2->ItemType == ItemTypeShield || - item2->ItemType == ItemTypePierce)) + (item2->ItemType == ItemType1HSlash || item2->ItemType == ItemType1HBlunt || item2->ItemType == ItemTypeShield || + item2->ItemType == ItemType1HPiercing)) { if (item2->Proc.Effect!=0) CastToMob()->AddProcToWeapon(item2->Proc.Effect, true); - eslot = MATERIAL_SECONDARY; + eslot = MaterialSecondary; } else if (foundslot == SLOT_HEAD) { - eslot = MATERIAL_HEAD; + eslot = MaterialHead; } else if (foundslot == SLOT_CHEST) { - eslot = MATERIAL_CHEST; + eslot = MaterialChest; } else if (foundslot == SLOT_ARMS) { - eslot = MATERIAL_ARMS; + eslot = MaterialArms; } else if (foundslot == SLOT_BRACER01 || foundslot == SLOT_BRACER02) { - eslot = MATERIAL_BRACER; + eslot = MaterialWrist; } else if (foundslot == SLOT_HANDS) { - eslot = MATERIAL_HANDS; + eslot = MaterialHands; } else if (foundslot == SLOT_LEGS) { - eslot = MATERIAL_LEGS; + eslot = MaterialLegs; } else if (foundslot == SLOT_FEET) { - eslot = MATERIAL_FEET; + eslot = MaterialFeet; } /* diff --git a/zone/lua_client.cpp b/zone/lua_client.cpp index dd48b88d2..86ad83c57 100644 --- a/zone/lua_client.cpp +++ b/zone/lua_client.cpp @@ -422,27 +422,27 @@ void Lua_Client::IncreaseLanguageSkill(int skill_id, int value) { int Lua_Client::GetRawSkill(int skill_id) { Lua_Safe_Call_Int(); - return self->GetRawSkill(static_cast(skill_id)); + return self->GetRawSkill(static_cast(skill_id)); } bool Lua_Client::HasSkill(int skill_id) { Lua_Safe_Call_Bool(); - return self->HasSkill(static_cast(skill_id)); + return self->HasSkill(static_cast(skill_id)); } bool Lua_Client::CanHaveSkill(int skill_id) { Lua_Safe_Call_Bool(); - return self->CanHaveSkill(static_cast(skill_id)); + return self->CanHaveSkill(static_cast(skill_id)); } void Lua_Client::SetSkill(int skill_id, int value) { Lua_Safe_Call_Void(); - self->SetSkill(static_cast(skill_id), value); + self->SetSkill(static_cast(skill_id), value); } void Lua_Client::AddSkill(int skill_id, int value) { Lua_Safe_Call_Void(); - self->AddSkill(static_cast(skill_id), value); + self->AddSkill(static_cast(skill_id), value); } void Lua_Client::CheckSpecializeIncrease(int spell_id) { @@ -452,12 +452,12 @@ void Lua_Client::CheckSpecializeIncrease(int spell_id) { void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target) { Lua_Safe_Call_Void(); - self->CheckIncreaseSkill(static_cast(skill_id), target); + self->CheckIncreaseSkill(static_cast(skill_id), target); } void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) { Lua_Safe_Call_Void(); - self->CheckIncreaseSkill(static_cast(skill_id), target, chance_mod); + self->CheckIncreaseSkill(static_cast(skill_id), target, chance_mod); } void Lua_Client::SetLanguageSkill(int language, int value) { @@ -467,7 +467,7 @@ void Lua_Client::SetLanguageSkill(int language, int value) { int Lua_Client::MaxSkill(int skill_id) { Lua_Safe_Call_Int(); - return self->MaxSkill(static_cast(skill_id)); + return self->MaxSkill(static_cast(skill_id)); } bool Lua_Client::IsMedding() { diff --git a/zone/lua_general.cpp b/zone/lua_general.cpp index 68819835a..28f8df634 100644 --- a/zone/lua_general.cpp +++ b/zone/lua_general.cpp @@ -1021,6 +1021,14 @@ void lua_clear_opcode(int op) { ClearMappedOpcode(static_cast(op)); } +void lua_enable_recipe(uint32 recipe_id) { + quest_manager.EnableRecipe(recipe_id); +} + +void lua_disable_recipe(uint32 recipe_id) { + quest_manager.DisableRecipe(recipe_id); +} + luabind::scope lua_register_general() { return luabind::namespace_("eq") [ @@ -1182,7 +1190,9 @@ luabind::scope lua_register_general() { luabind::def("get_owner", &lua_get_owner), luabind::def("get_quest_item", &lua_get_quest_item), luabind::def("map_opcodes", &lua_map_opcodes), - luabind::def("clear_opcode", &lua_clear_opcode) + luabind::def("clear_opcode", &lua_clear_opcode), + luabind::def("enable_recipe", &lua_enable_recipe), + luabind::def("disable_recipe", &lua_disable_recipe) ]; } @@ -1323,16 +1333,19 @@ luabind::scope lua_register_material() { return luabind::class_("Material") .enum_("constants") [ - luabind::value("Head", MATERIAL_HEAD), - luabind::value("Chest", MATERIAL_CHEST), - luabind::value("Arms", MATERIAL_ARMS), - luabind::value("Bracer", MATERIAL_BRACER), - luabind::value("Hands", MATERIAL_HANDS), - luabind::value("Legs", MATERIAL_LEGS), - luabind::value("Feet", MATERIAL_FEET), - luabind::value("Primary", MATERIAL_PRIMARY), - luabind::value("Secondary", MATERIAL_SECONDARY), - luabind::value("Max", MAX_MATERIALS) + luabind::value("Head", static_cast(MaterialHead)), + luabind::value("Chest", static_cast(MaterialChest)), + luabind::value("Arms", static_cast(MaterialArms)), + luabind::value("Bracer", static_cast(MaterialWrist)), // deprecated + luabind::value("Wrist", static_cast(MaterialWrist)), + luabind::value("Hands", static_cast(MaterialHands)), + luabind::value("Legs", static_cast(MaterialLegs)), + luabind::value("Feet", static_cast(MaterialFeet)), + luabind::value("Primary", static_cast(MaterialPrimary)), + luabind::value("Secondary", static_cast(MaterialSecondary)), + luabind::value("Max", static_cast(_MaterialCount)), // deprecated + luabind::value("Count", static_cast(_MaterialCount)), + luabind::value("Invalid", static_cast(_MaterialInvalid)) ]; } diff --git a/zone/lua_iteminst.cpp b/zone/lua_iteminst.cpp index 0427614d1..c774c332e 100644 --- a/zone/lua_iteminst.cpp +++ b/zone/lua_iteminst.cpp @@ -41,7 +41,7 @@ Lua_ItemInst::Lua_ItemInst(const Lua_ItemInst& o) { bool Lua_ItemInst::IsType(int item_class) { Lua_Safe_Call_Bool(); - return self->IsType(static_cast(item_class)); + return self->IsType(static_cast(item_class)); } bool Lua_ItemInst::IsStackable() { diff --git a/zone/lua_mob.cpp b/zone/lua_mob.cpp index f3e5d6cbc..851c1293a 100644 --- a/zone/lua_mob.cpp +++ b/zone/lua_mob.cpp @@ -178,22 +178,22 @@ bool Lua_Mob::Attack(Lua_Mob other, int hand, bool from_riposte, bool is_striket void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill)); + return self->Damage(from, damage, spell_id, static_cast(attack_skill)); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable, int buffslot) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable, int buffslot, bool buff_tic) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot, buff_tic); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot, buff_tic); } void Lua_Mob::RangedAttack(Lua_Mob other) { @@ -1222,28 +1222,28 @@ bool Lua_Mob::CombatRange(Lua_Mob other) { void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time, bool hit_chance) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance); } void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other) { @@ -1279,22 +1279,22 @@ void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill)); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill)); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus, bool can_riposte) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus, can_riposte); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus, can_riposte); } void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other) { @@ -1698,17 +1698,17 @@ void Lua_Mob::SetTargetable(bool on) { void Lua_Mob::ModSkillDmgTaken(int skill, int value) { Lua_Safe_Call_Void(); - self->ModSkillDmgTaken(static_cast(skill), value); + self->ModSkillDmgTaken(static_cast(skill), value); } int Lua_Mob::GetModSkillDmgTaken(int skill) { Lua_Safe_Call_Int(); - return self->GetModSkillDmgTaken(static_cast(skill)); + return self->GetModSkillDmgTaken(static_cast(skill)); } int Lua_Mob::GetSkillDmgTaken(int skill) { Lua_Safe_Call_Int(); - return self->GetSkillDmgTaken(static_cast(skill)); + return self->GetSkillDmgTaken(static_cast(skill)); } void Lua_Mob::SetAllowBeneficial(bool value) { @@ -1758,7 +1758,7 @@ int Lua_Mob::GetFlurryChance() { int Lua_Mob::GetSkill(int skill) { Lua_Safe_Call_Int(); - return self->GetSkill(static_cast(skill)); + return self->GetSkill(static_cast(skill)); } int Lua_Mob::GetSpecialAbility(int ability) { diff --git a/zone/maxskill.h b/zone/maxskill.h index d9f8b4ff5..8979d4814 100644 --- a/zone/maxskill.h +++ b/zone/maxskill.h @@ -1,3 +1,5 @@ +// This file needs more than just 'std' updates + uint16 Mob::MaxSkill_weapon(uint16 skillid, uint16 class_, uint16 level) const{ if (skillid > HIGHEST_SKILL) return 0; @@ -273,7 +275,7 @@ uint16 Mob::MaxSkill_weapon(uint16 skillid, uint16 class_, uint16 level) const{ } default: #if EQDEBUG - cout<<"MaxSkill_Weapon() Unknown class: "<= 1 - cout<<"Unknown Offensive skill: "<_medding = true; - regen = ((GetSkill(MEDITATE) / 10) + mana_regen); + regen = ((GetSkill(SkillMeditate) / 10) + mana_regen); regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; } else @@ -1223,16 +1223,16 @@ void Merc::CalcRestState() { RestRegenEndurance = (GetMaxEndurance() * RuleI(Character, RestRegenPercent) / 100); } -bool Merc::HasSkill(SkillType skill_id) const { +bool Merc::HasSkill(SkillUseTypes skill_id) const { return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id)); } -bool Merc::CanHaveSkill(SkillType skill_id) const { +bool Merc::CanHaveSkill(SkillUseTypes skill_id) const { return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0); //if you don't have it by max level, then odds are you never will? } -uint16 Merc::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Merc::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } @@ -1715,11 +1715,11 @@ void Merc::AI_Process() { int weapontype = 0; // No weapon type bool bIsFist = true; - if(bIsFist || ((weapontype != ItemType2HS) && (weapontype != ItemType2HPierce) && (weapontype != ItemType2HB))) { + if(bIsFist || ((weapontype != ItemType2HSlash) && (weapontype != ItemType2HPiercing) && (weapontype != ItemType2HBlunt))) { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -2403,7 +2403,7 @@ bool Merc::AICastSpell(int8 iChance, int32 iSpellTypes) { continue; } - if(spells[selectedMercSpell.spellid].skill == BACKSTAB && spells[selectedMercSpell.spellid].targettype == ST_Self) { + if(spells[selectedMercSpell.spellid].skill == SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) { if(!hidden) { continue; } @@ -4658,7 +4658,7 @@ void Merc::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -4668,7 +4668,7 @@ void Merc::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } else @@ -4680,7 +4680,7 @@ void Merc::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -4689,7 +4689,7 @@ void Merc::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } } @@ -4711,7 +4711,7 @@ bool Merc::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, boo return NPC::Attack(other, Hand, bRiposte, IsStrikethrough, IsFromSpell, opts); } -void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) +void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(IsDead() || IsCorpse()) return; @@ -4752,7 +4752,7 @@ Mob* Merc::GetOwnerOrSelf() { return Result; } -bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) +bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { if(!NPC::Death(killerMob, damage, spell, attack_skill)) return false; diff --git a/zone/merc.h b/zone/merc.h index a72216285..192b56575 100644 --- a/zone/merc.h +++ b/zone/merc.h @@ -46,8 +46,8 @@ public: virtual ~Merc(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = SLOT_PRIMARY, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return false; } @@ -166,10 +166,10 @@ public: inline const uint8 GetClientVersion() const { return _OwnerClientVersion; } virtual void SetTarget(Mob* mob); - bool HasSkill(SkillType skill_id) const; - bool CanHaveSkill(SkillType skill_id) const; - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + bool HasSkill(SkillUseTypes skill_id) const; + bool CanHaveSkill(SkillUseTypes skill_id) const; + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } virtual void DoClassAttacks(Mob *target); void CheckHateList(); bool CheckTaunt(); diff --git a/zone/mob.cpp b/zone/mob.cpp index 91f42f161..6780a1ca1 100644 --- a/zone/mob.cpp +++ b/zone/mob.cpp @@ -72,7 +72,7 @@ Mob::Mob(const char* in_name, uint32 in_drakkin_heritage, uint32 in_drakkin_tattoo, uint32 in_drakkin_details, - uint32 in_armor_tint[MAX_MATERIALS], + uint32 in_armor_tint[_MaterialCount], uint8 in_aa_title, uint8 in_see_invis, // see through invis/ivu @@ -238,7 +238,7 @@ Mob::Mob(const char* in_name, SkillProcs[j].base_spellID = SPELL_UNKNOWN; } - for (i = 0; i < MAX_MATERIALS; i++) + for (i = 0; i < _MaterialCount; i++) { if (in_armor_tint) { @@ -945,7 +945,7 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) strn0cpy(ns->spawn.lastName, lastname, sizeof(ns->spawn.lastName)); - for(i = 0; i < MAX_MATERIALS; i++) + for(i = 0; i < _MaterialCount; i++) { ns->spawn.equipment[i] = GetEquipmentMaterial(i); if (armor_tint[i]) @@ -1546,7 +1546,7 @@ void Mob::SendIllusionPacket(uint16 in_race, uint8 in_gender, uint8 in_texture, } uint8 Mob::GetDefaultGender(uint16 in_race, uint8 in_gender) { -//cout << "Gender in: " << (int)in_gender << endl; +//std::cout << "Gender in: " << (int)in_gender << std::endl; // undefined cout [CODEBUG] if ((in_race > 0 && in_race <= GNOME ) || in_race == IKSAR || in_race == VAHSHIR || in_race == FROGLOK || in_race == DRAKKIN || in_race == 15 || in_race == 50 || in_race == 57 || in_race == 70 || in_race == 98 || in_race == 118) { @@ -1918,7 +1918,7 @@ void Mob::SetZone(uint32 zone_id, uint32 instance_id) } void Mob::Kill() { - Death(this, 0, SPELL_UNKNOWN, HAND_TO_HAND); + Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand); } void Mob::SetAttackTimer() { @@ -1969,9 +1969,9 @@ void Mob::SetAttackTimer() { //if we have a 2H weapon in our main hand, no dual if(PrimaryWeapon != nullptr) { if( PrimaryWeapon->ItemClass == ItemClassCommon - && (PrimaryWeapon->ItemType == ItemType2HS - || PrimaryWeapon->ItemType == ItemType2HB - || PrimaryWeapon->ItemType == ItemType2HPierce)) { + && (PrimaryWeapon->ItemType == ItemType2HSlash + || PrimaryWeapon->ItemType == ItemType2HBlunt + || PrimaryWeapon->ItemType == ItemType2HPiercing)) { attack_dw_timer.Disable(); continue; } @@ -2003,7 +2003,7 @@ void Mob::SetAttackTimer() { ItemToUse = nullptr; } // Check to see if skill is valid - else if((ItemToUse->ItemType > ItemTypeThrowing) && (ItemToUse->ItemType != ItemTypeHand2Hand) && (ItemToUse->ItemType != ItemType2HPierce)) { + else if((ItemToUse->ItemType > ItemTypeLargeThrowing) && (ItemToUse->ItemType != ItemTypeMartial) && (ItemToUse->ItemType != ItemType2HPiercing)) { //no weapon ItemToUse = nullptr; } @@ -2039,7 +2039,7 @@ void Mob::SetAttackTimer() { if(speed < RuleI(Combat, MinHastedDelay)) speed = RuleI(Combat, MinHastedDelay); - if(ItemToUse && (ItemToUse->ItemType == ItemTypeBow || ItemToUse->ItemType == ItemTypeThrowing)) + if(ItemToUse && (ItemToUse->ItemType == ItemTypeBow || ItemToUse->ItemType == ItemTypeLargeThrowing)) { if(IsClient()) { @@ -2049,7 +2049,7 @@ void Mob::SetAttackTimer() { const ItemInst *pi = CastToClient()->GetInv().GetItem(r); if(!pi) continue; - if(pi->IsType(ItemClassContainer) && pi->GetItem()->BagType == BagType_Quiver) + if(pi->IsType(ItemClassContainer) && pi->GetItem()->BagType == BagTypeQuiver) { float temp_wr = ( pi->GetItem()->BagWR / RuleI(Combat, QuiverWRHasteDiv) ); if(temp_wr > max_quiver) @@ -2077,13 +2077,13 @@ void Mob::SetAttackTimer() { bool Mob::CanThisClassDualWield(void) const { if (!IsClient()) { - return(GetSkill(DUAL_WIELD) > 0); + return(GetSkill(SkillDualWield) > 0); } else { const ItemInst* inst = CastToClient()->GetInv().GetItem(SLOT_PRIMARY); // 2HS, 2HB, or 2HP if (inst && inst->IsType(ItemClassCommon)) { const Item_Struct* item = inst->GetItem(); - if ((item->ItemType == ItemType2HB) || (item->ItemType == ItemType2HS) || (item->ItemType == ItemType2HPierce)) + if ((item->ItemType == ItemType2HBlunt) || (item->ItemType == ItemType2HSlash) || (item->ItemType == ItemType2HPiercing)) return false; } else { //No weapon in hand... using hand-to-hand... @@ -2093,19 +2093,19 @@ bool Mob::CanThisClassDualWield(void) const } } - return (CastToClient()->HasSkill(DUAL_WIELD)); // No skill = no chance + return (CastToClient()->HasSkill(SkillDualWield)); // No skill = no chance } } bool Mob::CanThisClassDoubleAttack(void) const { if(!IsClient()) { - return(GetSkill(DOUBLE_ATTACK) > 0); + return(GetSkill(SkillDoubleAttack) > 0); } else { if(aabonuses.GiveDoubleAttack || itembonuses.GiveDoubleAttack || spellbonuses.GiveDoubleAttack) { return true; } - return(CastToClient()->HasSkill(DOUBLE_ATTACK)); + return(CastToClient()->HasSkill(SkillDoubleAttack)); } } @@ -2145,36 +2145,36 @@ bool Mob::IsWarriorClass(void) const bool Mob::CanThisClassParry(void) const { if(!IsClient()) { - return(GetSkill(PARRY) > 0); + return(GetSkill(SkillParry) > 0); } else { - return(CastToClient()->HasSkill(PARRY)); + return(CastToClient()->HasSkill(SkillParry)); } } bool Mob::CanThisClassDodge(void) const { if(!IsClient()) { - return(GetSkill(DODGE) > 0); + return(GetSkill(SkillDodge) > 0); } else { - return(CastToClient()->HasSkill(DODGE)); + return(CastToClient()->HasSkill(SkillDodge)); } } bool Mob::CanThisClassRiposte(void) const { if(!IsClient()) { - return(GetSkill(RIPOSTE) > 0); + return(GetSkill(SkillRiposte) > 0); } else { - return(CastToClient()->HasSkill(RIPOSTE)); + return(CastToClient()->HasSkill(SkillRiposte)); } } bool Mob::CanThisClassBlock(void) const { if(!IsClient()) { - return(GetSkill(BLOCKSKILL) > 0); + return(GetSkill(SkillBlock) > 0); } else { - return(CastToClient()->HasSkill(BLOCKSKILL)); + return(CastToClient()->HasSkill(SkillBlock)); } } @@ -2556,8 +2556,8 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const { if // for primary and secondary we need the model, not the material ( - material_slot == MATERIAL_PRIMARY || - material_slot == MATERIAL_SECONDARY + material_slot == MaterialPrimary || + material_slot == MaterialSecondary ) { if(strlen(item->IDFile) > 2) @@ -2775,7 +2775,7 @@ int16 Mob::GetResist(uint8 type) const uint32 Mob::GetLevelHP(uint8 tlevel) { - //cout<<"Tlevel: "<<(int)tlevel<= max_hp) cur_hp = max_hp; else cur_hp = hp;} bool ChangeHP(Mob* other, int32 amount, uint16 spell_id = 0, int8 buffslot = -1, bool iBuffTic = false); @@ -289,7 +289,7 @@ public: inline uint8 GetDrakkinHeritage() const { return drakkin_heritage; } inline uint8 GetDrakkinTattoo() const { return drakkin_tattoo; } inline uint8 GetDrakkinDetails() const { return drakkin_details; } - inline uint32 GetArmorTint(uint8 i) const { return armor_tint[(i < MAX_MATERIALS) ? i : 0]; } + inline uint32 GetArmorTint(uint8 i) const { return armor_tint[(i < _MaterialCount) ? i : 0]; } inline uint8 GetClass() const { return class_; } inline uint8 GetLevel() const { return level; } inline const char* GetName() const { return name; } @@ -537,7 +537,7 @@ public: int16 GetCriticalHealRate(uint16 spell_id); int32 GetVulnerability(int32 damage, Mob *caster, uint32 spell_id, uint32 ticsremaining); int32 GetAdditionalDamage(Mob *caster, uint32 spell_id, bool use_skill = false, uint16 skill=0); - int16 GetSkillDmgTaken(const SkillType skill_used); + int16 GetSkillDmgTaken(const SkillUseTypes skill_used); void DoKnockback(Mob *caster, uint32 pushback, uint32 pushup); int16 CalcResistChanceBonus(); int16 CalcFearResistChance(); @@ -559,8 +559,8 @@ public: bool DoHPToManaCovert(uint16 mana_cost = 0); int32 ApplySpellEffectiveness(Mob* caster, int16 spell_id, int32 value, bool IsBard = false); - void ModSkillDmgTaken(SkillType skill_num, int value); - int16 GetModSkillDmgTaken(const SkillType skill_num); + void ModSkillDmgTaken(SkillUseTypes skill_num, int value); + int16 GetModSkillDmgTaken(const SkillUseTypes skill_num); void ModVulnerability(uint8 resist, int16 value); int16 GetModVulnerability(const uint8 resist); @@ -623,7 +623,7 @@ public: virtual int GetHaste(); uint8 GetWeaponDamageBonus(const Item_Struct* Weapon); - uint16 GetDamageTable(SkillType skillinuse); + uint16 GetDamageTable(SkillUseTypes skillinuse); virtual int GetMonkHandToHandDamage(void); bool CanThisClassDoubleAttack(void) const; @@ -644,9 +644,9 @@ public: int32 ReduceDamage(int32 damage); int32 AffectMagicalDamage(int32 damage, uint16 spell_id, const bool iBuffTic, Mob* attacker); - virtual void DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); + virtual void DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const Item_Struct* item=nullptr, uint16 weapon_damage=0, int16 chance_mod=0,int16 focus=0); - virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); + virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const ItemInst* Ammo=nullptr, uint16 weapon_damage=0, int16 chance_mod=0, int16 focus=0); bool CanDoSpecialAttack(Mob *other); bool Flurry(ExtraAttackOptions *opts); @@ -760,7 +760,7 @@ public: // HP Event inline int GetNextHPEvent() const { return nexthpevent; } void SetNextHPEvent( int hpevent ); - void SendItemAnimation(Mob *to, const Item_Struct *item, SkillType skillInUse); + void SendItemAnimation(Mob *to, const Item_Struct *item, SkillUseTypes skillInUse); inline int& GetNextIncHPEvent() { return nextinchpevent; } void SetNextIncHPEvent( int inchpevent ); @@ -810,7 +810,7 @@ public: bool HasSpellEffect(int effectid); int mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster); - float mod_hit_chance(float chancetohit, SkillType skillinuse, Mob* attacker); + float mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker); float mod_riposte_chance(float ripostchance, Mob* attacker); float mod_block_chance(float blockchance, Mob* attacker); float mod_parry_chance(float parrychance, Mob* attacker); @@ -821,7 +821,7 @@ public: int32 mod_kick_damage(int32 dmg); int32 mod_bash_damage(int32 dmg); int32 mod_frenzy_damage(int32 dmg); - int32 mod_monk_special_damage(int32 ndamage, SkillType skill_type); + int32 mod_monk_special_damage(int32 ndamage, SkillUseTypes skill_type); int32 mod_backstab_damage(int32 ndamage); int mod_archery_bonus_chance(int bonuschance, const ItemInst* RangeWeapon); uint32 mod_archery_bonus_damage(uint32 MaxDmg, const ItemInst* RangeWeapon); @@ -835,7 +835,7 @@ public: bool mod_will_aggro(Mob *attacker, Mob *on); protected: - void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const SkillType attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic); + void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const SkillUseTypes attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic); static uint16 GetProcID(uint16 spell_id, uint8 effect_index); float _GetMovementSpeed(int mod) const; virtual bool MakeNewPositionAndSendUpdate(float x, float y, float z, float speed, bool checkZ); @@ -941,7 +941,7 @@ protected: int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr); int GetKickDamage(); int GetBashDamage(); - virtual void ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg); + virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg); bool HasDied(); void CalculateNewFearpoint(); float FindGroundZ(float new_x, float new_y, float z_offset=0.0); @@ -1022,7 +1022,7 @@ protected: uint32 drakkin_heritage; uint32 drakkin_tattoo; uint32 drakkin_details; - uint32 armor_tint[MAX_MATERIALS]; + uint32 armor_tint[_MaterialCount]; uint8 aa_title; diff --git a/zone/mod_functions.cpp b/zone/mod_functions.cpp index 62f226197..31aa32d75 100644 --- a/zone/mod_functions.cpp +++ b/zone/mod_functions.cpp @@ -33,7 +33,7 @@ void Zone::mod_repop() { return; } void NPC::mod_prespawn(Spawn2 *sp) { return; } //Base damage from NPC::Attack -int NPC::mod_npc_damage(int damage, SkillType skillinuse, int hand, const Item_Struct* weapon, Mob* other) { return(damage); } +int NPC::mod_npc_damage(int damage, SkillUseTypes skillinuse, int hand, const Item_Struct* weapon, Mob* other) { return(damage); } //Mob c has been given credit for a kill. This is called after the regular EVENT_KILLED_MERIT event. void NPC::mod_npc_killed_merit(Mob* c) { return; } @@ -42,7 +42,7 @@ void NPC::mod_npc_killed_merit(Mob* c) { return; } void NPC::mod_npc_killed(Mob* oos) { return; } //Base damage from Client::Attack - can cover myriad skill types -int Client::mod_client_damage(int damage, SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other) { return(damage); } +int Client::mod_client_damage(int damage, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other) { return(damage); } //message is char[4096], don't screw it up. Return true for normal behavior, false to return immediately. // Channels: @@ -62,7 +62,7 @@ bool Client::mod_client_message(char* message, uint8 chan_num) { return(true); } //Skillup override. When this is called the regular skillup check has failed. Return false to proceed with default behavior. //This will NOT allow a client to increase skill past a cap. -bool Client::mod_can_increase_skill(SkillType skillid, Mob* against_who) { return(false); } +bool Client::mod_can_increase_skill(SkillUseTypes skillid, Mob* against_who) { return(false); } //chance of general skill increase, rolled against 0-99 where higher chance is better. int16 Client::mod_increase_skill_chance(int16 chance, Mob* against_who) { return(chance); } @@ -118,7 +118,7 @@ int Client::mod_drink_value(const Item_Struct *item, int change) { return(change int Mob::mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster) { return(effect_value); } //chancetohit - 0 to 100 percent - set over 1000 for a guaranteed hit -float Mob::mod_hit_chance(float chancetohit, SkillType skillinuse, Mob* attacker) { return(chancetohit); } +float Mob::mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker) { return(chancetohit); } //Final riposte chance float Mob::mod_riposte_chance(float ripostechance, Mob* attacker) { return(ripostechance); } @@ -150,7 +150,7 @@ int32 Mob::mod_bash_damage(int32 dmg) { return(dmg); } int32 Mob::mod_frenzy_damage(int32 dmg) { return(dmg); } //Special attack damage after all other bonuses are applied. -int32 Mob::mod_monk_special_damage(int32 ndamage, SkillType skill_type) { return(ndamage); } +int32 Mob::mod_monk_special_damage(int32 ndamage, SkillUseTypes skill_type) { return(ndamage); } //ndamage - Backstab damage as calculated by default formulas int32 Mob::mod_backstab_damage(int32 ndamage) { return(ndamage); } diff --git a/zone/npc.cpp b/zone/npc.cpp index 4d5557964..ca10b7406 100644 --- a/zone/npc.cpp +++ b/zone/npc.cpp @@ -266,7 +266,7 @@ NPC::NPC(const NPCType* d, Spawn2* in_respawn, float x, float y, float z, float //give NPCs skill values... int r; for(r = 0; r <= HIGHEST_SKILL; r++) { - skills[r] = database.GetSkillCap(GetClass(),(SkillType)r,moblevel); + skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,moblevel); } if(d->trap_template > 0) @@ -444,7 +444,7 @@ void NPC::RemoveItem(uint32 item_id, uint16 quantity, uint16 slot) { return; } else if (item->item_id == item_id && item->equipSlot == slot && quantity >= 1) { - //cout<<"NPC::RemoveItem"<<" equipSlot:"<equipSlot<<" quantity:"<< quantity<equipSlot<<" quantity:"<< quantity<charges <= quantity) itemlist.erase(cur); else @@ -1198,7 +1198,7 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver int32 NPC::GetEquipmentMaterial(uint8 material_slot) const { - if (material_slot >= MAX_MATERIALS) + if (material_slot >= _MaterialCount) return 0; int inv_slot = Inventory::CalcSlotFromMaterial(material_slot); @@ -1206,13 +1206,13 @@ int32 NPC::GetEquipmentMaterial(uint8 material_slot) const return 0; if(equipment[inv_slot] == 0) { switch(material_slot) { - case MATERIAL_HEAD: + case MaterialHead: return helmtexture; - case MATERIAL_CHEST: + case MaterialChest: return texture; - case MATERIAL_PRIMARY: + case MaterialPrimary: return d_meele_texture1; - case MATERIAL_SECONDARY: + case MaterialSecondary: return d_meele_texture2; default: //they have nothing in the slot, and its not a special slot... they get nothing. @@ -1240,7 +1240,7 @@ uint32 NPC::GetMaxDamage(uint8 tlevel) void NPC::PickPocket(Client* thief) { - thief->CheckIncreaseSkill(PICK_POCKETS, nullptr, 5); + thief->CheckIncreaseSkill(SkillPickPockets, nullptr, 5); //make sure were allowed to targte them: int olevel = GetLevel(); @@ -1259,7 +1259,7 @@ void NPC::PickPocket(Client* thief) { return; } - int steal_skill = thief->GetSkill(PICK_POCKETS); + int steal_skill = thief->GetSkill(SkillPickPockets); int stealchance = steal_skill*100/(5*olevel+5); ItemInst* inst = 0; int x = 0; diff --git a/zone/npc.h b/zone/npc.h index 8fa44db8f..25730543b 100644 --- a/zone/npc.h +++ b/zone/npc.h @@ -79,8 +79,8 @@ public: virtual ~NPC(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return false; } @@ -117,7 +117,7 @@ public: int32 SpellFocusHeal; virtual void SetTarget(Mob* mob); - virtual uint16 GetSkill(SkillType skill_num) const { if (skill_num <= HIGHEST_SKILL) { return skills[skill_num]; } return 0; } + virtual uint16 GetSkill(SkillUseTypes skill_num) const { if (skill_num <= HIGHEST_SKILL) { return skills[skill_num]; } return 0; } void CalcItemBonuses(StatBonuses *newbon); virtual void CalcBonuses(); @@ -352,7 +352,7 @@ public: uint32 GetSpawnKillCount(); int GetScore(); void mod_prespawn(Spawn2 *sp); - int mod_npc_damage(int damage, SkillType skillinuse, int hand, const Item_Struct* weapon, Mob* other); + int mod_npc_damage(int damage, SkillUseTypes skillinuse, int hand, const Item_Struct* weapon, Mob* other); void mod_npc_killed_merit(Mob* c); void mod_npc_killed(Mob* oos); diff --git a/zone/object.h b/zone/object.h index e2f2bf6b6..1f0955c1f 100644 --- a/zone/object.h +++ b/zone/object.h @@ -70,7 +70,7 @@ IT10714_ACTORDEF=Augmentation Sealer IT10725_ACTORDEF=Shuriken */ -#define OT_DROPPEDITEM BagType_LargeBag +#define OT_DROPPEDITEM BagTypeLargeBag // Icon values: //0x0453 a pie @@ -109,7 +109,7 @@ public: static void HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo); static void HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac); - static SkillType TypeToSkill(uint32 type); + static SkillUseTypes TypeToSkill(uint32 type); // Packet functions void CreateSpawnPacket(EQApplicationPacket* app); @@ -169,7 +169,7 @@ protected: ItemInst* m_inst; // Item representing object bool m_inuse; // Currently in use by a client? uint32 m_id; // Database key, different than drop_id - uint32 m_type; // Object Type, ie, forge, oven, dropped item, etc (ref: ContainerTypes) + uint32 m_type; // Object Type, ie, forge, oven, dropped item, etc (ref: ContainerUseTypes) uint32 m_icon; // Icon to use for forge, oven, etc float m_max_x; float m_max_y; diff --git a/zone/perl_client.cpp b/zone/perl_client.cpp index 3fb012329..6a848a140 100644 --- a/zone/perl_client.cpp +++ b/zone/perl_client.cpp @@ -1898,7 +1898,7 @@ XS(XS_Client_GetSkill) Client * THIS; uint16 RETVAL; dXSTARG; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1925,7 +1925,7 @@ XS(XS_Client_GetRawSkill) Client * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1951,7 +1951,7 @@ XS(XS_Client_HasSkill) { Client * THIS; bool RETVAL; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1978,7 +1978,7 @@ XS(XS_Client_CanHaveSkill) { Client * THIS; bool RETVAL; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -2004,7 +2004,7 @@ XS(XS_Client_SetSkill) Perl_croak(aTHX_ "Usage: Client::SetSkill(THIS, skill_num, value)"); { Client * THIS; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); uint16 value = (uint16)SvUV(ST(2)); if (sv_derived_from(ST(0), "Client")) { @@ -2029,7 +2029,7 @@ XS(XS_Client_AddSkill) Perl_croak(aTHX_ "Usage: Client::AddSkill(THIS, skillid, value)"); { Client * THIS; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); uint16 value = (uint16)SvUV(ST(2)); if (sv_derived_from(ST(0), "Client")) { @@ -2079,7 +2079,7 @@ XS(XS_Client_CheckIncreaseSkill) { Client * THIS; bool RETVAL; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); int chancemodi; if (sv_derived_from(ST(0), "Client")) { @@ -2138,7 +2138,7 @@ XS(XS_Client_MaxSkill) { Client * THIS; uint16 RETVAL; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); uint16 class_ = 0; uint16 level = 0; dXSTARG; diff --git a/zone/perl_mob.cpp b/zone/perl_mob.cpp index 037a46270..13698cea9 100644 --- a/zone/perl_mob.cpp +++ b/zone/perl_mob.cpp @@ -619,7 +619,7 @@ XS(XS_Mob_GetSkill) Mob * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -901,7 +901,7 @@ XS(XS_Mob_Damage) Mob* from; int32 damage = (int32)SvIV(ST(2)); uint16 spell_id = (uint16)SvUV(ST(3)); - SkillType attack_skill = (SkillType)SvUV(ST(4)); + SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(4)); bool avoidable; int8 buffslot; bool iBuffTic; @@ -6639,7 +6639,7 @@ XS(XS_Mob_DoSpecialAttackDamage) { Mob * THIS; Mob* target; - SkillType attack_skill = (SkillType)SvUV(ST(2)); + SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(2)); int32 max_damage = (int32)SvIV(ST(3)); int32 min_damage = 1; int32 hate_override = -11; @@ -7644,7 +7644,7 @@ XS(XS_Mob_ModSkillDmgTaken) Perl_croak(aTHX_ "Usage: Mob::ModSkillDmgTaken(THIS, skill, value)"); { Mob * THIS; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); int16 value = (int16)SvIV(ST(2)); if (sv_derived_from(ST(0), "Mob")) { @@ -7671,7 +7671,7 @@ XS(XS_Mob_GetModSkillDmgTaken) Mob * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -7698,7 +7698,7 @@ XS(XS_Mob_GetSkillDmgTaken) Mob * THIS; int32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -7864,7 +7864,7 @@ XS(XS_Mob_DoMeleeSkillAttackDmg) Mob * THIS; Mob* target; uint16 weapon_damage = (uint16)SvIV(ST(2)); - SkillType skill = (SkillType)SvUV(ST(3)); + SkillUseTypes skill = (SkillUseTypes)SvUV(ST(3)); int16 chance_mod = (int16)SvIV(ST(4)); int16 focus = (int16)SvIV(ST(5)); uint8 CanRiposte = (uint8)SvIV(ST(6)); diff --git a/zone/perl_questitem.cpp b/zone/perl_questitem.cpp index fa5fd1c77..f9128718b 100644 --- a/zone/perl_questitem.cpp +++ b/zone/perl_questitem.cpp @@ -134,7 +134,7 @@ XS(XS_QuestItem_IsType) if(THIS == nullptr) Perl_croak(aTHX_ "THIS is nullptr, avoiding crash."); - RETVAL = THIS->IsType((ItemClass)type); + RETVAL = THIS->IsType((ItemClassTypes)type); ST(0) = boolSV(RETVAL); sv_2mortal(ST(0)); } diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index 06cd6b2cf..75763a7a6 100644 --- a/zone/questmgr.cpp +++ b/zone/questmgr.cpp @@ -1073,7 +1073,7 @@ void QuestManager::addskill(int skill_id, int value) { if(skill_id < 0 || skill_id > HIGHEST_SKILL) return; if (initiator && initiator->IsClient()) - initiator->AddSkill((SkillType) skill_id, value); + initiator->AddSkill((SkillUseTypes) skill_id, value); } void QuestManager::setlanguage(int skill_id, int value) { @@ -1087,7 +1087,7 @@ void QuestManager::setskill(int skill_id, int value) { if(skill_id < 0 || skill_id > HIGHEST_SKILL) return; if (initiator && initiator->IsClient()) - initiator->SetSkill((SkillType) skill_id, value); + initiator->SetSkill((SkillUseTypes) skill_id, value); } void QuestManager::setallskill(int value) { @@ -1095,8 +1095,8 @@ void QuestManager::setallskill(int value) { if (!initiator) return; if (initiator && initiator->IsClient()) { - SkillType sk; - for (sk = _1H_BLUNT; sk <= HIGHEST_SKILL; sk = (SkillType)(sk+1)) { + SkillUseTypes sk; + for (sk = Skill1HBlunt; sk <= HIGHEST_SKILL; sk = (SkillUseTypes)(sk+1)) { initiator->SetSkill(sk, value); } } @@ -1710,7 +1710,7 @@ void QuestManager::clear_zone_flag(int zone_id) { void QuestManager::sethp(int hpperc) { QuestManagerCurrentQuestVars(); int newhp = (owner->GetMaxHP() * (100 - hpperc)) / 100; - owner->Damage(owner, newhp, SPELL_UNKNOWN, HAND_TO_HAND, false, 0, false); + owner->Damage(owner, newhp, SPELL_UNKNOWN, SkillHandtoHand, false, 0, false); } bool QuestManager::summonburriedplayercorpse(uint32 char_id, float dest_x, float dest_y, float dest_z, float dest_heading) { @@ -2096,6 +2096,7 @@ bool QuestManager::istaskactive(int task) { return false; } + bool QuestManager::istaskactivityactive(int task, int activity) { QuestManagerCurrentQuestVars(); @@ -2104,6 +2105,7 @@ bool QuestManager::istaskactivityactive(int task, int activity) { return false; } + int QuestManager::gettaskactivitydonecount(int task, int activity) { QuestManagerCurrentQuestVars(); @@ -2113,6 +2115,7 @@ int QuestManager::gettaskactivitydonecount(int task, int activity) { return 0; } + void QuestManager::updatetaskactivity(int task, int activity, int count) { QuestManagerCurrentQuestVars(); @@ -2165,6 +2168,7 @@ int QuestManager::enabledtaskcount(int taskset) { return -1; } + int QuestManager::firsttaskinset(int taskset) { QuestManagerCurrentQuestVars(); @@ -2173,6 +2177,7 @@ int QuestManager::firsttaskinset(int taskset) { return -1; } + int QuestManager::lasttaskinset(int taskset) { QuestManagerCurrentQuestVars(); @@ -2181,6 +2186,7 @@ int QuestManager::lasttaskinset(int taskset) { return -1; } + int QuestManager::nexttaskinset(int taskset, int taskid) { QuestManagerCurrentQuestVars(); @@ -2189,6 +2195,7 @@ int QuestManager::nexttaskinset(int taskset, int taskid) { return -1; } + int QuestManager::activespeaktask() { QuestManagerCurrentQuestVars(); @@ -2196,6 +2203,7 @@ int QuestManager::activespeaktask() { return initiator->ActiveSpeakTask(owner->GetNPCTypeID()); return 0; } + int QuestManager::activespeakactivity(int taskid) { QuestManagerCurrentQuestVars(); @@ -2204,6 +2212,7 @@ int QuestManager::activespeakactivity(int taskid) { return 0; } + int QuestManager::istaskcompleted(int taskid) { QuestManagerCurrentQuestVars(); @@ -2212,6 +2221,7 @@ int QuestManager::istaskcompleted(int taskid) { return -1; } + int QuestManager::activetasksinset(int taskset) { QuestManagerCurrentQuestVars(); @@ -2220,6 +2230,7 @@ int QuestManager::activetasksinset(int taskset) { return -1; } + int QuestManager::completedtasksinset(int taskset) { QuestManagerCurrentQuestVars(); @@ -2237,6 +2248,7 @@ bool QuestManager::istaskappropriate(int task) { return false; } + void QuestManager::clearspawntimers() { if(zone) { //TODO: Dec 19, 2008, replace with code updated for current spawn timers. @@ -2253,6 +2265,7 @@ void QuestManager::clearspawntimers() { } } } + void QuestManager::ze(int type, const char *str) { entity_list.Message(0, type, str); } @@ -2888,6 +2901,18 @@ void QuestManager::CrossZoneMessagePlayerByName(uint32 Type, const char *CharNam safe_delete(pack); } +void QuestManager::EnableRecipe(uint32 recipe_id) +{ + if (recipe_id > 0) + database.EnableRecipe(recipe_id); +} + +void QuestManager::DisableRecipe(uint32 recipe_id) +{ + if (recipe_id > 0) + database.DisableRecipe(recipe_id); +} + Client *QuestManager::GetInitiator() const { if(!quests_running_.empty()) { running_quest e = quests_running_.top(); diff --git a/zone/questmgr.h b/zone/questmgr.h index fbd9702fa..9873dc441 100644 --- a/zone/questmgr.h +++ b/zone/questmgr.h @@ -231,6 +231,8 @@ public: void CrossZoneSignalPlayerByCharID(int charid, uint32 data); void CrossZoneSignalPlayerByName(const char *CharName, uint32 data); void CrossZoneMessagePlayerByName(uint32 Type, const char *CharName, const char *Message); + void EnableRecipe(uint32 recipe_id); + void DisableRecipe(uint32 recipe_id); Client *GetInitiator() const; NPC *GetNPC() const; diff --git a/zone/skills.h b/zone/skills.h index 581b66647..8c994a378 100644 --- a/zone/skills.h +++ b/zone/skills.h @@ -18,84 +18,84 @@ #ifndef SKILLS_H #define SKILLS_H -#define HIGHEST_SKILL 74 +#define HIGHEST_SKILL_UNUSED 74 // Correct Skill Numbers as of 4-14-2002 -#define _1H_BLUNT 0 -#define _1H_SLASHING 1 -#define _2H_BLUNT 2 -#define _2H_SLASHING 3 -#define ABJURE 4 -#define ALTERATION 5 -#define APPLY_POISON 6 -#define ARCHERY 7 -#define BACKSTAB 8 -#define BIND_WOUND 9 -#define BASH 10 -#define BLOCKSKILL 11 -#define BRASS_INSTRUMENTS 12 -#define CHANNELING 13 -#define CONJURATION 14 -#define DEFENSE 15 -#define DISARM 16 -#define DISARM_TRAPS 17 -#define DIVINATION 18 -#define DODGE 19 -#define DOUBLE_ATTACK 20 -#define DRAGON_PUNCH 21 -#define DUAL_WIELD 22 -#define EAGLE_STRIKE 23 -#define EVOCATION 24 -#define FEIGN_DEATH 25 -#define FLYING_KICK 26 -#define FORAGE 27 -#define HAND_TO_HAND 28 -#define HIDE 29 -#define KICK 30 -#define MEDITATE 31 -#define MEND 32 -#define OFFENSE 33 -#define PARRY 34 -#define PICK_LOCK 35 -#define PIERCING 36 -#define RIPOSTE 37 -#define ROUND_KICK 38 -#define SAFE_FALL 39 -#define SENSE_HEADING 40 -#define SINGING 41 -#define SNEAK 42 -#define SPECIALIZE_ABJURE 43 -#define SPECIALIZE_ALTERATION 44 -#define SPECIALIZE_CONJURATION 45 -#define SPECIALIZE_DIVINATION 46 -#define SPECIALIZE_EVOCATION 47 -#define PICK_POCKETS 48 -#define STRINGED_INSTRUMENTS 49 -#define SWIMMING 50 -#define THROWING 51 -#define TIGER_CLAW 52 -#define TRACKING 53 -#define WIND_INSTRUMENTS 54 -#define FISHING 55 -#define MAKE_POISON 56 -#define TINKERING 57 -#define RESEARCH 58 -#define ALCHEMY 59 -#define BAKING 60 -#define TAILORING 61 -#define SENSE_TRAPS 62 -#define BLACKSMITHING 63 -#define FLETCHING 64 -#define BREWING 65 -#define ALCOHOL_TOLERANCE 66 -#define BEGGING 67 -#define JEWELRY_MAKING 68 -#define POTTERY 69 -#define PERCUSSION_INSTRUMENTS 70 -#define INTIMIDATION 71 -#define BERSERKING 72 -#define TAUNT 73 -#define FRENZY 74 +#define _1H_BLUNT_UNUSED 0 +#define _1H_SLASHING_UNUSED 1 +#define _2H_BLUNT_UNUSED 2 +#define _2H_SLASHING_UNUSED 3 +#define ABJURE_UNUSED 4 +#define ALTERATION_UNUSED 5 +#define APPLY_POISON_UNUSED 6 +#define ARCHERY_UNUSED 7 +#define BACKSTAB_UNUSED 8 +#define BIND_WOUND_UNUSED 9 +#define BASH_UNUSED 10 +#define BLOCKSKILL_UNUSED 11 +#define BRASS_INSTRUMENTS_UNUSED 12 +#define CHANNELING_UNUSED 13 +#define CONJURATION_UNUSED 14 +#define DEFENSE_UNUSED 15 +#define DISARM_UNUSED 16 +#define DISARM_TRAPS_UNUSED 17 +#define DIVINATION_UNUSED 18 +#define DODGE_UNUSED 19 +#define DOUBLE_ATTACK_UNUSED 20 +#define DRAGON_PUNCH_UNUSED 21 +#define DUAL_WIELD_UNUSED 22 +#define EAGLE_STRIKE_UNUSED 23 +#define EVOCATION_UNUSED 24 +#define FEIGN_DEATH_UNUSED 25 +#define FLYING_KICK_UNUSED 26 +#define FORAGE_UNUSED 27 +#define HAND_TO_HAND_UNUSED 28 +#define HIDE_UNUSED 29 +#define KICK_UNUSED 30 +#define MEDITATE_UNUSED 31 +#define MEND_UNUSED 32 +#define OFFENSE_UNUSED 33 +#define PARRY_UNUSED 34 +#define PICK_LOCK_UNUSED 35 +#define PIERCING_UNUSED 36 +#define RIPOSTE_UNUSED 37 +#define ROUND_KICK_UNUSED 38 +#define SAFE_FALL_UNUSED 39 +#define SENSE_HEADING_UNUSED 40 +#define SINGING_UNUSED 41 +#define SNEAK_UNUSED 42 +#define SPECIALIZE_ABJURE_UNUSED 43 +#define SPECIALIZE_ALTERATION_UNUSED 44 +#define SPECIALIZE_CONJURATION_UNUSED 45 +#define SPECIALIZE_DIVINATION_UNUSED 46 +#define SPECIALIZE_EVOCATION_UNUSED 47 +#define PICK_POCKETS_UNUSED 48 +#define STRINGED_INSTRUMENTS_UNUSED 49 +#define SWIMMING_UNUSED 50 +#define THROWING_UNUSED 51 +#define TIGER_CLAW_UNUSED 52 +#define TRACKING_UNUSED 53 +#define WIND_INSTRUMENTS_UNUSED 54 +#define FISHING_UNUSED 55 +#define MAKE_POISON_UNUSED 56 +#define TINKERING_UNUSED 57 +#define RESEARCH_UNUSED 58 +#define ALCHEMY_UNUSED 59 +#define BAKING_UNUSED 60 +#define TAILORING_UNUSED 61 +#define SENSE_TRAPS_UNUSED 62 +#define BLACKSMITHING_UNUSED 63 +#define FLETCHING_UNUSED 64 +#define BREWING_UNUSED 65 +#define ALCOHOL_TOLERANCE_UNUSED 66 +#define BEGGING_UNUSED 67 +#define JEWELRY_MAKING_UNUSED 68 +#define POTTERY_UNUSED 69 +#define PERCUSSION_INSTRUMENTS_UNUSED 70 +#define INTIMIDATION_UNUSED 71 +#define BERSERKING_UNUSED 72 +#define TAUNT_UNUSED 73 +#define FRENZY_UNUSED 74 #endif diff --git a/zone/special_attacks.cpp b/zone/special_attacks.cpp index 7873c47ef..9e6e2e48d 100644 --- a/zone/special_attacks.cpp +++ b/zone/special_attacks.cpp @@ -33,14 +33,14 @@ int Mob::GetKickDamage() { int multiple=(GetLevel()*100/5); multiple += 100; - int32 dmg=(((GetSkill(KICK) + GetSTR() + GetLevel())*100 / 9000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. + int32 dmg=(((GetSkill(SkillKick) + GetSTR() + GetLevel())*100 / 9000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. if(GetClass() == WARRIOR || GetClass() == WARRIORGM ||GetClass() == BERSERKER || GetClass() == BERSERKERGM) { dmg*=12/10;//small increase for warriors } dmg /= 100; int32 mindmg = 1; - ApplySpecialAttackMod(KICK, dmg,mindmg); + ApplySpecialAttackMod(SkillKick, dmg,mindmg); dmg = mod_kick_damage(dmg); @@ -52,18 +52,18 @@ int Mob::GetBashDamage() { multiple += 100; //this is complete shite - int32 dmg=((((GetSkill(BASH) + GetSTR())*100 + GetLevel()*100/2) / 10000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. + int32 dmg=((((GetSkill(SkillBash) + GetSTR())*100 + GetLevel()*100/2) / 10000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. dmg /= 100; int32 mindmg = 1; - ApplySpecialAttackMod(BASH, dmg, mindmg); + ApplySpecialAttackMod(SkillBash, dmg, mindmg); dmg = mod_bash_damage(dmg); return(dmg); } -void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { +void Mob::ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg) { int item_slot = -1; //1: Apply bonus from AC (BOOT/SHIELD/HANDS) est. 40AC=6dmg @@ -71,19 +71,19 @@ void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { switch (skill){ - case FLYING_KICK: - case ROUND_KICK: - case KICK: + case SkillFlyingKick: + case SkillRoundKick: + case SkillKick: item_slot = SLOT_FEET; break; - case BASH: + case SkillBash: item_slot = SLOT_SECONDARY; break; - case DRAGON_PUNCH: - case EAGLE_STRIKE: - case TIGER_CLAW: + case SkillDragonPunch: + case SkillEagleStrike: + case SkillTigerClaw: item_slot = SLOT_HANDS; break; @@ -100,7 +100,7 @@ void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { } } -void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { +void Mob::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { //this really should go through the same code as normal melee damage to //pick up all the special behavior there @@ -108,7 +108,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int if(hate_override > -1) hate = hate_override; - if(skill == BASH) + if(skill == SkillBash) { if(IsClient()) { @@ -132,7 +132,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int else{ bool CanRiposte = true; - if(skill == THROWING && skill == ARCHERY) + if(skill == SkillThrowing || skill == SkillArchery) // changed from '&&' CanRiposte = false; who->AvoidDamage(this, max_damage, CanRiposte); @@ -194,13 +194,13 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { //allready do their checking in conjunction with the attack timer //throwing weapons if(ca_atk->m_atk == 11) { - if (ca_atk->m_skill == THROWING) { + if (ca_atk->m_skill == SkillThrowing) { SetAttackTimer(); ThrowingAttack(GetTarget()); return; } //ranged attack (archery) - if (ca_atk->m_skill == ARCHERY) { + if (ca_atk->m_skill == SkillArchery) { SetAttackTimer(); RangedAttack(GetTarget()); return; @@ -231,10 +231,10 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { int32 skill_reduction = this->GetSkillReuseTime(ca_atk->m_skill); - if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == BASH)) { // SLAM - Bash without a shield equipped + if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == SkillBash)) { // SLAM - Bash without a shield equipped if (GetTarget() != this) { - CheckIncreaseSkill(BASH, GetTarget(), 10); + CheckIncreaseSkill(SkillBash, GetTarget(), 10); DoAnim(animTailRake); int32 ht = 0; @@ -243,7 +243,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { dmg = -5; } else{ - if(!GetTarget()->CheckHitChance(this, BASH, 0)) { + if(!GetTarget()->CheckHitChance(this, SkillBash, 0)) { dmg = 0; ht = GetBashDamage(); } @@ -258,7 +258,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { ReuseTime = BashReuseTime-1-skill_reduction; ReuseTime = (ReuseTime*HasteMod)/100; - DoSpecialAttackDamage(GetTarget(), BASH, dmg, 1, ht, ReuseTime); + DoSpecialAttackDamage(GetTarget(), SkillBash, dmg, 1, ht, ReuseTime); if(ReuseTime > 0) { p_timers.Start(pTimerCombatAbility, ReuseTime); @@ -267,11 +267,11 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { return; } - if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == FRENZY)) + if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == SkillFrenzy)) { - CheckIncreaseSkill(FRENZY, GetTarget(), 10); + CheckIncreaseSkill(SkillFrenzy, GetTarget(), 10); int AtkRounds = 3; - int skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + int skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; DoAnim(anim2HSlashing); @@ -293,7 +293,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , ReuseTime, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , ReuseTime, true); } AtkRounds--; } @@ -310,11 +310,11 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { case WARRIOR: case RANGER: case BEASTLORD: - if (ca_atk->m_atk != 100 || ca_atk->m_skill != KICK) { + if (ca_atk->m_atk != 100 || ca_atk->m_skill != SkillKick) { break; } if (GetTarget() != this) { - CheckIncreaseSkill(KICK, GetTarget(), 10); + CheckIncreaseSkill(SkillKick, GetTarget(), 10); DoAnim(animKick); int32 ht = 0; @@ -322,7 +322,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { dmg = -5; } else{ - if(!GetTarget()->CheckHitChance(this, KICK, 0)) { + if(!GetTarget()->CheckHitChance(this, SkillKick, 0)) { dmg = 0; ht = GetKickDamage(); } @@ -335,7 +335,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { } ReuseTime = KickReuseTime-1-skill_reduction; - DoSpecialAttackDamage(GetTarget(), KICK, dmg, 1, ht, ReuseTime); + DoSpecialAttackDamage(GetTarget(), SkillKick, dmg, 1, ht, ReuseTime); } break; @@ -346,7 +346,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100)) ) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(GetTarget(), MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -363,12 +363,12 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { //hackish... but we return a huge reuse time if this is an // invalid skill, otherwise, we can safely assume it is a // valid monk skill and just cast it to a SkillType - CheckIncreaseSkill((SkillType) ca_atk->m_skill, GetTarget(), 10); + CheckIncreaseSkill((SkillUseTypes) ca_atk->m_skill, GetTarget(), 10); } break; } case ROGUE: { - if (ca_atk->m_atk != 100 || ca_atk->m_skill != BACKSTAB) { + if (ca_atk->m_atk != 100 || ca_atk->m_skill != SkillBackstab) { break; } TryBackstab(GetTarget(), ReuseTime); @@ -398,13 +398,13 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) int32 max_dmg = 0; int32 min_dmg = 1; int reuse = 0; - SkillType skill_type; //to avoid casting... even though it "would work" + SkillUseTypes skill_type; //to avoid casting... even though it "would work" uint8 itemslot = SLOT_FEET; switch(unchecked_type) { - case FLYING_KICK:{ - skill_type = FLYING_KICK; + case SkillFlyingKick:{ + skill_type = SkillFlyingKick; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, FlyingKickBonus) / 100) + 35; min_dmg = ((level*8)/10); ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -412,8 +412,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) reuse = FlyingKickReuseTime; break; } - case DRAGON_PUNCH:{ - skill_type = DRAGON_PUNCH; + case SkillDragonPunch:{ + skill_type = SkillDragonPunch; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, DragonPunchBonus) / 100) + 26; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -422,8 +422,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case EAGLE_STRIKE:{ - skill_type = EAGLE_STRIKE; + case SkillEagleStrike:{ + skill_type = SkillEagleStrike; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, EagleStrikeBonus) / 100) + 19; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -432,8 +432,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case TIGER_CLAW:{ - skill_type = TIGER_CLAW; + case SkillTigerClaw:{ + skill_type = SkillTigerClaw; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, TigerClawBonus) / 100) + 12; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -442,8 +442,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case ROUND_KICK:{ - skill_type = ROUND_KICK; + case SkillRoundKick:{ + skill_type = SkillRoundKick; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, RoundKickBonus) / 100) + 10; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); DoAnim(animRoundKick); @@ -451,8 +451,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case KICK:{ - skill_type = KICK; + case SkillKick:{ + skill_type = SkillKick; max_dmg = GetKickDamage(); DoAnim(animKick); reuse = KickReuseTime; @@ -506,7 +506,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { //make sure we have a proper weapon if we are a client. if(IsClient()) { const ItemInst *wpn = CastToClient()->GetInv().GetItem(SLOT_PRIMARY); - if(!wpn || (wpn->GetItem()->ItemType != ItemTypePierce)){ + if(!wpn || (wpn->GetItem()->ItemType != ItemType1HPiercing)){ Message_StringID(13, BACKSTAB_WEAPON); return; } @@ -544,13 +544,13 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { ) { entity_list.MessageClose_StringID(this, false, 200, MT_CritMelee, ASSASSINATES, GetName()); if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); RogueAssassinate(other); } else { RogueBackstab(other); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA @@ -563,7 +563,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { } } if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); } } //Live AA - Chaotic Backstab @@ -572,9 +572,9 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { //we can stab from any angle, we do min damage though. RogueBackstab(other, true); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA if(other->GetHP() > 0) @@ -620,12 +620,12 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) if(primaryweapondamage > 0){ if(level > 25){ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + ((level-25)/3) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + ((level-25)/3) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } else{ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + 1;; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + 1;; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } // determine minimum hits @@ -639,7 +639,7 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) min_hit = (level * ( level*5 - 105)) / 100; } - if(!other->CheckHitChance(this, BACKSTAB, 0)) { + if(!other->CheckHitChance(this, SkillBackstab, 0)) { ndamage = 0; } else{ @@ -665,7 +665,7 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) ndamage = mod_backstab_damage(ndamage); - DoSpecialAttackDamage(other, BACKSTAB, ndamage, min_hit, hate, ReuseTime); + DoSpecialAttackDamage(other, SkillBackstab, ndamage, min_hit, hate, ReuseTime); DoAnim(animPiercing); } @@ -675,9 +675,9 @@ void Mob::RogueAssassinate(Mob* other) //can you dodge, parry, etc.. an assassinate?? //if so, use DoSpecialAttackDamage(other, BACKSTAB, 32000); instead if(GetWeaponDamage(other, IsClient()?CastToClient()->GetInv().GetItem(SLOT_PRIMARY):(const ItemInst*)nullptr) > 0){ - other->Damage(this, 32000, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, 32000, SPELL_UNKNOWN, SkillBackstab); }else{ - other->Damage(this, -5, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, -5, SPELL_UNKNOWN, SkillBackstab); } DoAnim(animPiercing); //piercing animation } @@ -736,7 +736,7 @@ void Client::RangedAttack(Mob* other) { if(pi == nullptr || !pi->IsType(ItemClassContainer)) continue; const Item_Struct* bagitem = pi->GetItem(); - if(!bagitem || bagitem->BagType != BagType_Quiver) + if(!bagitem || bagitem->BagType != BagTypeQuiver) continue; //we found a quiver, look for the ammo in it @@ -794,7 +794,7 @@ void Client::RangedAttack(Mob* other) { return; } - SendItemAnimation(GetTarget(), AmmoItem, ARCHERY); + SendItemAnimation(GetTarget(), AmmoItem, SkillArchery); DoArcheryAttackDmg(GetTarget(), RangeWeapon, Ammo); @@ -809,7 +809,7 @@ void Client::RangedAttack(Mob* other) { mlog(COMBAT__RANGED, "Endless Quiver prevented ammo consumption."); } - CheckIncreaseSkill(ARCHERY, GetTarget(), -15); + CheckIncreaseSkill(SkillArchery, GetTarget(), -15); //break invis when you attack if(invisible) { @@ -848,13 +848,13 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item if (!CanDoSpecialAttack(other)) return; - if (!other->CheckHitChance(this, ARCHERY, 13,chance_mod)) { + if (!other->CheckHitChance(this, SkillArchery, 13,chance_mod)) { mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); - other->Damage(this, 0, SPELL_UNKNOWN, ARCHERY); + other->Damage(this, 0, SPELL_UNKNOWN, SkillArchery); } else { mlog(COMBAT__RANGED, "Ranged attack hit %s.", other->GetName()); - if(!TryHeadShot(other, ARCHERY)) + if(!TryHeadShot(other, SkillArchery)) { int32 TotalDmg = 0; int16 WDmg = 0; @@ -872,7 +872,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item WDmg = 0; if(ADmg < 0) ADmg = 0; - uint32 MaxDmg = (RuleR(Combat, ArcheryBaseDamageBonus)*(WDmg+ADmg)*GetDamageTable(ARCHERY)) / 100; + uint32 MaxDmg = (RuleR(Combat, ArcheryBaseDamageBonus)*(WDmg+ADmg)*GetDamageTable(SkillArchery)) / 100; int32 hate = ((WDmg+ADmg)); uint16 bonusArcheryDamageModifier = aabonuses.ArcheryDamageModifier + itembonuses.ArcheryDamageModifier + spellbonuses.ArcheryDamageModifier; @@ -927,7 +927,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item //twice, for ammo and weapon TotalDmg += (2*((GetLevel()-25)/3)); minDmg += (2*((GetLevel()-25)/3)); - minDmg += minDmg * GetMeleeMinDamageMod_SE(ARCHERY) / 100; + minDmg += minDmg * GetMeleeMinDamageMod_SE(SkillArchery) / 100; hate += (2*((GetLevel()-25)/3)); } @@ -936,20 +936,20 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item if(TotalDmg > 0) { TotalDmg += TotalDmg*focus/100; - ApplyMeleeDamageBonus(ARCHERY, TotalDmg); - TotalDmg += other->GetAdditionalDamage(this, 0, true, ARCHERY); - TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(ARCHERY) / 100) + GetSkillDmgAmt(ARCHERY); + ApplyMeleeDamageBonus(SkillArchery, TotalDmg); + TotalDmg += other->GetAdditionalDamage(this, 0, true, SkillArchery); + TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(SkillArchery) / 100) + GetSkillDmgAmt(SkillArchery); TotalDmg = mod_archery_damage(TotalDmg, dobonus, RangeWeapon); - TryCriticalHit(other, ARCHERY, TotalDmg); + TryCriticalHit(other, SkillArchery, TotalDmg); other->AddToHateList(this, hate, 0, false); } } else TotalDmg = -5; - other->Damage(this, TotalDmg, SPELL_UNKNOWN, ARCHERY); + other->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillArchery); } } @@ -1013,16 +1013,16 @@ void NPC::RangedAttack(Mob* other) } if(ammo) - SendItemAnimation(GetTarget(), ammo, ARCHERY); + SendItemAnimation(GetTarget(), ammo, SkillArchery); // Face the Target FaceTarget(GetTarget()); // Hit? - if (!GetTarget()->CheckHitChance(this, ARCHERY, 13)) + if (!GetTarget()->CheckHitChance(this, SkillArchery, 13)) { mlog(COMBAT__RANGED, "Ranged attack missed %s.", GetTarget()->GetName()); - GetTarget()->Damage(this, 0, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, 0, SPELL_UNKNOWN, SkillArchery); } else { @@ -1044,14 +1044,14 @@ void NPC::RangedAttack(Mob* other) int32 hate = TotalDmg; GetTarget()->MeleeMitigation(this, TotalDmg, MinDmg); - ApplyMeleeDamageBonus(ARCHERY, TotalDmg); - TryCriticalHit(GetTarget(), ARCHERY, TotalDmg); + ApplyMeleeDamageBonus(SkillArchery, TotalDmg); + TryCriticalHit(GetTarget(), SkillArchery, TotalDmg); GetTarget()->AddToHateList(this, hate, 0, false); - GetTarget()->Damage(this, TotalDmg, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillArchery); } else { - GetTarget()->Damage(this, -5, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, -5, SPELL_UNKNOWN, SkillArchery); } } @@ -1090,7 +1090,7 @@ void NPC::RangedAttack(Mob* other) uint16 Mob::GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg) { - uint16 MaxDmg = (((2 * wDmg) * GetDamageTable(THROWING)) / 100); + uint16 MaxDmg = (((2 * wDmg) * GetDamageTable(SkillThrowing)) / 100); if (MaxDmg == 0) MaxDmg = 1; @@ -1105,7 +1105,7 @@ uint16 Mob::GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg) { TotalDmg += ((GetLevel()-25)/3); minDmg += ((GetLevel()-25)/3); - minDmg += minDmg * GetMeleeMinDamageMod_SE(THROWING) / 100; + minDmg += minDmg * GetMeleeMinDamageMod_SE(SkillThrowing) / 100; } if(MaxDmg < minDmg) @@ -1138,7 +1138,7 @@ void Client::ThrowingAttack(Mob* other) { //old was 51 } const Item_Struct* item = RangeWeapon->GetItem(); - if(item->ItemType != ItemTypeThrowing && item->ItemType != ItemTypeThrowingv2) { + if(item->ItemType != ItemTypeLargeThrowing && item->ItemType != ItemTypeSmallThrowing) { mlog(COMBAT__RANGED, "Ranged attack canceled. Ranged item %d is not a throwing weapon. type %d.", item->ItemType); Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing useful to throw!", GetItemIDAt(SLOT_RANGE)); return; @@ -1189,13 +1189,13 @@ void Client::ThrowingAttack(Mob* other) { //old was 51 return; } //send item animation, also does the throw animation - SendItemAnimation(GetTarget(), item, THROWING); + SendItemAnimation(GetTarget(), item, SkillThrowing); DoThrowingAttackDmg(GetTarget(), RangeWeapon, item); //consume ammo DeleteItemInInventory(ammo_slot, 1, true); - CheckIncreaseSkill(THROWING, GetTarget()); + CheckIncreaseSkill(SkillThrowing, GetTarget()); //break invis when you attack if(invisible) { @@ -1234,9 +1234,9 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite if (!CanDoSpecialAttack(other)) return; - if (!other->CheckHitChance(this, THROWING, 13, chance_mod)){ + if (!other->CheckHitChance(this, SkillThrowing, 13, chance_mod)){ mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); - other->Damage(this, 0, SPELL_UNKNOWN, THROWING); + other->Damage(this, 0, SPELL_UNKNOWN, SkillThrowing); } else { mlog(COMBAT__RANGED, "Throwing attack hit %s.", other->GetName()); @@ -1260,10 +1260,10 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite if(TotalDmg > 0) { TotalDmg += TotalDmg*focus/100; - ApplyMeleeDamageBonus(THROWING, TotalDmg); - TotalDmg += other->GetAdditionalDamage(this, 0, true, THROWING); - TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(THROWING) / 100) + GetSkillDmgAmt(THROWING); - TryCriticalHit(other, THROWING, TotalDmg); + ApplyMeleeDamageBonus(SkillThrowing, TotalDmg); + TotalDmg += other->GetAdditionalDamage(this, 0, true, SkillThrowing); + TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(SkillThrowing) / 100) + GetSkillDmgAmt(SkillThrowing); + TryCriticalHit(other, SkillThrowing, TotalDmg); int32 hate = (2*WDmg); other->AddToHateList(this, hate, 0, false); } @@ -1272,14 +1272,14 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite else TotalDmg = -5; - other->Damage(this, TotalDmg, SPELL_UNKNOWN, THROWING); + other->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillThrowing); } if((RangeWeapon != nullptr) && GetTarget() && other && (other->GetHP() > -10)) TryWeaponProc(RangeWeapon, other, 11); } -void Mob::SendItemAnimation(Mob *to, const Item_Struct *item, SkillType skillInUse) { +void Mob::SendItemAnimation(Mob *to, const Item_Struct *item, SkillUseTypes skillInUse) { EQApplicationPacket *outapp = new EQApplicationPacket(OP_SomeItemPacketMaybe, sizeof(Arrow_Struct)); Arrow_Struct *as = (Arrow_Struct *) outapp->pBuffer; as->type = 1; @@ -1450,17 +1450,17 @@ void NPC::DoClassAttacks(Mob *target) { } break; case MONK: case MONKGM: { - uint8 satype = KICK; + uint8 satype = SkillKick; if(level > 29) { - satype = FLYING_KICK; + satype = SkillFlyingKick; } else if(level > 24) { - satype = DRAGON_PUNCH; + satype = SkillDragonPunch; } else if(level > 19) { - satype = EAGLE_STRIKE; + satype = SkillEagleStrike; } else if(level > 9) { - satype = TIGER_CLAW; + satype = SkillTigerClaw; } else if(level > 4) { - satype = ROUND_KICK; + satype = SkillRoundKick; } reuse = MonkSpecialAttack(target, satype); @@ -1479,7 +1479,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -1489,7 +1489,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } else @@ -1501,7 +1501,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -1510,7 +1510,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } } @@ -1536,7 +1536,7 @@ void NPC::DoClassAttacks(Mob *target) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, -1 , reuse, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, -1 , reuse, true); } AtkRounds--; } @@ -1556,7 +1556,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -1565,7 +1565,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } break; @@ -1582,7 +1582,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -1591,7 +1591,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } break; @@ -1643,43 +1643,43 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) case WARRIOR: case RANGER: case BEASTLORD: - skill_to_use = KICK; + skill_to_use = SkillKick; break; case BERSERKER: - skill_to_use = FRENZY; + skill_to_use = SkillFrenzy; break; case SHADOWKNIGHT: case PALADIN: - skill_to_use = BASH; + skill_to_use = SkillBash; break; case MONK: if(GetLevel() >= 30) { - skill_to_use = FLYING_KICK; + skill_to_use = SkillFlyingKick; } else if(GetLevel() >= 25) { - skill_to_use = DRAGON_PUNCH; + skill_to_use = SkillDragonPunch; } else if(GetLevel() >= 20) { - skill_to_use = EAGLE_STRIKE; + skill_to_use = SkillEagleStrike; } else if(GetLevel() >= 10) { - skill_to_use = TIGER_CLAW; + skill_to_use = SkillTigerClaw; } else if(GetLevel() >= 5) { - skill_to_use = ROUND_KICK; + skill_to_use = SkillRoundKick; } else { - skill_to_use = KICK; + skill_to_use = SkillKick; } break; case ROGUE: - skill_to_use = BACKSTAB; + skill_to_use = SkillBackstab; break; } } @@ -1690,7 +1690,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) if(skill_to_use == -1) return; - if(skill_to_use == BASH) + if(skill_to_use == SkillBash) { if (ca_target!=this) { @@ -1701,7 +1701,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) dmg = -5; } else{ - if(!ca_target->CheckHitChance(this, BASH, 0)) { + if(!ca_target->CheckHitChance(this, SkillBash, 0)) { dmg = 0; } else{ @@ -1716,7 +1716,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) ReuseTime = BashReuseTime-1; ReuseTime = (ReuseTime*HasteMod)/100; - DoSpecialAttackDamage(ca_target, BASH, dmg, 1,-1,ReuseTime); + DoSpecialAttackDamage(ca_target, SkillBash, dmg, 1,-1,ReuseTime); if(ReuseTime > 0 && !IsRiposte) { @@ -1726,11 +1726,11 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) return; } - if(skill_to_use == FRENZY) + if(skill_to_use == SkillFrenzy) { - CheckIncreaseSkill(FRENZY, GetTarget(), 10); + CheckIncreaseSkill(SkillFrenzy, GetTarget(), 10); int AtkRounds = 3; - int skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + int skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; DoAnim(anim2HSlashing); @@ -1750,7 +1750,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , ReuseTime, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , ReuseTime, true); } AtkRounds--; } @@ -1761,7 +1761,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) return; } - if(skill_to_use == KICK) + if(skill_to_use == SkillKick) { if(ca_target!=this) { @@ -1771,7 +1771,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) dmg = -5; } else{ - if(!ca_target->CheckHitChance(this, KICK, 0)) { + if(!ca_target->CheckHitChance(this, SkillKick, 0)) { dmg = 0; } else{ @@ -1784,15 +1784,15 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) ReuseTime = KickReuseTime-1; - DoSpecialAttackDamage(ca_target, KICK, dmg, 1,-1, ReuseTime); + DoSpecialAttackDamage(ca_target, SkillKick, dmg, 1,-1, ReuseTime); } } - if(skill_to_use == FLYING_KICK || - skill_to_use == DRAGON_PUNCH || - skill_to_use == EAGLE_STRIKE || - skill_to_use == TIGER_CLAW || - skill_to_use == ROUND_KICK) + if(skill_to_use == SkillFlyingKick || + skill_to_use == SkillDragonPunch || + skill_to_use == SkillEagleStrike || + skill_to_use == SkillTigerClaw || + skill_to_use == SkillRoundKick) { ReuseTime = MonkSpecialAttack(ca_target, skill_to_use) - 1; MonkSpecialAttack(ca_target, skill_to_use); @@ -1804,7 +1804,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100))) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(ca_target, MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -1818,7 +1818,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) } } - if(skill_to_use == BACKSTAB) + if(skill_to_use == SkillBackstab) { ReuseTime = BackstabReuseTime-1; @@ -1933,7 +1933,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { return; if(!always_succeed && IsClient()) - CastToClient()->CheckIncreaseSkill(TAUNT, who, 10); + CastToClient()->CheckIncreaseSkill(SkillTaunt, who, 10); Mob *hate_top = who->GetHateMost(); @@ -1971,7 +1971,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { //TauntSkillFalloff rate is not based on any real data. Default of 33% gives a reasonable result. if (IsClient() && !always_succeed) - tauntchance -= (RuleR(Combat,TauntSkillFalloff) * (CastToClient()->MaxSkill(TAUNT) - GetSkill(TAUNT))); + tauntchance -= (RuleR(Combat,TauntSkillFalloff) * (CastToClient()->MaxSkill(SkillTaunt) - GetSkill(SkillTaunt))); //From SE_Taunt (Does a taunt with a chance modifier) if (chance_bonus) @@ -2004,7 +2004,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { if (HasSkillProcs()){ float chance = (float)TauntReuseTime*RuleR(Combat, AvgProcsPerMinute)/60000.0f; - TrySkillProc(who, TAUNT, chance); + TrySkillProc(who, SkillTaunt, chance); } } @@ -2026,14 +2026,14 @@ void Mob::InstillDoubt(Mob *who) { if(IsClient()) { - CastToClient()->CheckIncreaseSkill(INTIMIDATION, who, 10); + CastToClient()->CheckIncreaseSkill(SkillIntimidation, who, 10); } //I think this formula needs work int value = 0; //user's bonus - value += GetSkill(INTIMIDATION) + GetCHA()/4; + value += GetSkill(SkillIntimidation) + GetCHA()/4; //target's counters value -= target->GetLevel()*4 + who->GetWIS()/4; @@ -2055,10 +2055,10 @@ void Mob::InstillDoubt(Mob *who) { } } -bool Mob::TryHeadShot(Mob* defender, SkillType skillInUse) { +bool Mob::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) { bool Result = false; - if(defender && skillInUse == ARCHERY) { + if(defender && skillInUse == SkillArchery) { if(GetAA(aaHeadshot) && defender->GetBodyType() == BT_Humanoid) { if((GetLevelCon(GetLevel(), defender->GetLevel()) == CON_LIGHTBLUE || GetLevelCon(GetLevel(), defender->GetLevel()) == CON_GREEN) && defender->GetLevel() <= 60 && !defender->IsClient()) { // WildcardX: These chance formula's below are arbitrary. If someone has a better formula that is more @@ -2081,15 +2081,15 @@ bool Mob::TryHeadShot(Mob* defender, SkillType skillInUse) { return Result; } -void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) +void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) { if (!CanDoSpecialAttack(other)) return; //For spells using skill value 98 (feral swipe ect) server sets this to 67 automatically. //Kayen: This is unlikely to be completely accurate but use OFFENSE skill value for these effects. - if (skillinuse == BEGGING) - skillinuse = OFFENSE; + if (skillinuse == SkillBegging) + skillinuse = SkillOffense; int damage = 0; uint32 hate = 0; @@ -2151,7 +2151,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil else damage = -5; - if(skillinuse == BASH){ + if(skillinuse == SkillBash){ if(IsClient()){ ItemInst *item = CastToClient()->GetInv().GetItem(SLOT_SECONDARY); if(item){ @@ -2167,8 +2167,8 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil other->AddToHateList(this, hate); bool CanSkillProc = true; - if (skillinuse == OFFENSE){ //Hack to allow damage to display. - skillinuse = TIGER_CLAW; //'strike' your opponent - Arbitrary choice for message. + if (skillinuse == SkillOffense){ //Hack to allow damage to display. + skillinuse = SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message. CanSkillProc = false; //Disable skill procs } diff --git a/zone/spell_effects.cpp b/zone/spell_effects.cpp index b43046649..acd041f05 100644 --- a/zone/spell_effects.cpp +++ b/zone/spell_effects.cpp @@ -2113,11 +2113,11 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial) switch(spells[spell_id].skill) { - case THROWING: + case SkillThrowing: caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i], focus); break; - case ARCHERY: + case SkillArchery: caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i],focus); break; @@ -3238,11 +3238,11 @@ void Mob::DoBuffTic(uint16 spell_id, int slot, uint32 ticsremaining, uint8 caste double break_chance = 2.0; if(caster) { - break_chance -= (2 * (((double)caster->GetSkill(DIVINATION) + ((double)caster->GetLevel() * 3.0)) / 650.0)); + break_chance -= (2 * (((double)caster->GetSkill(SkillDivination) + ((double)caster->GetLevel() * 3.0)) / 650.0)); } else { - break_chance -= (2 * (((double)GetSkill(DIVINATION) + ((double)GetLevel() * 3.0)) / 650.0)); + break_chance -= (2 * (((double)GetSkill(SkillDivination) + ((double)GetLevel() * 3.0)) / 650.0)); } if(MakeRandomFloat(0.0, 100.0) < break_chance) diff --git a/zone/spells.cpp b/zone/spells.cpp index 3b7f391f3..68997eec3 100644 --- a/zone/spells.cpp +++ b/zone/spells.cpp @@ -479,16 +479,16 @@ bool Mob::DoCastSpell(uint16 spell_id, uint16 target_id, uint16 slot, uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const { switch(spells[spell_id].skill) { - case ABJURE: - return(GetSkill(SPECIALIZE_ABJURE)); - case ALTERATION: - return(GetSkill(SPECIALIZE_ALTERATION)); - case CONJURATION: - return(GetSkill(SPECIALIZE_CONJURATION)); - case DIVINATION: - return(GetSkill(SPECIALIZE_DIVINATION)); - case EVOCATION: - return(GetSkill(SPECIALIZE_EVOCATION)); + case SkillAbjuration: + return(GetSkill(SkillSpecializeAbjure)); + case SkillAlteration: + return(GetSkill(SkillSpecializeAlteration)); + case SkillConjuration: + return(GetSkill(SkillSpecializeConjuration)); + case SkillDivination: + return(GetSkill(SkillSpecializeDivination)); + case SkillEvocation: + return(GetSkill(SkillSpecializeEvocation)); default: //wtf... break; @@ -498,20 +498,20 @@ uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const { void Client::CheckSpecializeIncrease(uint16 spell_id) { switch(spells[spell_id].skill) { - case ABJURE: - CheckIncreaseSkill(SPECIALIZE_ABJURE, nullptr); + case SkillAbjuration: + CheckIncreaseSkill(SkillSpecializeAbjure, nullptr); break; - case ALTERATION: - CheckIncreaseSkill(SPECIALIZE_ALTERATION, nullptr); + case SkillAlteration: + CheckIncreaseSkill(SkillSpecializeAlteration, nullptr); break; - case CONJURATION: - CheckIncreaseSkill(SPECIALIZE_CONJURATION, nullptr); + case SkillConjuration: + CheckIncreaseSkill(SkillSpecializeConjuration, nullptr); break; - case DIVINATION: - CheckIncreaseSkill(SPECIALIZE_DIVINATION, nullptr); + case SkillDivination: + CheckIncreaseSkill(SkillSpecializeDivination, nullptr); break; - case EVOCATION: - CheckIncreaseSkill(SPECIALIZE_EVOCATION, nullptr); + case SkillEvocation: + CheckIncreaseSkill(SkillSpecializeEvocation, nullptr); break; default: //wtf... @@ -522,48 +522,48 @@ void Client::CheckSpecializeIncrease(uint16 spell_id) { void Client::CheckSongSkillIncrease(uint16 spell_id){ switch(spells[spell_id].skill) { - case SINGING: - CheckIncreaseSkill(SINGING, nullptr, -15); + case SkillSinging: + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case PERCUSSION_INSTRUMENTS: + case SkillPercussionInstruments: if(this->itembonuses.percussionMod > 0) { - if(GetRawSkill(PERCUSSION_INSTRUMENTS) > 0) // no skill increases if not trained in the instrument - CheckIncreaseSkill(PERCUSSION_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument + CheckIncreaseSkill(SkillPercussionInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); // tell the client that they need instrument training } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case STRINGED_INSTRUMENTS: + case SkillStringedInstruments: if(this->itembonuses.stringedMod > 0) { - if(GetRawSkill(STRINGED_INSTRUMENTS) > 0) - CheckIncreaseSkill(STRINGED_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillStringedInstruments) > 0) + CheckIncreaseSkill(SkillStringedInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case WIND_INSTRUMENTS: + case SkillWindInstruments: if(this->itembonuses.windMod > 0) { - if(GetRawSkill(WIND_INSTRUMENTS) > 0) - CheckIncreaseSkill(WIND_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillWindInstruments) > 0) + CheckIncreaseSkill(SkillWindInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case BRASS_INSTRUMENTS: + case SkillBrassInstruments: if(this->itembonuses.brassMod > 0) { - if(GetRawSkill(BRASS_INSTRUMENTS) > 0) - CheckIncreaseSkill(BRASS_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillBrassInstruments) > 0) + CheckIncreaseSkill(SkillBrassInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; default: break; @@ -904,7 +904,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells; // max 93% chance at 252 skill - channelchance = 30 + GetSkill(CHANNELING) / 400.0f * 100; + channelchance = 30 + GetSkill(SkillChanneling) / 400.0f * 100; channelchance -= attacked_count * 2; channelchance += channelchance * channelbonuses / 100.0f; } @@ -918,7 +918,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells; // max 93% chance at 252 skill - channelchance = 30 + GetSkill(CHANNELING) / 400.0f * 100; + channelchance = 30 + GetSkill(SkillChanneling) / 400.0f * 100; channelchance -= attacked_count * 2; channelchance += channelchance * channelbonuses / 100.0f; } @@ -950,7 +950,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, } } - mlog(SPELLS__CASTING, "Checking Interruption: spell x: %f spell y: %f cur x: %f cur y: %f channelchance %f channeling skill %d\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(CHANNELING)); + mlog(SPELLS__CASTING, "Checking Interruption: spell x: %f spell y: %f cur x: %f cur y: %f channelchance %f channeling skill %d\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(SkillChanneling)); if(MakeRandomFloat(0, 100) > channelchance) { mlog(SPELLS__CASTING_ERR, "Casting of %d canceled: interrupted.", spell_id); @@ -1239,7 +1239,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, c->CheckIncreaseSkill(spells[spell_id].skill, nullptr); // increased chance of gaining channel skill if you regained concentration - c->CheckIncreaseSkill(CHANNELING, nullptr, regain_conc ? 5 : 0); + c->CheckIncreaseSkill(SkillChanneling, nullptr, regain_conc ? 5 : 0); c->CheckSpecializeIncrease(spell_id); } @@ -2251,7 +2251,7 @@ void Mob::BardPulse(uint16 spell_id, Mob *caster) { action->instrument_mod = caster->GetInstrumentMod(spell_id); action->buff_unknown = 0; action->level = buffs[buffs_i].casterlevel; - action->type = SpellDamageType; + action->type = DamageTypeSpell; entity_list.QueueCloseClients(this, packet, false, 200, 0, true, IsClient() ? FilterPCSpells : FilterNPCSpells); action->buff_unknown = 4; @@ -2317,7 +2317,7 @@ void Mob::BardPulse(uint16 spell_id, Mob *caster) { CombatDamage_Struct *cd = (CombatDamage_Struct *)message_packet->pBuffer; cd->target = action->target; cd->source = action->source; - cd->type = SpellDamageType; + cd->type = DamageTypeSpell; cd->spellid = action->spell; cd->sequence = action->sequence; cd->damage = 0; @@ -3014,7 +3014,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r if(IsDetrimentalSpell(spell_id) && !IsAttackAllowed(spelltar) && !IsResurrectionEffects(spell_id)) { if(!IsClient() || !CastToClient()->GetGM()) { - Message_StringID(MT_Shout, SPELL_NO_HOLD); + Message_StringID(MT_SpellFailure, SPELL_NO_HOLD); return false; } } @@ -3151,7 +3151,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r { if(spelltar->invisible) { - spelltar->Message_StringID(MT_Shout, ALREADY_INVIS, GetCleanName()); + spelltar->Message_StringID(MT_SpellFailure, ALREADY_INVIS, GetCleanName()); safe_delete(action_packet); return false; } @@ -3161,7 +3161,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r { if(spelltar->invisible_undead) { - spelltar->Message_StringID(MT_Shout, ALREADY_INVIS, GetCleanName()); + spelltar->Message_StringID(MT_SpellFailure, ALREADY_INVIS, GetCleanName()); safe_delete(action_packet); return false; } @@ -3171,7 +3171,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r { if(spelltar->invisible_animals) { - spelltar->Message_StringID(MT_Shout, ALREADY_INVIS, GetCleanName()); + spelltar->Message_StringID(MT_SpellFailure, ALREADY_INVIS, GetCleanName()); safe_delete(action_packet); return false; } @@ -3252,7 +3252,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r mlog(SPELLS__CASTING_ERR, "Beneficial ae bard song %d can't take hold %s -> %s, IBA? %d", spell_id, GetName(), spelltar->GetName(), IsBeneficialAllowed(spelltar)); } else { mlog(SPELLS__CASTING_ERR, "Beneficial spell %d can't take hold %s -> %s, IBA? %d", spell_id, GetName(), spelltar->GetName(), IsBeneficialAllowed(spelltar)); - Message_StringID(MT_Shout, SPELL_NO_HOLD); + Message_StringID(MT_SpellFailure, SPELL_NO_HOLD); } safe_delete(action_packet); return false; @@ -3262,7 +3262,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r else if ( !IsAttackAllowed(spelltar, true) && !IsResurrectionEffects(spell_id)) // Detrimental spells - PVP check { mlog(SPELLS__CASTING_ERR, "Detrimental spell %d can't take hold %s -> %s", spell_id, GetName(), spelltar->GetName()); - spelltar->Message_StringID(MT_Shout, YOU_ARE_PROTECTED, GetCleanName()); + spelltar->Message_StringID(MT_SpellFailure, YOU_ARE_PROTECTED, GetCleanName()); safe_delete(action_packet); return false; } @@ -3287,6 +3287,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r spelltar->GetBodyType() != BT_Undead && spelltar->GetBodyType() != BT_Vampire) { + safe_delete(action_packet); return false; } } @@ -3299,7 +3300,8 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r focus = CalcFocusEffect(focusBlockNextSpell, buffs[b].spellid, spell_id); if(focus) { CheckHitsRemaining(b); - Message_StringID(MT_Shout, SPELL_WOULDNT_HOLD); + Message_StringID(MT_SpellFailure, SPELL_WOULDNT_HOLD); + safe_delete(action_packet); return false; } } @@ -3347,6 +3349,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r if(reflect_chance) { Message_StringID(MT_Spells, SPELL_REFLECT, GetCleanName(), spelltar->GetCleanName()); SpellOnTarget(spell_id, this, true, use_resist_adjust, resist_adjust); + safe_delete(action_packet); return false; } } @@ -3520,6 +3523,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r mlog(SPELLS__BUFFS, "Spell %d failed: recipient did not meet the level restrictions", spell_id); if(!IsBardSong(spell_id)) Message_StringID(MT_SpellFailure, SPELL_TOO_POWERFUL); + safe_delete(action_packet); return false; } @@ -3530,7 +3534,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r // spell. It's most likely a buff that can't stack. mlog(SPELLS__CASTING_ERR, "Spell %d could not apply its effects %s -> %s\n", spell_id, GetName(), spelltar->GetName()); if(casting_spell_type != 1) // AA is handled differently - Message_StringID(MT_Shout, SPELL_NO_HOLD); + Message_StringID(MT_SpellFailure, SPELL_NO_HOLD); safe_delete(action_packet); return false; } diff --git a/zone/titles.cpp b/zone/titles.cpp index c2f5a484d..5e2484b39 100644 --- a/zone/titles.cpp +++ b/zone/titles.cpp @@ -51,7 +51,7 @@ bool TitleManager::LoadTitles() while ((row = mysql_fetch_row(result))) { Title.TitleID = atoi(row[0]); - Title.SkillID = (SkillType) atoi(row[1]); + Title.SkillID = (SkillUseTypes) atoi(row[1]); Title.MinSkillValue = atoi(row[2]); Title.MaxSkillValue = atoi(row[3]); Title.MinAAPoints = atoi(row[4]); @@ -193,10 +193,10 @@ bool TitleManager::IsClientEligibleForTitle(Client *c, std::vector:: if(Title->SkillID >= 0) { - if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) < static_cast(Title->MinSkillValue))) + if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) < static_cast(Title->MinSkillValue))) return false; - if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) > static_cast(Title->MaxSkillValue))) + if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) > static_cast(Title->MaxSkillValue))) return false; } diff --git a/zone/tradeskills.cpp b/zone/tradeskills.cpp index 90df72573..fa1e32b7c 100644 --- a/zone/tradeskills.cpp +++ b/zone/tradeskills.cpp @@ -35,7 +35,7 @@ #include "../common/rulesys.h" #include "QuestParserCollection.h" -static const SkillType TradeskillUnknown = _1H_BLUNT; /* an arbitrary non-tradeskill */ +static const SkillUseTypes TradeskillUnknown = Skill1HBlunt; /* an arbitrary non-tradeskill */ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo) { @@ -315,7 +315,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob } //changing from a switch to string of if's since we don't need to iterate through all of the skills in the SkillType enum - if (spec.tradeskill == ALCHEMY) { + if (spec.tradeskill == SkillAlchemy) { if (user_pp.class_ != SHAMAN) { user->Message(13, "This tradeskill can only be performed by a shaman."); return; @@ -325,13 +325,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob return; } } - else if (spec.tradeskill == TINKERING) { + else if (spec.tradeskill == SkillTinkering) { if (user_pp.race != GNOME) { user->Message(13, "Only gnomes can tinker."); return; } } - else if (spec.tradeskill == MAKE_POISON) { + else if (spec.tradeskill == SkillMakePoison) { if (user_pp.class_ != ROGUE) { user->Message(13, "Only rogues can mix poisons."); return; @@ -576,75 +576,75 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac parse->EventPlayer(EVENT_COMBINE_FAILURE, user, spec.name.c_str(), spec.recipe_id); } -SkillType Object::TypeToSkill(uint32 type) +SkillUseTypes Object::TypeToSkill(uint32 type) { - switch(type) // grouped and ordered by SkillType name - new types need to be verified for proper SkillType and use + switch(type) // grouped and ordered by SkillUseTypes name - new types need to be verified for proper SkillUseTypes and use { - /*ALCHEMY*/ - case BagType_MedicineBag: { return (SkillType)ALCHEMY; } +/*SkillAlchemy*/ + case BagTypeMedicineBag: { return SkillAlchemy; } - /*BAKING*/ - // case BagType_MixingBowl: // No idea... - case BagType_Oven: { return (SkillType)BAKING; } +/*SkillBaking*/ + // case BagTypeMixingBowl: // No idea... + case BagTypeOven: { return SkillBaking; } - /*BLACKSMITHING*/ - case BagType_Forge: - // case BagType_KoadaDalForge: - case BagType_TeirDalForge: - case BagType_OggokForge: - case BagType_StormguardForge: - // case BagType_AkanonForge: - // case BagType_NorthmanForge: - // case BagType_CabilisForge: - // case BagType_FreeportForge: - // case BagType_RoyalQeynosForge: - // case BagType_TrollForge: - case BagType_FierDalForge: - case BagType_ValeForge: { return (SkillType)BLACKSMITHING; } // Delete return if BagType_GuktaForge enabled - // case BagType_ErudForge: - // case BagType_GuktaForge: { return (SkillType)BLACKSMITHING; } +/*SkillBlacksmithing*/ + case BagTypeForge: + // case BagTypeKoadaDalForge: + case BagTypeTeirDalForge: + case BagTypeOggokForge: + case BagTypeStormguardForge: + // case BagTypeAkanonForge: + // case BagTypeNorthmanForge: + // case BagTypeCabilisForge: + // case BagTypeFreeportForge: + // case BagTypeRoyalQeynosForge: + // case BagTypeTrollForge: + case BagTypeFierDalForge: + case BagTypeValeForge: { return SkillBlacksmithing; } // Delete return if BagTypeGuktaForge enabled + // case BagTypeErudForge: + // case BagTypeGuktaForge: { return SkillBlacksmithing; } - /*BREWING*/ - // case BagType_IceCreamChurn: // No idea... - case BagType_BrewBarrel: { return (SkillType)BREWING; } +/*SkillBrewing*/ + // case BagTypeIceCreamChurn: // No idea... + case BagTypeBrewBarrel: { return SkillBrewing; } - /*FISHING*/ - case BagType_TackleBox: { return (SkillType)FISHING; } +/*SkillFishing*/ + case BagTypeTackleBox: { return SkillFishing; } - /*FLETCHING*/ - case BagType_FletchingKit: { return (SkillType)FLETCHING; } // Delete return if BagType_FierDalFletchingKit enabled - // case BagType_FierDalFletchingKit: { return (SkillType)FLETCHING; } +/*SkillFletching*/ + case BagTypeFletchingKit: { return SkillFletching; } // Delete return if BagTypeFierDalFletchingKit enabled + // case BagTypeFierDalFletchingKit: { return SkillFletching; } - /*JEWELRY_MAKING*/ - case BagType_JewelersKit: { return (SkillType)JEWELRY_MAKING; } +/*SkillJewelryMaking*/ + case BagTypeJewelersKit: { return SkillJewelryMaking; } - /*MAKE_POISON*/ - // This is a guess and needs to be verified... (Could be ALCHEMY) - // case BagType_Mortar: { return (SkillType)MAKE_POISON; } +/*SkillMakePoison*/ + // This is a guess and needs to be verified... (Could be SkillAlchemy) + // case BagTypeMortar: { return SkillMakePoison; } - /*POTTERY*/ - case BagType_PotteryWheel: - case BagType_Kiln: { return (SkillType)POTTERY; } // Delete return if BagType_IksarPotteryWheel enabled - // case BagType_IksarPotteryWheel: { return (SkillType)POTTERY; } +/*SkillPottery*/ + case BagTypePotteryWheel: + case BagTypeKiln: { return SkillPottery; } // Delete return if BagTypeIksarPotteryWheel enabled + // case BagTypeIksarPotteryWheel: { return SkillPottery; } - /*RESEARCH*/ - // case BagType_Lexicon: - case BagType_WizardsLexicon: - case BagType_MagesLexicon: - case BagType_NecromancersLexicon: - case BagType_EnchantersLexicon: { return (SkillType)RESEARCH; } // Delete return if BagType_ConcordanceofResearch enabled - // case BagType_ConcordanceofResearch: { return (SkillType)RESEARCH; } +/*SkillResearch*/ + // case BagTypeLexicon: + case BagTypeWizardsLexicon: + case BagTypeMagesLexicon: + case BagTypeNecromancersLexicon: + case BagTypeEnchantersLexicon: { return SkillResearch; } // Delete return if BagTypeConcordanceofResearch enabled + // case BagTypeConcordanceofResearch: { return SkillResearch; } - /*TAILORING*/ - case BagType_SewingKit: { return (SkillType)TAILORING; } // Delete return if BagType_FierDalTailoringKit enabled - // case BagType_HalflingTailoringKit: - // case BagType_ErudTailoringKit: - // case BagType_FierDalTailoringKit: { return (SkillType)TAILORING; } +/*SkillTailoring*/ + case BagTypeSewingKit: { return SkillTailoring; } // Delete return if BagTypeFierDalTailoringKit enabled + // case BagTypeHalflingTailoringKit: + // case BagTypeErudTailoringKit: + // case BagTypeFierDalTailoringKit: { return SkillTailoring; } - /*TINKERING*/ - case BagType_ToolBox: { return (SkillType)TINKERING; } +/*SkillTinkering*/ + case BagTypeToolBox: { return SkillTinkering; } - /*Undefined*/ +/*Undefined*/ default: { break; } } @@ -689,7 +689,7 @@ void Client::TradeskillSearchResults(const char *query, unsigned long qlen, unsi // Recipes that have either been made before or were // explicitly learned are excempt from that limit if (RuleB(Skills, UseLimitTradeskillSearchSkillDiff)) { - if (((int32)trivial - (int32)GetSkill((SkillType)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff) + if (((int32)trivial - (int32)GetSkill((SkillUseTypes)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff) && row[4] == nullptr) { continue; @@ -855,17 +855,17 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { // If you want to customize the stage1 success rate do it here. // Remember: skillup_modifier is (float). Lower is better switch(spec->tradeskill) { - case FLETCHING: - case ALCHEMY: - case JEWELRY_MAKING: - case POTTERY: + case SkillFletching: + case SkillAlchemy: + case SkillJewelryMaking: + case SkillPottery: skillup_modifier = 4; break; - case BAKING: - case BREWING: + case SkillBaking: + case SkillBrewing: skillup_modifier = 3; break; - case RESEARCH: + case SkillResearch: skillup_modifier = 1; break; default: @@ -876,10 +876,10 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { // Some tradeskills take the higher of one additional stat beside INT and WIS // to determine the skillup rate. Additionally these tradeskills do not have an // -15 modifier on their statbonus. - if (spec->tradeskill == FLETCHING || spec->tradeskill == MAKE_POISON) { + if (spec->tradeskill == SkillFletching || spec->tradeskill == SkillMakePoison) { thirdstat = GetDEX(); stat_modifier = 0; - } else if (spec->tradeskill == BLACKSMITHING) { + } else if (spec->tradeskill == SkillBlacksmithing) { thirdstat = GetSTR(); stat_modifier = 0; } @@ -932,7 +932,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { //AA modifiers //can we do this with nested switches? - if(spec->tradeskill == ALCHEMY){ + if(spec->tradeskill == SkillAlchemy){ switch(GetAA(aaAlchemyMastery)){ case 1: AAChance = 10; @@ -946,7 +946,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if(spec->tradeskill == JEWELRY_MAKING){ + if(spec->tradeskill == SkillJewelryMaking){ switch(GetAA(aaJewelCraftMastery)){ case 1: AAChance = 10; @@ -961,7 +961,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } const Item_Struct* item = nullptr; - if (spec->tradeskill == BLACKSMITHING) { + if (spec->tradeskill == SkillBlacksmithing) { switch(GetAA(aaBlacksmithingMastery)) { case 1: AAChance = 10; @@ -975,7 +975,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == BAKING) { + if (spec->tradeskill == SkillBaking) { switch(GetAA(aaBakingMastery)) { case 1: AAChance = 10; @@ -989,7 +989,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == BREWING) { + if (spec->tradeskill == SkillBrewing) { switch(GetAA(aaBrewingMastery)) { case 1: AAChance = 10; @@ -1003,7 +1003,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == FLETCHING) { + if (spec->tradeskill == SkillFletching) { switch(GetAA(aaFletchingMastery2)) { case 1: AAChance = 10; @@ -1017,7 +1017,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == POTTERY) { + if (spec->tradeskill == SkillPottery) { switch(GetAA(aaPotteryMastery)) { case 1: AAChance = 10; @@ -1031,7 +1031,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == TAILORING) { + if (spec->tradeskill == SkillTailoring) { switch(GetAA(aaTailoringMastery)) { case 1: AAChance = 10; @@ -1045,7 +1045,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == RESEARCH) { + if (spec->tradeskill == SkillResearch) { switch(GetAA(aaArcaneTongues)) { case 1: AAChance = 10; @@ -1124,7 +1124,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { return(false); } -void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillType tradeskill) +void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillUseTypes tradeskill) { uint16 current_raw_skill = GetRawSkill(tradeskill); @@ -1223,8 +1223,9 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3 qlen = MakeAnyLenString(&query, "SELECT tre.recipe_id " " FROM tradeskill_recipe_entries AS tre" - " WHERE ( tre.item_id IN(%s) AND tre.componentcount>0 )" - " OR ( tre.item_id %s AND tre.iscontainer=1 )" + " INNER JOIN tradeskill_recipe AS tr ON (tre.recipe_id = tr.id) " + " WHERE tr.enabled AND (( tre.item_id IN(%s) AND tre.componentcount>0 )" + " OR ( tre.item_id %s AND tre.iscontainer=1 ))" " GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u" " AND sum(tre.item_id * tre.componentcount) = %u", buf2, containers, count, sum); @@ -1387,7 +1388,7 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id " ON tr.id = tre.recipe_id" " LEFT JOIN (SELECT recipe_id, madecount from char_recipe_list WHERE char_id = %u) AS crl " " ON tr.id = crl.recipe_id " - " WHERE tr.id = %lu AND tre.item_id %s" + " WHERE tr.id = %lu AND tre.item_id %s AND tr.enabled " " GROUP BY tr.id", char_id, (unsigned long)recipe_id, containers); if (!RunQuery(query, qlen, errbuf, &result)) { @@ -1405,7 +1406,7 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id } row = mysql_fetch_row(result); - spec->tradeskill = (SkillType)atoi(row[1]); + spec->tradeskill = (SkillUseTypes)atoi(row[1]); spec->skill_needed = (int16)atoi(row[2]); spec->trivial = (uint16)atoi(row[3]); spec->nofail = atoi(row[4]) ? true : false; @@ -1559,31 +1560,31 @@ void Client::LearnRecipe(uint32 recipeID) } -bool Client::CanIncreaseTradeskill(SkillType tradeskill) { +bool Client::CanIncreaseTradeskill(SkillUseTypes tradeskill) { uint32 rawskill = GetRawSkill(tradeskill); uint16 maxskill = MaxSkill(tradeskill); if (rawskill >= maxskill) //Max skill sanity check return false; - uint8 Baking = (GetRawSkill(BAKING) > 200) ? 1 : 0; - uint8 Smithing = (GetRawSkill(BLACKSMITHING) > 200) ? 1 : 0; - uint8 Brewing = (GetRawSkill(BREWING) > 200) ? 1 : 0; - uint8 Fletching = (GetRawSkill(FLETCHING) > 200) ? 1 : 0; - uint8 Jewelry = (GetRawSkill(JEWELRY_MAKING) > 200) ? 1 : 0; - uint8 Pottery = (GetRawSkill(POTTERY) > 200) ? 1 : 0; - uint8 Tailoring = (GetRawSkill(TAILORING) > 200) ? 1 : 0; + uint8 Baking = (GetRawSkill(SkillBaking) > 200) ? 1 : 0; + uint8 Smithing = (GetRawSkill(SkillBlacksmithing) > 200) ? 1 : 0; + uint8 Brewing = (GetRawSkill(SkillBrewing) > 200) ? 1 : 0; + uint8 Fletching = (GetRawSkill(SkillFletching) > 200) ? 1 : 0; + uint8 Jewelry = (GetRawSkill(SkillJewelryMaking) > 200) ? 1 : 0; + uint8 Pottery = (GetRawSkill(SkillPottery) > 200) ? 1 : 0; + uint8 Tailoring = (GetRawSkill(SkillTailoring) > 200) ? 1 : 0; uint8 SkillTotal = Baking + Smithing + Brewing + Fletching + Jewelry + Pottery + Tailoring; //Tradeskills above 200 uint32 aaLevel = GetAA(aaNewTanaanCraftingMastery); //New Tanaan AA: Each level allows an additional tradeskill above 200 (first one is free) switch (tradeskill) { - case BAKING: - case BLACKSMITHING: - case BREWING: - case FLETCHING: - case JEWELRY_MAKING: - case POTTERY: - case TAILORING: + case SkillBaking: + case SkillBlacksmithing: + case SkillBrewing: + case SkillFletching: + case SkillJewelryMaking: + case SkillPottery: + case SkillTailoring: if (aaLevel == 6) break; //Maxed AA if (SkillTotal == 0) @@ -1598,3 +1599,31 @@ bool Client::CanIncreaseTradeskill(SkillType tradeskill) { } return true; } + +void ZoneDatabase::EnableRecipe(uint32 recipe_id) +{ + char *query = 0; + uint32 qlen; + char errbuf[MYSQL_ERRMSG_SIZE]; + + qlen = MakeAnyLenString(&query, "UPDATE tradeskill_recipe SET enabled = 1 WHERE id = %u;", recipe_id); + + if (!RunQuery(query, qlen, errbuf)) { + LogFile->write(EQEMuLog::Error, "Error in EnableRecipe query '%s': %s", query, errbuf); + } + safe_delete_array(query); +} + +void ZoneDatabase::DisableRecipe(uint32 recipe_id) +{ + char *query = 0; + uint32 qlen; + char errbuf[MYSQL_ERRMSG_SIZE]; + + qlen = MakeAnyLenString(&query, "UPDATE tradeskill_recipe SET enabled = 0 WHERE id = %u;", recipe_id); + + if (!RunQuery(query, qlen, errbuf)) { + LogFile->write(EQEMuLog::Error, "Error in DisableRecipe query '%s': %s", query, errbuf); + } + safe_delete_array(query); +} diff --git a/zone/zone.cpp b/zone/zone.cpp index 98f0126eb..dfddf22ff 100644 --- a/zone/zone.cpp +++ b/zone/zone.cpp @@ -270,7 +270,7 @@ bool Zone::LoadZoneObjects() { //tradeskill containers do not have an itemid of 0... at least what I am seeing if (itemid == 0) { // Generic tradeskill container - inst = new ItemInst(ItemUseWorldContainer); + inst = new ItemInst(ItemInstWorldContainer); } else { // Groundspawn object @@ -279,7 +279,7 @@ bool Zone::LoadZoneObjects() { //Father Nitwit's fix... not perfect... if(inst == nullptr && type != OT_DROPPEDITEM) { - inst = new ItemInst(ItemUseWorldContainer); + inst = new ItemInst(ItemInstWorldContainer); } // Load child objects if container diff --git a/zone/zonedb.cpp b/zone/zonedb.cpp index 31e1b5231..776ff9cfd 100644 --- a/zone/zonedb.cpp +++ b/zone/zonedb.cpp @@ -1197,7 +1197,7 @@ const NPCType* ZoneDatabase::GetNPCType (uint32 id) { { if ((at_row = mysql_fetch_row(at_result))) { - for (i = 0; i < MAX_MATERIALS; i++) + for (i = 0; i < _MaterialCount; i++) { tmpNPCType->armor_tint[i] = atoi(at_row[i * 3]) << 16; tmpNPCType->armor_tint[i] |= atoi(at_row[i * 3 + 1]) << 8; @@ -1230,7 +1230,7 @@ const NPCType* ZoneDatabase::GetNPCType (uint32 id) { if (armor_tint_id == 0) { - for (i = 1; i < MAX_MATERIALS; i++) + for (i = 1; i < _MaterialCount; i++) { tmpNPCType->armor_tint[i] = tmpNPCType->armor_tint[0]; } @@ -1508,7 +1508,7 @@ const NPCType* ZoneDatabase::GetMercType(uint32 id, uint16 raceid, uint32 client { if ((at_row = mysql_fetch_row(at_result))) { - for (i = 0; i < MAX_MATERIALS; i++) + for (i = 0; i < _MaterialCount; i++) { tmpNPCType->armor_tint[i] = atoi(at_row[i * 3]) << 16; tmpNPCType->armor_tint[i] |= atoi(at_row[i * 3 + 1]) << 8; @@ -1541,7 +1541,7 @@ const NPCType* ZoneDatabase::GetMercType(uint32 id, uint16 raceid, uint32 client if (armor_tint_id == 0) { - for (i = 1; i < MAX_MATERIALS; i++) + for (i = 1; i < _MaterialCount; i++) { tmpNPCType->armor_tint[i] = tmpNPCType->armor_tint[0]; } diff --git a/zone/zonedb.h b/zone/zonedb.h index 60ed0e65e..39941e307 100644 --- a/zone/zonedb.h +++ b/zone/zonedb.h @@ -39,7 +39,7 @@ struct DBnpcspells_Struct { }; struct DBTradeskillRecipe_Struct { - SkillType tradeskill; + SkillUseTypes tradeskill; int16 skill_needed; uint16 trivial; bool nofail; @@ -382,9 +382,11 @@ public: */ bool GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec); bool GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec); - uint32 GetZoneForage(uint32 ZoneID, uint8 skill); /* for foraging - BoB */ + uint32 GetZoneForage(uint32 ZoneID, uint8 skill); /* for foraging */ uint32 GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id, uint8 &npc_chance); void UpdateRecipeMadecount(uint32 recipe_id, uint32 char_id, uint32 madecount); + void EnableRecipe(uint32 recipe_id); + void DisableRecipe(uint32 recipe_id); /* * Tribute diff --git a/zone/zonedbasync.cpp b/zone/zonedbasync.cpp index e07b28d6e..4d1bf8491 100644 --- a/zone/zonedbasync.cpp +++ b/zone/zonedbasync.cpp @@ -21,11 +21,11 @@ void DispatchFinishedDBAsync(DBAsyncWork* dbaw) { if (dbaq->GetAnswer(errbuf, result)) database.LoadVariables_result(result); else - cout << "Async DB.LoadVariables() failed: '" << errbuf << "'" << endl; + std::cout << "Async DB.LoadVariables() failed: '" << errbuf << "'" << std::endl; break; } default: { - cout << "Error: DispatchFinishedDBAsync(): Unknown workpt.b4" << endl; + std::cout << "Error: DispatchFinishedDBAsync(): Unknown workpt.b4" << std::endl; break; } } @@ -119,7 +119,7 @@ bool DBAsyncCB_CharacterBackup(DBAsyncWork* iWork) { // return true means delete } } else { -// cout << "Error in DBAsyncCB_CharacterBackup query1 '" << query << "' " << errbuf << endl; +// std::cout << "Error in DBAsyncCB_CharacterBackup query1 '" << query << "' " << errbuf << std::endl; safe_delete_array(query); return true; } diff --git a/zone/zonedump.h b/zone/zonedump.h index 60333515a..65774d078 100644 --- a/zone/zonedump.h +++ b/zone/zonedump.h @@ -85,7 +85,7 @@ struct NPCType uint32 drakkin_heritage; uint32 drakkin_tattoo; uint32 drakkin_details; - uint32 armor_tint[MAX_MATERIALS]; + uint32 armor_tint[_MaterialCount]; uint32 min_dmg; uint32 max_dmg; int16 attack_count;