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

Merge branch 'master' into base_data

Browse Source
This commit is contained in:
KimLS 2013-11-06 13:18:20 -08:00
commit c944aafb39
91 changed files with 2061 additions and 1561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
changelog.txt
View File

@ -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.

2
common/EQPacket.cpp
View File

@ -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);

12
common/EQStream.cpp
View File

@ -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());
}

18
common/EQStreamFactory.cpp
View File

@ -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<std::string,EQStream *>::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;
}
}
}

10
common/EmuTCPConnection.cpp
View File

@ -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);

58
common/Item.cpp
View File

@ -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;
}

20
common/Item.h
View File

@ -43,9 +43,11 @@ typedef std::list<ItemInst*>::const_iterator iter_queue;
typedef std::map<int16, ItemInst*>::const_iterator iter_inst;
typedef std::map<uint8, ItemInst*>::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

2
common/TCPConnection.cpp
View File

@ -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 */

2
common/TCPServer.h
View File

@ -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);

6
common/database.cpp
View File

@ -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;
}

179
common/deity.h
View File

@ -18,48 +18,149 @@
#ifndef DEITY_H
#define DEITY_H
#include "types.h"
#include <string>
// 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

509
common/eq_constants.h
View File

@ -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
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 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.

22
common/eq_packet_structs.h
View File

@ -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];
};
};

4
common/eqtime.cpp
View File

@ -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;
}

2
common/extprofile.h
View File

@ -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;

2
common/linked_list.h
View File

@ -337,7 +337,7 @@ ListElement<TYPE>::ListElement(const TYPE& d)
template<class TYPE>
ListElement<TYPE>::~ListElement()
{
// cout << "ListElement<TYPE>::~ListElement()" << endl;
// std::cout << "ListElement<TYPE>::~ListElement()" << std::endl;
if (data != 0)
safe_delete(data);

2
common/packet_dump.cpp
View File

@ -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)

4
common/packet_dump_file.cpp
View File

@ -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)

4
common/patches/Client62.cpp
View File

@ -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);

8
common/patches/Client62_structs.h
View File

@ -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; //

11
common/patches/RoF.cpp
View File

@ -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);

2
common/patches/RoF_structs.h
View File

@ -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;

10
common/patches/SoD.cpp
View File

@ -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);
}

6
common/patches/SoD_structs.h
View File

@ -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)

6
common/patches/SoF.cpp
View File

@ -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);

6
common/patches/SoF_structs.h
View File

@ -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)

4
common/patches/Titanium.cpp
View File

@ -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);

6
common/patches/Titanium_structs.h
View File

@ -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)

10
common/patches/Underfoot.cpp
View File

@ -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);
}

6
common/patches/Underfoot_structs.h
View File

@ -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)

2
common/seperator.h
View File

@ -57,7 +57,7 @@ public:
return;
for (i=0; i<len; i++) {
// cout << i << ": 0x" << hex << (int) message[i] << dec << " " << message[i] << endl;
// std::cout << i << ": 0x" << std::hex << (int) message[i] << std::dec << " " << message[i] << std::endl; // undefined cout [CODEBUG]
if (inarg) {
if ((inquote == false && (message[i] == div || message[i] == div2 || message[i] == div3)) || (inquote && (message[i] == '\'' || message[i] == '\"') && (message[i+1] == div || message[i+1] == div2 || message[i+1] == div3 || message[i+1] == 0))) {
inquote = false;

8
common/shareddb.cpp
View File

@ -1476,7 +1476,7 @@ void SharedDatabase::LoadSkillCaps(void *data) {
}
}
uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level) {
uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillUseTypes Skill, uint8 Level) {
if(!skill_caps_mmf) {
return 0;
}
@ -1505,7 +1505,7 @@ uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level) {
return skill_caps_table[index];
}
uint8 SharedDatabase::GetTrainLevel(uint8 Class_, SkillType Skill, uint8 Level) {
uint8 SharedDatabase::GetTrainLevel(uint8 Class_, SkillUseTypes Skill, uint8 Level) {
if(!skill_caps_mmf) {
return 0;
}
@ -1683,9 +1683,9 @@ void SharedDatabase::LoadSpells(void *data, int max_spells) {
sp[tempid].basediff=atoi(row[99]);
int tmp_skill = atoi(row[100]);;
if(tmp_skill < 0 || tmp_skill > 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]);

4
common/shareddb.h
View File

@ -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);

162
common/skills.h
View File

@ -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

2
common/spdat.h
View File

@ -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;

4
utils/player_profile_set/player_profile_set/eq_player_structs.h
View File

@ -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; //

1
utils/sql/git/required/2013_10_31_Recipe_disabling.sql Normal file
View File

@ -0,0 +1 @@
ALTER TABLE `tradeskill_recipe` ADD `enabled` tinyint(1) NOT NULL DEFAULT '1';

52
world/client.cpp
View File

@ -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;
}
}

4
world/worlddb.cpp
View File

@ -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;

2
zone/AA.cpp
View File

@ -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;

12
zone/MobAI.cpp
View File

@ -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);

2
zone/Object.cpp
View File

@ -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;

183
zone/attack.cpp
View File

@ -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<SkillType>(GetPrimSkill());
skillinuse = static_cast<SkillUseTypes>(GetPrimSkill());
OffHandAtk(false);
}
if (Hand == 14) {
skillinuse = static_cast<SkillType>(GetSecSkill());
skillinuse = static_cast<SkillUseTypes>(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<SkillType>(36);
skillinuse = static_cast<SkillUseTypes>(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)
{

4
zone/beacon.h
View File

@ -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; }

3
zone/bonuses.cpp
View File

@ -29,6 +29,7 @@
#include "QuestParserCollection.h"
#include <math.h>
#include <assert.h>
#include <iostream>
#ifndef WIN32
#include <stdlib.h>
#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)"<<endl;
std::cout<<"Client::CalcEdibleBonuses(StatBonuses* newbon)"<<std::endl;
#endif
// Search player slots for skill=14(food) and skill=15(drink)
uint32 i;

330
zone/bot.cpp
View File

@ -1251,19 +1251,19 @@ void Bot::GenerateArmorClass()
{
/// new formula
int avoidance = 0;
avoidance = (acmod() + ((GetSkill(DEFENSE)*16)/9));
avoidance = (acmod() + ((GetSkill(SkillDefense)*16)/9));
if(avoidance < 0)
avoidance = 0;
int mitigation = 0;
if(GetClass() == WIZARD || GetClass() == MAGICIAN || GetClass() == NECROMANCER || GetClass() == ENCHANTER)
{
mitigation = GetSkill(DEFENSE)/4 + (itembonuses.AC+1);
mitigation = GetSkill(SkillDefense)/4 + (itembonuses.AC+1);
mitigation -= 4;
}
else
{
mitigation = GetSkill(DEFENSE)/3 + ((itembonuses.AC*4)/3);
mitigation = GetSkill(SkillDefense)/3 + ((itembonuses.AC*4)/3);
if(GetClass() == MONK)
mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close...
}
@ -1290,56 +1290,56 @@ void Bot::GenerateArmorClass()
uint16 Bot::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(SLOT_PRIMARY);
if(!equiped)
{
skill = HAND_TO_HAND;
skill = SkillHandtoHand;
}
else
{
uint8 type = m_inv.GetItem(SLOT_PRIMARY)->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);
}
}

20
zone/bot.h
View File

@ -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();

2
zone/botspellsai.cpp
View File

@ -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.

196
zone/client.cpp
View File

@ -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<uint64>(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<std::string, SkillType> Skills;
std::map<std::string, SkillType>::iterator it;
std::map<std::string, SkillUseTypes> Skills;
std::map<std::string, SkillUseTypes>::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;

40
zone/client.h
View File

@ -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);

42
zone/client_mods.cpp
View File

@ -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);

118
zone/client_packet.cpp
View File

@ -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;

58
zone/client_process.cpp
View File

@ -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;

78
zone/command.cpp
View File

@ -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");
}
}
}

2
zone/command.h
View File

@ -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);

4
zone/corpse.h
View File

@ -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; }

6
zone/doors.cpp
View File

@ -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);

39
zone/embparser_api.cpp
View File

@ -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,6 +3563,8 @@ 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);
newXS(strcpy(buf, "enablerecipe"), XS__enablerecipe, file);
newXS(strcpy(buf, "disablerecipe"), XS__disablerecipe, file);
XSRETURN_YES;
}

12
zone/entity.cpp
View File

@ -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)

12
zone/forage.cpp
View File

@ -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);
}

6
zone/inventory.cpp
View File

@ -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

22
zone/loottables.cpp
View File

@ -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;
}
/*

16
zone/lua_client.cpp
View File

@ -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<SkillType>(skill_id));
return self->GetRawSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::HasSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->HasSkill(static_cast<SkillType>(skill_id));
return self->HasSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::CanHaveSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->CanHaveSkill(static_cast<SkillType>(skill_id));
return self->CanHaveSkill(static_cast<SkillUseTypes>(skill_id));
}
void Lua_Client::SetSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->SetSkill(static_cast<SkillType>(skill_id), value);
self->SetSkill(static_cast<SkillUseTypes>(skill_id), value);
}
void Lua_Client::AddSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->AddSkill(static_cast<SkillType>(skill_id), value);
self->AddSkill(static_cast<SkillUseTypes>(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<SkillType>(skill_id), target);
self->CheckIncreaseSkill(static_cast<SkillUseTypes>(skill_id), target);
}
void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) {
Lua_Safe_Call_Void();
self->CheckIncreaseSkill(static_cast<SkillType>(skill_id), target, chance_mod);
self->CheckIncreaseSkill(static_cast<SkillUseTypes>(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<SkillType>(skill_id));
return self->MaxSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::IsMedding() {

35
zone/lua_general.cpp
View File

@ -1021,6 +1021,14 @@ void lua_clear_opcode(int op) {
ClearMappedOpcode(static_cast<EmuOpcode>(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_<Materials>("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<int>(MaterialHead)),
luabind::value("Chest", static_cast<int>(MaterialChest)),
luabind::value("Arms", static_cast<int>(MaterialArms)),
luabind::value("Bracer", static_cast<int>(MaterialWrist)), // deprecated
luabind::value("Wrist", static_cast<int>(MaterialWrist)),
luabind::value("Hands", static_cast<int>(MaterialHands)),
luabind::value("Legs", static_cast<int>(MaterialLegs)),
luabind::value("Feet", static_cast<int>(MaterialFeet)),
luabind::value("Primary", static_cast<int>(MaterialPrimary)),
luabind::value("Secondary", static_cast<int>(MaterialSecondary)),
luabind::value("Max", static_cast<int>(_MaterialCount)), // deprecated
luabind::value("Count", static_cast<int>(_MaterialCount)),
luabind::value("Invalid", static_cast<int>(_MaterialInvalid))
];
}

2
zone/lua_iteminst.cpp
View File

@ -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<ItemClass>(item_class));
return self->IsType(static_cast<ItemClassTypes>(item_class));
}
bool Lua_ItemInst::IsStackable() {

34
zone/lua_mob.cpp
View File

@ -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<SkillType>(attack_skill));
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable, buffslot);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable, buffslot, buff_tic);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(skill), max_damage);
}
void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage) {
Lua_Safe_Call_Void();
self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(skill), max_damage, min_damage);
}
void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override) {
Lua_Safe_Call_Void();
self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(skill), max_damage, min_damage, hate_override);
}
void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time) {
Lua_Safe_Call_Void();
self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(skill), max_damage, min_damage, hate_override, reuse_time);
}
void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time,
bool hit_chance) {
Lua_Safe_Call_Void();
self->DoSpecialAttackDamage(other, static_cast<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill));
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(skill));
}
void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod) {
Lua_Safe_Call_Void();
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(skill), chance_mod);
}
void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus) {
Lua_Safe_Call_Void();
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod, focus);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(skill), chance_mod, focus);
}
void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus, bool can_riposte) {
Lua_Safe_Call_Void();
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillType>(skill), chance_mod, focus, can_riposte);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(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<SkillType>(skill), value);
self->ModSkillDmgTaken(static_cast<SkillUseTypes>(skill), value);
}
int Lua_Mob::GetModSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetModSkillDmgTaken(static_cast<SkillType>(skill));
return self->GetModSkillDmgTaken(static_cast<SkillUseTypes>(skill));
}
int Lua_Mob::GetSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetSkillDmgTaken(static_cast<SkillType>(skill));
return self->GetSkillDmgTaken(static_cast<SkillUseTypes>(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<SkillType>(skill));
return self->GetSkill(static_cast<SkillUseTypes>(skill));
}
int Lua_Mob::GetSpecialAbility(int ability) {

14
zone/maxskill.h
View File

@ -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: "<<class_<<endl;
std::cout<<"MaxSkill_Weapon() Unknown class: "<<class_<<std::endl;
#endif
break;
}
@ -281,7 +283,7 @@ uint16 Mob::MaxSkill_weapon(uint16 skillid, uint16 class_, uint16 level) const{
}
default:
#if EQDEBUG
cout<<"Unknown weapon skill: "<<skillid<<endl;
std::cout<<"Unknown weapon skill: "<<skillid<<std::endl;
#endif
break;
}// Switch skill
@ -812,7 +814,7 @@ uint16 Mob::MaxSkill_offensive(uint16 skillid, uint16 class_, uint16 level) cons
////////////////////////////////////////////////////////
default:
#if EQDEBUG >= 1
cout<<"Unknown Offensive skill: "<<skillid<<endl;
std::cout<<"Unknown Offensive skill: "<<skillid<<std::endl;
#endif
break;
}// Switch skill
@ -1351,7 +1353,7 @@ uint16 Mob::MaxSkill_defensive(uint16 skillid, uint16 class_, uint16 level) cons
default:
#if EQDEBUG
cout<<"Unknown Defensive skill: "<<skillid<<endl;
std::cout<<"Unknown Defensive skill: "<<skillid<<std::endl;
#endif
break;
}// Switch skill
@ -1613,7 +1615,7 @@ uint16 Mob::MaxSkill_arcane(uint16 skillid, uint16 class_, uint16 level) const{
////////////////////////////////////////////////////////
default:
#if EQDEBUG
cout<<"Unknown arcane skill: "<<skillid<<endl;
std::cout<<"Unknown arcane skill: "<<skillid<<std::endl;
#endif
break;
}// Switch skill
@ -2069,7 +2071,7 @@ uint16 Mob::MaxSkill_class(uint16 skillid, uint16 class_, uint16 level) const{
////////////////////////////////////////////////////////
default:
#if EQDEBUG
cout<<"Unknown class skill: "<<skillid<<endl;
std::cout<<"Unknown class skill: "<<skillid<<std::endl;
#endif
break;
}// Switch skill

34
zone/merc.cpp
View File

@ -59,7 +59,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
int r;
for(r = 0; r <= HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(),(SkillType)r,GetLevel());
skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,GetLevel());
}
GetMercSize();
@ -983,8 +983,8 @@ int32 Merc::CalcBaseManaRegen()
int32 regen = 0;
if (IsSitting())
{
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;
}
@ -1000,9 +1000,9 @@ int32 Merc::CalcManaRegen()
if (IsSitting())
{
BuffFadeBySitModifier();
if(HasSkill(MEDITATE)) {
if(HasSkill(SkillMeditate)) {
this->_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;

12
zone/merc.h
View File

@ -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();

92
zone/mob.cpp
View File

@ -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<<endl;
//std::cout<<"Tlevel: "<<(int)tlevel<<std::endl; // cout undefined [CODEBUG]
int multiplier = 0;
if (tlevel < 10)
{
@ -3308,7 +3308,7 @@ int32 Mob::GetVulnerability(int32 damage, Mob *caster, uint32 spell_id, uint32 t
return damage;
}
int16 Mob::GetSkillDmgTaken(const SkillType skill_used)
int16 Mob::GetSkillDmgTaken(const SkillUseTypes skill_used)
{
int skilldmg_mod = 0;
@ -4414,7 +4414,7 @@ void Mob::SetBodyType(bodyType new_body, bool overwrite_orig) {
}
void Mob::ModSkillDmgTaken(SkillType skill_num, int value)
void Mob::ModSkillDmgTaken(SkillUseTypes skill_num, int value)
{
if (skill_num <= HIGHEST_SKILL)
SkillDmgTaken_Mod[skill_num] = value;
@ -4424,7 +4424,7 @@ void Mob::ModSkillDmgTaken(SkillType skill_num, int value)
SkillDmgTaken_Mod[HIGHEST_SKILL+1] = value;
}
int16 Mob::GetModSkillDmgTaken(const SkillType skill_num)
int16 Mob::GetModSkillDmgTaken(const SkillUseTypes skill_num)
{
if (skill_num <= HIGHEST_SKILL)
return SkillDmgTaken_Mod[skill_num];
@ -4536,24 +4536,24 @@ uint16 Mob::GetSkillByItemType(int ItemType)
{
switch (ItemType)
{
case ItemType1HS:
return _1H_SLASHING;
case ItemType2HS:
return _2H_SLASHING;
case ItemTypePierce:
return PIERCING;
case ItemType1HB:
return _1H_BLUNT;
case ItemType2HB:
return _2H_BLUNT;
case ItemType2HPierce:
return PIERCING;
case ItemTypeHand2Hand:
return HAND_TO_HAND;
case ItemType1HSlash:
return Skill1HSlashing;
case ItemType2HSlash:
return Skill2HSlashing;
case ItemType1HPiercing:
return Skill1HPiercing;
case ItemType1HBlunt:
return Skill1HBlunt;
case ItemType2HBlunt:
return Skill2HBlunt;
case ItemType2HPiercing:
return Skill1HPiercing; // change to 2HPiercing once activated
case ItemTypeMartial:
return SkillHandtoHand;
default:
return HAND_TO_HAND;
return SkillHandtoHand;
}
return HAND_TO_HAND;
return SkillHandtoHand;
}

42
zone/mob.h
View File

@ -84,7 +84,7 @@ public:
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
uint8 in_see_invis_undead, // see through invis vs. undead
@ -117,11 +117,11 @@ public:
virtual void TryBackstab(Mob *other,int ReuseTime = 10);
void TriggerDefensiveProcs(const ItemInst* weapon, Mob *on, uint16 hand = 13, int damage = 0);
virtual bool AvoidDamage(Mob* attacker, int32 &damage, bool CanRiposte = true);
virtual bool CheckHitChance(Mob* attacker, SkillType skillinuse, int Hand, int16 chance_mod = 0);
virtual bool CheckHitChance(Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod = 0);
virtual void TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttackOptions *opts = nullptr);
void TryPetCriticalHit(Mob *defender, uint16 skill, int32 &damage);
virtual bool TryFinishingBlow(Mob *defender, SkillType skillinuse);
virtual bool TryHeadShot(Mob* defender, SkillType skillInUse);
virtual bool TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse);
virtual bool TryHeadShot(Mob* defender, SkillUseTypes skillInUse);
virtual void DoRiposte(Mob* defender);
void ApplyMeleeDamageBonus(uint16 skill, int32 &damage);
virtual void MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttackOptions *opts = nullptr);
@ -147,7 +147,7 @@ public:
inline bool SeeImprovedHide() const { return see_improved_hide; }
bool IsInvisible(Mob* other = 0) const;
void SetInvisible(uint8 state);
bool AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapon);
bool AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon);
//Song
bool UseBardSpellLogic(uint16 spell_id = 0xffff, int slot = -1);
@ -257,14 +257,14 @@ public:
void TempName(const char *newname = nullptr);
void SetTargetable(bool on);
bool IsTargetable() const { return m_targetable; }
virtual uint16 GetSkill(SkillType skill_num) const { return 0; }
virtual uint16 GetSkill(SkillUseTypes skill_num) const { return 0; }
virtual uint32 GetEquipment(uint8 material_slot) const { return(0); }
virtual int32 GetEquipmentMaterial(uint8 material_slot) const;
virtual uint32 GetEquipmentColor(uint8 material_slot) const;
virtual uint32 IsEliteMaterialItem(uint8 material_slot) const;
bool AffectedBySpellExcludingSlot(int slot, int effect);
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) = 0;
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) = 0;
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill,
bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) = 0;
inline virtual void SetHP(int32 hp) { if (hp >= 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;

10
zone/mod_functions.cpp
View File

@ -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); }

18
zone/npc.cpp
View File

@ -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:"<<iterator.GetData()->equipSlot<<" quantity:"<< quantity<<endl;
//std::cout<<"NPC::RemoveItem"<<" equipSlot:"<<iterator.GetData()->equipSlot<<" quantity:"<< quantity<<std::endl; // iterator undefined [CODEBUG]
if (item->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;

8
zone/npc.h
View File

@ -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);

6
zone/object.h
View File

@ -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;

16
zone/perl_client.cpp
View File

@ -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;

14
zone/perl_mob.cpp
View File

@ -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));

2
zone/perl_questitem.cpp
View File

@ -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));
}

35
zone/questmgr.cpp
View File

@ -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();

2
zone/questmgr.h
View File

@ -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;

152
zone/skills.h
View File

@ -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

294
zone/special_attacks.cpp
View File

@ -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
}

8
zone/spell_effects.cpp
View File

@ -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)

108
zone/spells.cpp
View File

@ -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;
}

6
zone/titles.cpp
View File

@ -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<TitleEntry>::
if(Title->SkillID >= 0)
{
if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillType>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
return false;
if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillType>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
return false;
}

225
zone/tradeskills.cpp
View File

@ -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);
}

4
zone/zone.cpp
View File

@ -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

8
zone/zonedb.cpp
View File

@ -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];
}

6
zone/zonedb.h
View File

@ -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

6
zone/zonedbasync.cpp
View File

@ -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;
}

2
zone/zonedump.h
View File

@ -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;