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

Rename LogDebugType to DebugCategory

Browse Source
This commit is contained in:
Akkadius 2015-01-16 03:09:02 -06:00
parent 5a3b40c503
commit 132fbbb0c6
70 changed files with 1039 additions and 1039 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

242
common/eq_stream.cpp
View File

@ -81,18 +81,18 @@ void EQStream::init(bool resetSession) {
OpMgr = nullptr; OpMgr = nullptr;
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
} }
EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p) EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
{ {
EQRawApplicationPacket *ap=nullptr; EQRawApplicationPacket *ap=nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Creating new application packet, length %d" __L, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Creating new application packet, length %d" __L, p->size);
_raw(NET__APP_CREATE_HEX, 0xFFFF, p); _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
ap = p->MakeAppPacket(); ap = p->MakeAppPacket();
return ap; return ap;
@ -101,7 +101,7 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len) EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
{ {
EQRawApplicationPacket *ap=nullptr; EQRawApplicationPacket *ap=nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Creating new application packet, length %d" __L, len); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Creating new application packet, length %d" __L, len);
_hex(NET__APP_CREATE_HEX, buf, len); _hex(NET__APP_CREATE_HEX, buf, len);
ap = new EQRawApplicationPacket(buf, len); ap = new EQRawApplicationPacket(buf, len);
return ap; return ap;
@ -132,7 +132,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
} }
if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) { if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Session not initialized, packet ignored" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Session not initialized, packet ignored" __L);
_raw(NET__DEBUG, 0xFFFF, p); _raw(NET__DEBUG, 0xFFFF, p);
return; return;
} }
@ -143,7 +143,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
while(processed < p->size) { while(processed < p->size) {
subpacket_length=*(p->pBuffer+processed); subpacket_length=*(p->pBuffer+processed);
EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length); EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
_raw(NET__NET_CREATE_HEX, 0xFFFF, subp); _raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
subp->copyInfo(p); subp->copyInfo(p);
ProcessPacket(subp); ProcessPacket(subp);
@ -158,12 +158,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
while(processed<p->size) { while(processed<p->size) {
EQRawApplicationPacket *ap=nullptr; EQRawApplicationPacket *ap=nullptr;
if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) { if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length); ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length);
processed+=subpacket_length+1; processed+=subpacket_length+1;
} else { } else {
subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1)); subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length); ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length);
processed+=subpacket_length+3; processed+=subpacket_length+3;
} }
@ -178,29 +178,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_Packet: { case OP_Packet: {
if(!p->pBuffer || (p->Size() < 4)) if(!p->pBuffer || (p->Size() < 4))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Packet that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Packet that was of malformed size" __L);
break; break;
} }
uint16 seq=ntohs(*(uint16 *)(p->pBuffer)); uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
SeqOrder check=CompareSequence(NextInSeq,seq); SeqOrder check=CompareSequence(NextInSeq,seq);
if (check == SeqFuture) { if (check == SeqFuture) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p); _raw(NET__DEBUG, seq, p);
PacketQueue[seq]=p->Copy(); PacketQueue[seq]=p->Copy();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
//SendOutOfOrderAck(seq); //SendOutOfOrderAck(seq);
} else if (check == SeqPast) { } else if (check == SeqPast) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p); _raw(NET__DEBUG, seq, p);
SendOutOfOrderAck(seq); //we already got this packet but it was out of order SendOutOfOrderAck(seq); //we already got this packet but it was out of order
} else { } else {
// In case we did queue one before as well. // In case we did queue one before as well.
EQProtocolPacket *qp=RemoveQueue(seq); EQProtocolPacket *qp=RemoveQueue(seq);
if (qp) { if (qp) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
delete qp; delete qp;
} }
@ -209,7 +209,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
// Check for an embedded OP_AppCombinded (protocol level 0x19) // Check for an embedded OP_AppCombinded (protocol level 0x19)
if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) { if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2); EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
_raw(NET__NET_CREATE_HEX, seq, subp); _raw(NET__NET_CREATE_HEX, seq, subp);
subp->copyInfo(p); subp->copyInfo(p);
ProcessPacket(subp); ProcessPacket(subp);
@ -228,29 +228,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_Fragment: { case OP_Fragment: {
if(!p->pBuffer || (p->Size() < 4)) if(!p->pBuffer || (p->Size() < 4))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Fragment that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Fragment that was of malformed size" __L);
break; break;
} }
uint16 seq=ntohs(*(uint16 *)(p->pBuffer)); uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
SeqOrder check=CompareSequence(NextInSeq,seq); SeqOrder check=CompareSequence(NextInSeq,seq);
if (check == SeqFuture) { if (check == SeqFuture) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p); _raw(NET__DEBUG, seq, p);
PacketQueue[seq]=p->Copy(); PacketQueue[seq]=p->Copy();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
//SendOutOfOrderAck(seq); //SendOutOfOrderAck(seq);
} else if (check == SeqPast) { } else if (check == SeqPast) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p); _raw(NET__DEBUG, seq, p);
SendOutOfOrderAck(seq); SendOutOfOrderAck(seq);
} else { } else {
// In case we did queue one before as well. // In case we did queue one before as well.
EQProtocolPacket *qp=RemoveQueue(seq); EQProtocolPacket *qp=RemoveQueue(seq);
if (qp) { if (qp) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
delete qp; delete qp;
} }
SetNextAckToSend(seq); SetNextAckToSend(seq);
@ -258,18 +258,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
if (oversize_buffer) { if (oversize_buffer) {
memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2); memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2);
oversize_offset+=p->size-2; oversize_offset+=p->size-2;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
if (oversize_offset==oversize_length) { if (oversize_offset==oversize_length) {
if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) { if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset); EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
//_raw(NET__NET_CREATE_HEX, subp); //_raw(NET__NET_CREATE_HEX, subp);
subp->copyInfo(p); subp->copyInfo(p);
ProcessPacket(subp); ProcessPacket(subp);
delete subp; delete subp;
} else { } else {
EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset); EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
if (ap) { if (ap) {
ap->copyInfo(p); ap->copyInfo(p);
InboundQueuePush(ap); InboundQueuePush(ap);
@ -284,7 +284,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
oversize_buffer=new unsigned char[oversize_length]; oversize_buffer=new unsigned char[oversize_length];
memcpy(oversize_buffer,p->pBuffer+6,p->size-6); memcpy(oversize_buffer,p->pBuffer+6,p->size-6);
oversize_offset=p->size-6; oversize_offset=p->size-6;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
} }
} }
} }
@ -292,14 +292,14 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_KeepAlive: { case OP_KeepAlive: {
#ifndef COLLECTOR #ifndef COLLECTOR
NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size)); NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received and queued reply to keep alive" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received and queued reply to keep alive" __L);
#endif #endif
} }
break; break;
case OP_Ack: { case OP_Ack: {
if(!p->pBuffer || (p->Size() < 4)) if(!p->pBuffer || (p->Size() < 4))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Ack that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_Ack that was of malformed size" __L);
break; break;
} }
#ifndef COLLECTOR #ifndef COLLECTOR
@ -315,12 +315,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_SessionRequest: { case OP_SessionRequest: {
if(p->Size() < sizeof(SessionRequest)) if(p->Size() < sizeof(SessionRequest))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
break; break;
} }
#ifndef COLLECTOR #ifndef COLLECTOR
if (GetState()==ESTABLISHED) { if (GetState()==ESTABLISHED) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
// client seems to try a max of 30 times (initial+3 retries) then gives up, giving it a few more attempts just in case // client seems to try a max of 30 times (initial+3 retries) then gives up, giving it a few more attempts just in case
// streamactive means we identified the opcode for the stream, we cannot re-establish this connection // streamactive means we identified the opcode for the stream, we cannot re-establish this connection
@ -340,7 +340,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
SessionRequest *Request=(SessionRequest *)p->pBuffer; SessionRequest *Request=(SessionRequest *)p->pBuffer;
Session=ntohl(Request->Session); Session=ntohl(Request->Session);
SetMaxLen(ntohl(Request->MaxLength)); SetMaxLen(ntohl(Request->MaxLength));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
SetState(ESTABLISHED); SetState(ESTABLISHED);
#ifndef COLLECTOR #ifndef COLLECTOR
Key=0x11223344; Key=0x11223344;
@ -351,7 +351,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_SessionResponse: { case OP_SessionResponse: {
if(p->Size() < sizeof(SessionResponse)) if(p->Size() < sizeof(SessionResponse))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
break; break;
} }
@ -367,7 +367,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
compressed=(Response->Format&FLAG_COMPRESSED); compressed=(Response->Format&FLAG_COMPRESSED);
encoded=(Response->Format&FLAG_ENCODED); encoded=(Response->Format&FLAG_ENCODED);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
// Kinda kludgy, but trie for now // Kinda kludgy, but trie for now
if (StreamType==UnknownStream) { if (StreamType==UnknownStream) {
@ -390,17 +390,17 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
EQStreamState state = GetState(); EQStreamState state = GetState();
if(state == ESTABLISHED) { if(state == ESTABLISHED) {
//client initiated disconnect? //client initiated disconnect?
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
_SendDisconnect(); _SendDisconnect();
SetState(CLOSED); SetState(CLOSED);
} else if(state == CLOSING) { } else if(state == CLOSING) {
//we were waiting for this anyways, ignore pending messages, send the reply and be closed. //we were waiting for this anyways, ignore pending messages, send the reply and be closed.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
_SendDisconnect(); _SendDisconnect();
SetState(CLOSED); SetState(CLOSED);
} else { } else {
//we are expecting this (or have already gotten it, but dont care either way) //we are expecting this (or have already gotten it, but dont care either way)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
SetState(CLOSED); SetState(CLOSED);
} }
} }
@ -408,7 +408,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_OutOfOrderAck: { case OP_OutOfOrderAck: {
if(!p->pBuffer || (p->Size() < 4)) if(!p->pBuffer || (p->Size() < 4))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
break; break;
} }
#ifndef COLLECTOR #ifndef COLLECTOR
@ -416,15 +416,15 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
MOutboundQueue.lock(); MOutboundQueue.lock();
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid. //if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) { if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
seq, SequencedBase, SequencedBase+NextSequencedSend); seq, SequencedBase, SequencedBase+NextSequencedSend);
bool retransmit_acked_packets = false; bool retransmit_acked_packets = false;
@ -435,7 +435,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
if(!retransmit_acked_packets) { if(!retransmit_acked_packets) {
uint16 sqsize = SequencedQueue.size(); uint16 sqsize = SequencedQueue.size();
uint16 index = seq - SequencedBase; uint16 index = seq - SequencedBase;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
if (index < sqsize) { if (index < sqsize) {
std::deque<EQProtocolPacket *>::iterator sitr; std::deque<EQProtocolPacket *>::iterator sitr;
sitr = SequencedQueue.begin(); sitr = SequencedQueue.begin();
@ -450,15 +450,15 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
NextSequencedSend = 0; NextSequencedSend = 0;
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
} }
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
MOutboundQueue.unlock(); MOutboundQueue.unlock();
#endif #endif
@ -467,12 +467,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
case OP_SessionStatRequest: { case OP_SessionStatRequest: {
if(p->Size() < sizeof(SessionStats)) if(p->Size() < sizeof(SessionStats))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
break; break;
} }
#ifndef COLLECTOR #ifndef COLLECTOR
SessionStats *Stats=(SessionStats *)p->pBuffer; SessionStats *Stats=(SessionStats *)p->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
(unsigned long)ntohl(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta), (unsigned long)ntohl(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta),
(unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta), (unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta),
(unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta)); (unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta));
@ -493,18 +493,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
} }
if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX) if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
retransmittimeout = RETRANSMIT_TIMEOUT_MAX; retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
} }
} }
#endif #endif
} }
break; break;
case OP_SessionStatResponse: { case OP_SessionStatResponse: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
} }
break; break;
case OP_OutOfSession: { case OP_OutOfSession: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfSession. Ignoring." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
} }
break; break;
default: default:
@ -535,7 +535,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
return; return;
if(OpMgr == nullptr || *OpMgr == nullptr) { if(OpMgr == nullptr || *OpMgr == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
delete pack; delete pack;
return; return;
} }
@ -562,7 +562,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
// Convert the EQApplicationPacket to 1 or more EQProtocolPackets // Convert the EQApplicationPacket to 1 or more EQProtocolPackets
if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2) if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Making oversized packet, len %d" __L, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Making oversized packet, len %d" __L, p->size);
unsigned char *tmpbuff=new unsigned char[p->size+3]; unsigned char *tmpbuff=new unsigned char[p->size+3];
length=p->serialize(opcode, tmpbuff); length=p->serialize(opcode, tmpbuff);
@ -571,7 +571,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
*(uint32 *)(out->pBuffer+2)=htonl(p->Size()); *(uint32 *)(out->pBuffer+2)=htonl(p->Size());
used=MaxLen-10; used=MaxLen-10;
memcpy(out->pBuffer+6,tmpbuff,used); memcpy(out->pBuffer+6,tmpbuff,used);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
SequencedPush(out); SequencedPush(out);
@ -582,7 +582,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
out->size=chunksize+2; out->size=chunksize+2;
SequencedPush(out); SequencedPush(out);
used+=chunksize; used+=chunksize;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
} }
delete p; delete p;
delete[] tmpbuff; delete[] tmpbuff;
@ -606,22 +606,22 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
#else #else
MOutboundQueue.lock(); MOutboundQueue.lock();
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase);
*(uint16 *)(p->pBuffer)=htons(NextOutSeq); *(uint16 *)(p->pBuffer)=htons(NextOutSeq);
SequencedQueue.push_back(p); SequencedQueue.push_back(p);
NextOutSeq++; NextOutSeq++;
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
MOutboundQueue.unlock(); MOutboundQueue.unlock();
#endif #endif
@ -633,7 +633,7 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
delete p; delete p;
#else #else
MOutboundQueue.lock(); MOutboundQueue.lock();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
NonSequencedQueue.push(p); NonSequencedQueue.push(p);
MOutboundQueue.unlock(); MOutboundQueue.unlock();
#endif #endif
@ -642,14 +642,14 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
void EQStream::SendAck(uint16 seq) void EQStream::SendAck(uint16 seq)
{ {
uint16 Seq=htons(seq); uint16 Seq=htons(seq);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending ack with sequence %d" __L, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending ack with sequence %d" __L, seq);
SetLastAckSent(seq); SetLastAckSent(seq);
NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16))); NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
} }
void EQStream::SendOutOfOrderAck(uint16 seq) void EQStream::SendOutOfOrderAck(uint16 seq)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending out of order ack with sequence %d" __L, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
uint16 Seq=htons(seq); uint16 Seq=htons(seq);
NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16))); NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16)));
} }
@ -685,7 +685,7 @@ void EQStream::Write(int eq_fd)
// if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue // if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue
if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend && if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend &&
(GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) { (GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked " logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
"buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend); "buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend);
NextSequencedSend = 0; NextSequencedSend = 0;
retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet
@ -706,24 +706,24 @@ void EQStream::Write(int eq_fd)
// If we don't have a packet to try to combine into, use this one as the base // If we don't have a packet to try to combine into, use this one as the base
// And remove it form the queue // And remove it form the queue
p = NonSequencedQueue.front(); p = NonSequencedQueue.front();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
NonSequencedQueue.pop(); NonSequencedQueue.pop();
} else if (!p->combine(NonSequencedQueue.front())) { } else if (!p->combine(NonSequencedQueue.front())) {
// Tryint to combine this packet with the base didn't work (too big maybe) // Tryint to combine this packet with the base didn't work (too big maybe)
// So just send the base packet (we'll try this packet again later) // So just send the base packet (we'll try this packet again later)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
ReadyToSend.push(p); ReadyToSend.push(p);
BytesWritten+=p->size; BytesWritten+=p->size;
p=nullptr; p=nullptr;
if (BytesWritten > threshold) { if (BytesWritten > threshold) {
// Sent enough this round, lets stop to be fair // Sent enough this round, lets stop to be fair
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
break; break;
} }
} else { } else {
// Combine worked, so just remove this packet and it's spot in the queue // Combine worked, so just remove this packet and it's spot in the queue
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
delete NonSequencedQueue.front(); delete NonSequencedQueue.front();
NonSequencedQueue.pop(); NonSequencedQueue.pop();
} }
@ -734,48 +734,48 @@ void EQStream::Write(int eq_fd)
if (sitr!=SequencedQueue.end()) { if (sitr!=SequencedQueue.end()) {
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
uint16 seq_send = SequencedBase + NextSequencedSend; //just for logging... uint16 seq_send = SequencedBase + NextSequencedSend; //just for logging...
if(SequencedQueue.empty()) { if(SequencedQueue.empty()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
SeqEmpty=true; SeqEmpty=true;
continue; continue;
} }
if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) { if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) { if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
sitr++; sitr++;
NextSequencedSend++; NextSequencedSend++;
} else if (!p) { } else if (!p) {
// If we don't have a packet to try to combine into, use this one as the base // If we don't have a packet to try to combine into, use this one as the base
// Copy it first as it will still live until it is acked // Copy it first as it will still live until it is acked
p=(*sitr)->Copy(); p=(*sitr)->Copy();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
++sitr; ++sitr;
NextSequencedSend++; NextSequencedSend++;
} else if (!p->combine(*sitr)) { } else if (!p->combine(*sitr)) {
// Trying to combine this packet with the base didn't work (too big maybe) // Trying to combine this packet with the base didn't work (too big maybe)
// So just send the base packet (we'll try this packet again later) // So just send the base packet (we'll try this packet again later)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
ReadyToSend.push(p); ReadyToSend.push(p);
BytesWritten+=p->size; BytesWritten+=p->size;
p=nullptr; p=nullptr;
if (BytesWritten > threshold) { if (BytesWritten > threshold) {
// Sent enough this round, lets stop to be fair // Sent enough this round, lets stop to be fair
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
break; break;
} }
} else { } else {
// Combine worked // Combine worked
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
++sitr; ++sitr;
NextSequencedSend++; NextSequencedSend++;
} }
@ -784,35 +784,35 @@ void EQStream::Write(int eq_fd)
// If we don't have a packet to try to combine into, use this one as the base // If we don't have a packet to try to combine into, use this one as the base
// Copy it first as it will still live until it is acked // Copy it first as it will still live until it is acked
p=(*sitr)->Copy(); p=(*sitr)->Copy();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
++sitr; ++sitr;
NextSequencedSend++; NextSequencedSend++;
} else if (!p->combine(*sitr)) { } else if (!p->combine(*sitr)) {
// Trying to combine this packet with the base didn't work (too big maybe) // Trying to combine this packet with the base didn't work (too big maybe)
// So just send the base packet (we'll try this packet again later) // So just send the base packet (we'll try this packet again later)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
ReadyToSend.push(p); ReadyToSend.push(p);
BytesWritten+=p->size; BytesWritten+=p->size;
p=nullptr; p=nullptr;
if (BytesWritten > threshold) { if (BytesWritten > threshold) {
// Sent enough this round, lets stop to be fair // Sent enough this round, lets stop to be fair
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
break; break;
} }
} else { } else {
// Combine worked // Combine worked
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
++sitr; ++sitr;
NextSequencedSend++; NextSequencedSend++;
} }
} }
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
} else { } else {
// No more sequenced packets // No more sequenced packets
@ -824,7 +824,7 @@ void EQStream::Write(int eq_fd)
// We have a packet still, must have run out of both seq and non-seq, so send it // We have a packet still, must have run out of both seq and non-seq, so send it
if (p) { if (p) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Final combined packet not full, len %d" __L, p->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
ReadyToSend.push(p); ReadyToSend.push(p);
BytesWritten+=p->size; BytesWritten+=p->size;
} }
@ -841,7 +841,7 @@ void EQStream::Write(int eq_fd)
if(SeqEmpty && NonSeqEmpty) { if(SeqEmpty && NonSeqEmpty) {
//no more data to send //no more data to send
if(CheckState(CLOSING)) { if(CheckState(CLOSING)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "All outgoing data flushed, closing stream." __L ); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "All outgoing data flushed, closing stream." __L );
//we are waiting for the queues to empty, now we can do our disconnect. //we are waiting for the queues to empty, now we can do our disconnect.
//this packet will not actually go out until the next call to Write(). //this packet will not actually go out until the next call to Write().
_SendDisconnect(); _SendDisconnect();
@ -904,7 +904,7 @@ EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(Ses
out->size=sizeof(SessionResponse); out->size=sizeof(SessionResponse);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
(unsigned long)Session, MaxLen, Key, compressed?"yes":"no", encoded?"yes":"no"); (unsigned long)Session, MaxLen, Key, compressed?"yes":"no", encoded?"yes":"no");
NonSequencedPush(out); NonSequencedPush(out);
@ -918,7 +918,7 @@ EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(Sess
Request->Session=htonl(time(nullptr)); Request->Session=htonl(time(nullptr));
Request->MaxLength=htonl(512); Request->MaxLength=htonl(512);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
NonSequencedPush(out); NonSequencedPush(out);
} }
@ -932,7 +932,7 @@ void EQStream::_SendDisconnect()
*(uint32 *)out->pBuffer=htonl(Session); *(uint32 *)out->pBuffer=htonl(Session);
NonSequencedPush(out); NonSequencedPush(out);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
} }
void EQStream::InboundQueuePush(EQRawApplicationPacket *p) void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@ -959,7 +959,7 @@ EQRawApplicationPacket *p=nullptr;
if(OpMgr != nullptr && *OpMgr != nullptr) { if(OpMgr != nullptr && *OpMgr != nullptr) {
EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode); EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
if (emu_op == OP_Unknown) { if (emu_op == OP_Unknown) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
} }
p->SetOpcode(emu_op); p->SetOpcode(emu_op);
@ -986,7 +986,7 @@ EQRawApplicationPacket *p=nullptr;
if(OpMgr != nullptr && *OpMgr != nullptr) { if(OpMgr != nullptr && *OpMgr != nullptr) {
EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode); EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
if(emu_op == OP_Unknown) { if(emu_op == OP_Unknown) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
} }
p->SetOpcode(emu_op); p->SetOpcode(emu_op);
@ -1014,7 +1014,7 @@ void EQStream::InboundQueueClear()
{ {
EQApplicationPacket *p=nullptr; EQApplicationPacket *p=nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing inbound queue" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing inbound queue" __L);
MInboundQueue.lock(); MInboundQueue.lock();
if (!InboundQueue.empty()) { if (!InboundQueue.empty()) {
@ -1057,7 +1057,7 @@ void EQStream::OutboundQueueClear()
{ {
EQProtocolPacket *p=nullptr; EQProtocolPacket *p=nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing outbound queue" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing outbound queue" __L);
MOutboundQueue.lock(); MOutboundQueue.lock();
while(!NonSequencedQueue.empty()) { while(!NonSequencedQueue.empty()) {
@ -1079,7 +1079,7 @@ void EQStream::PacketQueueClear()
{ {
EQProtocolPacket *p=nullptr; EQProtocolPacket *p=nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing future packet queue" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Clearing future packet queue" __L);
if(!PacketQueue.empty()) { if(!PacketQueue.empty()) {
std::map<unsigned short,EQProtocolPacket *>::iterator itr; std::map<unsigned short,EQProtocolPacket *>::iterator itr;
@ -1111,7 +1111,7 @@ uint32 newlength=0;
delete p; delete p;
ProcessQueue(); ProcessQueue();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Incoming packet failed checksum" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Incoming packet failed checksum" __L);
_hex(NET__NET_CREATE_HEX, buffer, length); _hex(NET__NET_CREATE_HEX, buffer, length);
} }
} }
@ -1141,33 +1141,33 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
MOutboundQueue.lock(); MOutboundQueue.lock();
//do a bit of sanity checking. //do a bit of sanity checking.
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Ack Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Ack Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Pre-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
SeqOrder ord = CompareSequence(SequencedBase, seq); SeqOrder ord = CompareSequence(SequencedBase, seq);
if(ord == SeqInOrder) { if(ord == SeqInOrder) {
//they are not acking anything new... //they are not acking anything new...
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
} else if(ord == SeqPast) { } else if(ord == SeqPast) {
//they are nacking blocks going back before our buffer, wtf? //they are nacking blocks going back before our buffer, wtf?
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);
//this is a good ack, we get to ack some blocks. //this is a good ack, we get to ack some blocks.
seq++; //we stop at the block right after their ack, counting on the wrap of both numbers. seq++; //we stop at the block right after their ack, counting on the wrap of both numbers.
while(SequencedBase != seq) { while(SequencedBase != seq) {
if(SequencedQueue.empty()) { if(SequencedQueue.empty()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
SequencedBase = NextOutSeq; SequencedBase = NextOutSeq;
NextSequencedSend = 0; NextSequencedSend = 0;
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
//clean out the acked packet //clean out the acked packet
delete SequencedQueue.front(); delete SequencedQueue.front();
SequencedQueue.pop_front(); SequencedQueue.pop_front();
@ -1178,10 +1178,10 @@ logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OUT OF PACKET
SequencedBase++; SequencedBase++;
} }
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) { if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
} }
if(NextSequencedSend > SequencedQueue.size()) { if(NextSequencedSend > SequencedQueue.size()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
} }
} }
@ -1191,7 +1191,7 @@ if(NextSequencedSend > SequencedQueue.size()) {
void EQStream::SetNextAckToSend(uint32 seq) void EQStream::SetNextAckToSend(uint32 seq)
{ {
MAcks.lock(); MAcks.lock();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
NextAckToSend=seq; NextAckToSend=seq;
MAcks.unlock(); MAcks.unlock();
} }
@ -1199,7 +1199,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
void EQStream::SetLastAckSent(uint32 seq) void EQStream::SetLastAckSent(uint32 seq)
{ {
MAcks.lock(); MAcks.lock();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
LastAckSent=seq; LastAckSent=seq;
MAcks.unlock(); MAcks.unlock();
} }
@ -1212,10 +1212,10 @@ void EQStream::ProcessQueue()
EQProtocolPacket *qp=nullptr; EQProtocolPacket *qp=nullptr;
while((qp=RemoveQueue(NextInSeq))!=nullptr) { while((qp=RemoveQueue(NextInSeq))!=nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
ProcessPacket(qp); ProcessPacket(qp);
delete qp; delete qp;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
} }
} }
@ -1226,21 +1226,21 @@ EQProtocolPacket *qp=nullptr;
if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) { if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
qp=itr->second; qp=itr->second;
PacketQueue.erase(itr); PacketQueue.erase(itr);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
} }
return qp; return qp;
} }
void EQStream::SetStreamType(EQStreamType type) void EQStream::SetStreamType(EQStreamType type)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
StreamType=type; StreamType=type;
switch (StreamType) { switch (StreamType) {
case LoginStream: case LoginStream:
app_opcode_size=1; app_opcode_size=1;
compressed=false; compressed=false;
encoded=false; encoded=false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
break; break;
case ChatOrMailStream: case ChatOrMailStream:
case ChatStream: case ChatStream:
@ -1248,7 +1248,7 @@ void EQStream::SetStreamType(EQStreamType type)
app_opcode_size=1; app_opcode_size=1;
compressed=false; compressed=false;
encoded=true; encoded=true;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
break; break;
case ZoneStream: case ZoneStream:
case WorldStream: case WorldStream:
@ -1256,7 +1256,7 @@ void EQStream::SetStreamType(EQStreamType type)
app_opcode_size=2; app_opcode_size=2;
compressed=true; compressed=true;
encoded=false; encoded=false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
break; break;
} }
} }
@ -1306,7 +1306,7 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)
void EQStream::SetState(EQStreamState state) { void EQStream::SetState(EQStreamState state) {
MState.lock(); MState.lock();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Changing state from %d to %d" __L, State, state); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Changing state from %d to %d" __L, State, state);
State=state; State=state;
MState.unlock(); MState.unlock();
} }
@ -1318,29 +1318,29 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
EQStreamState orig_state = GetState(); EQStreamState orig_state = GetState();
if (orig_state == CLOSING && !outgoing_data) { if (orig_state == CLOSING && !outgoing_data) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Out of data in closing state, disconnecting." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Out of data in closing state, disconnecting." __L);
_SendDisconnect(); _SendDisconnect();
SetState(DISCONNECTING); SetState(DISCONNECTING);
} else if (LastPacket && (now-LastPacket) > timeout) { } else if (LastPacket && (now-LastPacket) > timeout) {
switch(orig_state) { switch(orig_state) {
case CLOSING: case CLOSING:
//if we time out in the closing state, they are not acking us, just give up //if we time out in the closing state, they are not acking us, just give up
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L);
_SendDisconnect(); _SendDisconnect();
SetState(CLOSED); SetState(CLOSED);
break; break;
case DISCONNECTING: case DISCONNECTING:
//we timed out waiting for them to send us the disconnect reply, just give up. //we timed out waiting for them to send us the disconnect reply, just give up.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
SetState(CLOSED); SetState(CLOSED);
break; break;
case CLOSED: case CLOSED:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in closed state??" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in closed state??" __L);
break; break;
case ESTABLISHED: case ESTABLISHED:
//we timed out during normal operation. Try to be nice about it. //we timed out during normal operation. Try to be nice about it.
//we will almost certainly time out again waiting for the disconnect reply, but oh well. //we will almost certainly time out again waiting for the disconnect reply, but oh well.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in established state. Closing connection." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Timeout expired in established state. Closing connection." __L);
_SendDisconnect(); _SendDisconnect();
SetState(DISCONNECTING); SetState(DISCONNECTING);
break; break;
@ -1369,11 +1369,11 @@ void EQStream::AdjustRates(uint32 average_delta)
MRate.lock(); MRate.lock();
RateThreshold=RATEBASE/average_delta; RateThreshold=RATEBASE/average_delta;
DecayRate=DECAYBASE/average_delta; DecayRate=DECAYBASE/average_delta;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L,
RateThreshold, DecayRate, average_delta); RateThreshold, DecayRate, average_delta);
MRate.unlock(); MRate.unlock();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L,
average_delta, AVERAGE_DELTA_MAX); average_delta, AVERAGE_DELTA_MAX);
} }
} else { } else {
@ -1381,7 +1381,7 @@ void EQStream::AdjustRates(uint32 average_delta)
MRate.lock(); MRate.lock();
RateThreshold=RATEBASE/average_delta; RateThreshold=RATEBASE/average_delta;
DecayRate=DECAYBASE/average_delta; DecayRate=DECAYBASE/average_delta;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L,
RateThreshold, DecayRate, average_delta); RateThreshold, DecayRate, average_delta);
MRate.unlock(); MRate.unlock();
} }
@ -1391,12 +1391,12 @@ void EQStream::AdjustRates(uint32 average_delta)
void EQStream::Close() { void EQStream::Close() {
if(HasOutgoingData()) { if(HasOutgoingData()) {
//there is pending data, wait for it to go out. //there is pending data, wait for it to go out.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
SetState(CLOSING); SetState(CLOSING);
} else { } else {
//otherwise, we are done, we can drop immediately. //otherwise, we are done, we can drop immediately.
_SendDisconnect(); _SendDisconnect();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Stream closing immediate due to Close()" __L); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Netcode, _L "Stream closing immediate due to Close()" __L);
SetState(DISCONNECTING); SetState(DISCONNECTING);
} }
} }
@ -1424,19 +1424,19 @@ EQStream::MatchState EQStream::CheckSignature(const Signature *sig) {
} else if(p->opcode == sig->first_eq_opcode) { } else if(p->opcode == sig->first_eq_opcode) {
//opcode matches, check length.. //opcode matches, check length..
if(p->size == sig->first_length) { if(p->size == sig->first_length) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
res = MatchSuccessful; res = MatchSuccessful;
} else if(sig->first_length == 0) { } else if(sig->first_length == 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
res = MatchSuccessful; res = MatchSuccessful;
} else { } else {
//opcode matched but length did not. //opcode matched but length did not.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
res = MatchFailed; res = MatchFailed;
} }
} else { } else {
//first opcode did not match.. //first opcode did not match..
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
res = MatchFailed; res = MatchFailed;
} }
} }

20
common/eq_stream_ident.cpp
View File

@ -46,7 +46,7 @@ void EQStreamIdentifier::Process() {
//first see if this stream has expired //first see if this stream has expired
if(r->expire.Check(false)) { if(r->expire.Check(false)) {
//this stream has failed to match any pattern in our timeframe. //this stream has failed to match any pattern in our timeframe.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
r->stream->ReleaseFromUse(); r->stream->ReleaseFromUse();
delete r; delete r;
cur = m_streams.erase(cur); cur = m_streams.erase(cur);
@ -62,23 +62,23 @@ void EQStreamIdentifier::Process() {
} }
if(r->stream->GetState() != ESTABLISHED) { if(r->stream->GetState() != ESTABLISHED) {
//the stream closed before it was identified. //the stream closed before it was identified.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
switch(r->stream->GetState()) switch(r->stream->GetState())
{ {
case ESTABLISHED: case ESTABLISHED:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Established"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Established");
break; break;
case CLOSING: case CLOSING:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Closing"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Closing");
break; break;
case DISCONNECTING: case DISCONNECTING:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Disconnecting"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Disconnecting");
break; break;
case CLOSED: case CLOSED:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Closed"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Closed");
break; break;
default: default:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
break; break;
} }
r->stream->ReleaseFromUse(); r->stream->ReleaseFromUse();
@ -109,7 +109,7 @@ void EQStreamIdentifier::Process() {
case EQStream::MatchSuccessful: { case EQStream::MatchSuccessful: {
//yay, a match. //yay, a match.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
// before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further // before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further
r->stream->SetActive(true); r->stream->SetActive(true);
@ -123,7 +123,7 @@ void EQStreamIdentifier::Process() {
} }
case EQStream::MatchFailed: case EQStream::MatchFailed:
//do nothing... //do nothing...
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
break; break;
} }
} }
@ -131,7 +131,7 @@ void EQStreamIdentifier::Process() {
//if we checked all patches and did not find a match. //if we checked all patches and did not find a match.
if(all_ready && !found_one) { if(all_ready && !found_one) {
//the stream cannot be identified. //the stream cannot be identified.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
r->stream->ReleaseFromUse(); r->stream->ReleaseFromUse();
} }

2
common/eqemu_logsys.cpp
View File

@ -176,7 +176,7 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 log_type, uint16 log_category, co
#endif #endif
} }
void EQEmuLogSys::LogDebugType(DebugLevel debug_level, uint16 log_category, std::string message, ...) void EQEmuLogSys::DebugCategory(DebugLevel debug_level, uint16 log_category, std::string message, ...)
{ {
va_list args; va_list args;
va_start(args, message); va_start(args, message);

2
common/eqemu_logsys.h
View File

@ -81,7 +81,7 @@ public:
void LoadLogSettingsDefaults(); void LoadLogSettingsDefaults();
void Log(uint16 log_type, const std::string message, ...); void Log(uint16 log_type, const std::string message, ...);
void LogDebug(DebugLevel debug_level, std::string message, ...); void LogDebug(DebugLevel debug_level, std::string message, ...);
void LogDebugType(DebugLevel debug_level, uint16 log_category, std::string message, ...); void DebugCategory(DebugLevel debug_level, uint16 log_category, std::string message, ...);
void MakeDirectory(std::string directory_name); void MakeDirectory(std::string directory_name);
void SetCurrentTimeStamp(char* time_stamp); void SetCurrentTimeStamp(char* time_stamp);
void StartFileLogs(const std::string log_name); void StartFileLogs(const std::string log_name);

130
common/guild_base.cpp
View File

@ -46,7 +46,7 @@ bool BaseGuildManager::LoadGuilds() {
ClearGuilds(); ClearGuilds();
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to load guilds when we have no database object."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to load guilds when we have no database object.");
return(false); return(false);
} }
@ -57,7 +57,7 @@ bool BaseGuildManager::LoadGuilds() {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guilds '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guilds '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -69,7 +69,7 @@ bool BaseGuildManager::LoadGuilds() {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild ranks '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild ranks '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -79,13 +79,13 @@ bool BaseGuildManager::LoadGuilds() {
uint8 rankn = atoi(row[1]); uint8 rankn = atoi(row[1]);
if(rankn > GUILD_MAX_RANK) { if(rankn > GUILD_MAX_RANK) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
continue; continue;
} }
res = m_guilds.find(guild_id); res = m_guilds.find(guild_id);
if(res == m_guilds.end()) { if(res == m_guilds.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found rank %d for non-existent guild %d, skipping.", rankn, guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found rank %d for non-existent guild %d, skipping.", rankn, guild_id);
continue; continue;
} }
@ -107,7 +107,7 @@ bool BaseGuildManager::LoadGuilds() {
bool BaseGuildManager::RefreshGuild(uint32 guild_id) { bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id);
return(false); return(false);
} }
@ -120,13 +120,13 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error reloading guilds '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error reloading guilds '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
if (results.RowCount() == 0) if (results.RowCount() == 0)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to find guild %d in the database.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to find guild %d in the database.", guild_id);
return false; return false;
} }
@ -140,7 +140,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error reloading guild ranks '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error reloading guild ranks '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -149,7 +149,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
uint8 rankn = atoi(row[1]); uint8 rankn = atoi(row[1]);
if(rankn > GUILD_MAX_RANK) { if(rankn > GUILD_MAX_RANK) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
continue; continue;
} }
@ -166,7 +166,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
rank.permissions[GUILD_WARPEACE] = (row[10][0] == '1') ? true: false; rank.permissions[GUILD_WARPEACE] = (row[10][0] == '1') ? true: false;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Successfully refreshed guild %d from the database.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Successfully refreshed guild %d from the database.", guild_id);
return true; return true;
} }
@ -218,14 +218,14 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) { bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to store guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to store guild %d when we have no database object.", guild_id);
return(false); return(false);
} }
std::map<uint32, GuildInfo *>::const_iterator res; std::map<uint32, GuildInfo *>::const_iterator res;
res = m_guilds.find(guild_id); res = m_guilds.find(guild_id);
if(res == m_guilds.end()) { if(res == m_guilds.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to store non-existent guild %d", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to store non-existent guild %d", guild_id);
return(false); return(false);
} }
GuildInfo *info = res->second; GuildInfo *info = res->second;
@ -236,14 +236,14 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error clearing old guild record when storing %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error clearing old guild record when storing %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str());
//clear out old `guild_ranks` entries //clear out old `guild_ranks` entries
query = StringFormat("DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id); query = StringFormat("DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id);
results = m_db->QueryDatabase(query); results = m_db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error clearing old guild_ranks records when storing %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error clearing old guild_ranks records when storing %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str());
//escape our strings. //escape our strings.
char *name_esc = new char[info->name.length()*2+1]; char *name_esc = new char[info->name.length()*2+1];
@ -260,7 +260,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error inserting new guild record when storing %d. Giving up. '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error inserting new guild record when storing %d. Giving up. '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str());
safe_delete_array(name_esc); safe_delete_array(name_esc);
safe_delete_array(motd_esc); safe_delete_array(motd_esc);
safe_delete_array(motd_set_esc); safe_delete_array(motd_set_esc);
@ -294,21 +294,21 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error inserting new guild rank record when storing %d for %d. Giving up. '%s': %s", rank, guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error inserting new guild rank record when storing %d for %d. Giving up. '%s': %s", rank, guild_id, query.c_str(), results.ErrorMessage().c_str());
safe_delete_array(title_esc); safe_delete_array(title_esc);
return false; return false;
} }
safe_delete_array(title_esc); safe_delete_array(title_esc);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Stored guild %d in the database", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Stored guild %d in the database", guild_id);
return true; return true;
} }
uint32 BaseGuildManager::_GetFreeGuildID() { uint32 BaseGuildManager::_GetFreeGuildID() {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested find a free guild ID when we have no database object."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested find a free guild ID when we have no database object.");
return(GUILD_NONE); return(GUILD_NONE);
} }
@ -343,12 +343,12 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
if (results.RowCount() == 0) if (results.RowCount() == 0)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Located free guild ID %d in the database", index); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Located free guild ID %d in the database", index);
return index; return index;
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to find a free guild ID when requested."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to find a free guild ID when requested.");
return GUILD_NONE; return GUILD_NONE;
} }
@ -518,11 +518,11 @@ uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
//now store the resulting guild setup into the DB. //now store the resulting guild setup into the DB.
if(!_StoreGuildDB(new_id)) { if(!_StoreGuildDB(new_id)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error storing new guild. It may have been partially created which may need manual removal."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error storing new guild. It may have been partially created which may need manual removal.");
return(GUILD_NONE); return(GUILD_NONE);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Created guild %d in the database.", new_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Created guild %d in the database.", new_id);
return(new_id); return(new_id);
} }
@ -538,7 +538,7 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
} }
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to delete guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to delete guild %d when we have no database object.", guild_id);
return(false); return(false);
} }
@ -558,14 +558,14 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
query = StringFormat("DELETE FROM guild_bank WHERE guildid=%lu", (unsigned long)guild_id); query = StringFormat("DELETE FROM guild_bank WHERE guildid=%lu", (unsigned long)guild_id);
QueryWithLogging(query, "deleting guild bank"); QueryWithLogging(query, "deleting guild bank");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Deleted guild %d from the database.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Deleted guild %d from the database.", guild_id);
return(true); return(true);
} }
bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) { bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to rename guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to rename guild %d when we have no database object.", guild_id);
return false; return false;
} }
@ -586,13 +586,13 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error renaming guild %d '%s': %s", guild_id, query.c_str(), results.Success()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error renaming guild %d '%s': %s", guild_id, query.c_str(), results.Success());
safe_delete_array(esc); safe_delete_array(esc);
return false; return false;
} }
safe_delete_array(esc); safe_delete_array(esc);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Renamed guild %s (%d) to %s in database.", info->name.c_str(), guild_id, name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Renamed guild %s (%d) to %s in database.", info->name.c_str(), guild_id, name);
info->name = name; //update our local record. info->name = name; //update our local record.
@ -601,7 +601,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) { bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id);
return false; return false;
} }
@ -617,7 +617,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error changing leader on guild %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error changing leader on guild %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -628,7 +628,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
if(!DBSetGuildRank(leader, GUILD_LEADER)) if(!DBSetGuildRank(leader, GUILD_LEADER))
return false; return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set guild leader for guild %d to %d in the database", guild_id, leader); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set guild leader for guild %d to %d in the database", guild_id, leader);
info->leader_char_id = leader; //update our local record. info->leader_char_id = leader; //update our local record.
@ -637,7 +637,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) { bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id);
return(false); return(false);
} }
@ -661,7 +661,7 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting MOTD for guild %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting MOTD for guild %d '%s': %s", guild_id, query.c_str(), results.ErrorMessage().c_str());
safe_delete_array(esc); safe_delete_array(esc);
safe_delete_array(esc_set); safe_delete_array(esc_set);
return false; return false;
@ -669,7 +669,7 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
safe_delete_array(esc); safe_delete_array(esc);
safe_delete_array(esc_set); safe_delete_array(esc_set);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set MOTD for guild %d in the database", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set MOTD for guild %d in the database", guild_id);
info->motd = motd; //update our local record. info->motd = motd; //update our local record.
info->motd_setter = setter; //update our local record. info->motd_setter = setter; //update our local record.
@ -698,13 +698,13 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting URL for guild %d '%s': %s", GuildID, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting URL for guild %d '%s': %s", GuildID, query.c_str(), results.ErrorMessage().c_str());
safe_delete_array(esc); safe_delete_array(esc);
return(false); return(false);
} }
safe_delete_array(esc); safe_delete_array(esc);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set URL for guild %d in the database", GuildID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set URL for guild %d in the database", GuildID);
info->url = URL; //update our local record. info->url = URL; //update our local record.
@ -733,13 +733,13 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting Channel for guild %d '%s': %s", GuildID, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting Channel for guild %d '%s': %s", GuildID, query.c_str(), results.ErrorMessage().c_str());
safe_delete_array(esc); safe_delete_array(esc);
return(false); return(false);
} }
safe_delete_array(esc); safe_delete_array(esc);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set Channel for guild %d in the database", GuildID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set Channel for guild %d in the database", GuildID);
info->channel = Channel; //update our local record. info->channel = Channel; //update our local record.
@ -748,7 +748,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) { bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id);
return(false); return(false);
} }
@ -759,7 +759,7 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error Changing char %d to guild %d '%s': %s", charid, guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error Changing char %d to guild %d '%s': %s", charid, guild_id, query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -768,11 +768,11 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error removing char %d from guild '%s': %s", charid, guild_id, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error removing char %d from guild '%s': %s", charid, guild_id, query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set char %d to guild %d and rank %d in the database.", charid, guild_id, rank); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set char %d to guild %d and rank %d in the database.", charid, guild_id, rank);
return true; return true;
} }
@ -796,7 +796,7 @@ bool BaseGuildManager::GetBankerFlag(uint32 CharID)
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if(!results.Success()) if(!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error retrieving banker flag '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error retrieving banker flag '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -827,7 +827,7 @@ bool BaseGuildManager::GetAltFlag(uint32 CharID)
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if(!results.Success()) if(!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error retrieving alt flag '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error retrieving alt flag '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -863,11 +863,11 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting public note for char %d '%s': %s", charid, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error setting public note for char %d '%s': %s", charid, query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set public not for char %d", charid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Set public not for char %d", charid);
return true; return true;
} }
@ -880,7 +880,7 @@ bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error %s: '%s': %s", errmsg, query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error %s: '%s': %s", errmsg, query.c_str(), results.ErrorMessage().c_str());
return(false); return(false);
} }
@ -938,7 +938,7 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id); std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id);
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member list '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member list '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -948,14 +948,14 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
members.push_back(ci); members.push_back(ci);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived entire guild member list for guild %d from the database", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived entire guild member list for guild %d from the database", guild_id);
return true; return true;
} }
bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) { bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested char info on %s when we have no database object.", char_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested char info on %s when we have no database object.", char_name);
return(false); return(false);
} }
@ -969,7 +969,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
safe_delete_array(esc); safe_delete_array(esc);
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -978,7 +978,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
auto row = results.begin(); auto row = results.begin();
ProcessGuildMember(row, into); ProcessGuildMember(row, into);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived guild member info for char %s from the database", char_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived guild member info for char %s from the database", char_name);
return true; return true;
@ -987,7 +987,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) { bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
if(m_db == nullptr) { if(m_db == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested char info on %d when we have no database object.", char_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Requested char info on %d when we have no database object.", char_id);
return false; return false;
} }
@ -1000,7 +1000,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
#endif #endif
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error loading guild member '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -1009,7 +1009,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
auto row = results.begin(); auto row = results.begin();
ProcessGuildMember(row, into); ProcessGuildMember(row, into);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived guild member info for char %d", char_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Retreived guild member info for char %d", char_id);
return true; return true;
@ -1124,16 +1124,16 @@ bool BaseGuildManager::GuildExists(uint32 guild_id) const {
bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const { bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
if(guild_id == GUILD_NONE) { if(guild_id == GUILD_NONE) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for char %d: not a guild.", char_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for char %d: not a guild.", char_id);
return(false); return(false);
} }
std::map<uint32, GuildInfo *>::const_iterator res; std::map<uint32, GuildInfo *>::const_iterator res;
res = m_guilds.find(guild_id); res = m_guilds.find(guild_id);
if(res == m_guilds.end()) { if(res == m_guilds.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for char %d: invalid guild.", char_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for char %d: invalid guild.", char_id);
return(false); //invalid guild return(false); //invalid guild
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for guild %d, char %d: leader id=%d", guild_id, char_id, res->second->leader_char_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check leader for guild %d, char %d: leader id=%d", guild_id, char_id, res->second->leader_char_id);
return(char_id == res->second->leader_char_id); return(char_id == res->second->leader_char_id);
} }
@ -1163,20 +1163,20 @@ uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 cha
bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const { bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
if(status >= 250) { if(status >= 250) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status);
return(true); //250+ as allowed anything return(true); //250+ as allowed anything
} }
std::map<uint32, GuildInfo *>::const_iterator res; std::map<uint32, GuildInfo *>::const_iterator res;
res = m_guilds.find(guild_id); res = m_guilds.find(guild_id);
if(res == m_guilds.end()) { if(res == m_guilds.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d with user status %d, no such guild, denied.", guild_id, status); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d with user status %d, no such guild, denied.", guild_id, status);
return(false); //invalid guild return(false); //invalid guild
} }
bool granted = (res->second->minstatus <= status); bool granted = (res->second->minstatus <= status);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %s (%d) with user status %d. Min status %d: %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %s (%d) with user status %d. Min status %d: %s",
res->second->name.c_str(), guild_id, status, res->second->minstatus, granted?"granted":"denied"); res->second->name.c_str(), guild_id, status, res->second->minstatus, granted?"granted":"denied");
return(granted); return(granted);
@ -1184,21 +1184,21 @@ bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const { bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const {
if(rank > GUILD_MAX_RANK) { if(rank > GUILD_MAX_RANK) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.",
guild_id, rank, GuildActionNames[act], act); guild_id, rank, GuildActionNames[act], act);
return(false); //invalid rank return(false); //invalid rank
} }
std::map<uint32, GuildInfo *>::const_iterator res; std::map<uint32, GuildInfo *>::const_iterator res;
res = m_guilds.find(guild_id); res = m_guilds.find(guild_id);
if(res == m_guilds.end()) { if(res == m_guilds.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid guild, denied.", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid guild, denied.",
guild_id, rank, GuildActionNames[act], act); guild_id, rank, GuildActionNames[act], act);
return(false); //invalid guild return(false); //invalid guild
} }
bool granted = res->second->ranks[rank].permissions[act]; bool granted = res->second->ranks[rank].permissions[act];
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %s (%d) and rank %s (%d) for action %s (%d): %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Check permission on guild %s (%d) and rank %s (%d) for action %s (%d): %s",
res->second->name.c_str(), guild_id, res->second->name.c_str(), guild_id,
res->second->ranks[rank].name.c_str(), rank, res->second->ranks[rank].name.c_str(), rank,
GuildActionNames[act], act, GuildActionNames[act], act,
@ -1245,7 +1245,7 @@ uint32 BaseGuildManager::DoesAccountContainAGuildLeader(uint32 AccountID)
auto results = m_db->QueryDatabase(query); auto results = m_db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error executing query '%s': %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Error executing query '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return 0; return 0;
} }

34
common/patches/rof.cpp
View File

@ -52,7 +52,7 @@ namespace RoF
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -78,7 +78,7 @@ namespace RoF
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -93,10 +93,10 @@ namespace RoF
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -316,7 +316,7 @@ namespace RoF
if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
} }
@ -551,7 +551,7 @@ namespace RoF
if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
@ -585,7 +585,7 @@ namespace RoF
safe_delete_array(Serialized); safe_delete_array(Serialized);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -1386,7 +1386,7 @@ namespace RoF
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -2556,7 +2556,7 @@ namespace RoF
outapp->WriteUInt8(0); // Unknown outapp->WriteUInt8(0); // Unknown
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition());
unsigned char *NewBuffer = new unsigned char[outapp->GetWritePosition()]; unsigned char *NewBuffer = new unsigned char[outapp->GetWritePosition()];
memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition()); memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition());
@ -3321,7 +3321,7 @@ namespace RoF
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -3654,7 +3654,7 @@ namespace RoF
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -3902,7 +3902,7 @@ namespace RoF
Buffer += 29; Buffer += 29;
if (Buffer != (BufferStart + PacketSize)) if (Buffer != (BufferStart + PacketSize))
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize));
} }
//logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size); //logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size);
//_hex(NET__ERROR, outapp->pBuffer, outapp->size); //_hex(NET__ERROR, outapp->pBuffer, outapp->size);
@ -4498,7 +4498,7 @@ namespace RoF
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
//logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot.MainSlot, eq->to_slot.MainSlot); //logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot.MainSlot, eq->to_slot.MainSlot);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] MoveItem SlotType from %i to %i, MainSlot from %i to %i, SubSlot from %i to %i, AugSlot from %i to %i, Unknown01 from %i to %i, Number %u", eq->from_slot.SlotType, eq->to_slot.SlotType, eq->from_slot.MainSlot, eq->to_slot.MainSlot, eq->from_slot.SubSlot, eq->to_slot.SubSlot, eq->from_slot.AugSlot, eq->to_slot.AugSlot, eq->from_slot.Unknown01, eq->to_slot.Unknown01, eq->number_in_stack); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] MoveItem SlotType from %i to %i, MainSlot from %i to %i, SubSlot from %i to %i, AugSlot from %i to %i, Unknown01 from %i to %i, Number %u", eq->from_slot.SlotType, eq->to_slot.SlotType, eq->from_slot.MainSlot, eq->to_slot.MainSlot, eq->from_slot.SubSlot, eq->to_slot.SubSlot, eq->from_slot.AugSlot, eq->to_slot.AugSlot, eq->from_slot.Unknown01, eq->to_slot.Unknown01, eq->number_in_stack);
emu->from_slot = RoFToServerSlot(eq->from_slot); emu->from_slot = RoFToServerSlot(eq->from_slot);
emu->to_slot = RoFToServerSlot(eq->to_slot); emu->to_slot = RoFToServerSlot(eq->to_slot);
IN(number_in_stack); IN(number_in_stack);
@ -5455,7 +5455,7 @@ namespace RoF
RoFSlot.MainSlot = TempSlot; RoFSlot.MainSlot = TempSlot;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoFSlot.SlotType, RoFSlot.Unknown02, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoFSlot.SlotType, RoFSlot.Unknown02, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01);
return RoFSlot; return RoFSlot;
} }
@ -5496,7 +5496,7 @@ namespace RoF
RoFSlot.SubSlot = TempSlot - ((RoFSlot.MainSlot + 2) * EmuConstants::ITEM_CONTAINER_SIZE); RoFSlot.SubSlot = TempSlot - ((RoFSlot.MainSlot + 2) * EmuConstants::ITEM_CONTAINER_SIZE);
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01);
return RoFSlot; return RoFSlot;
} }
@ -5601,7 +5601,7 @@ namespace RoF
ServerSlot = INVALID_INDEX; ServerSlot = INVALID_INDEX;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoFSlot.SlotType, RoFSlot.Unknown02, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01, ServerSlot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoFSlot.SlotType, RoFSlot.Unknown02, RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01, ServerSlot);
return ServerSlot; return ServerSlot;
} }
@ -5636,7 +5636,7 @@ namespace RoF
ServerSlot = TempSlot; ServerSlot = TempSlot;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01, ServerSlot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoFSlot.MainSlot, RoFSlot.SubSlot, RoFSlot.AugSlot, RoFSlot.Unknown01, ServerSlot);
return ServerSlot; return ServerSlot;
} }

34
common/patches/rof2.cpp
View File

@ -52,7 +52,7 @@ namespace RoF2
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -78,7 +78,7 @@ namespace RoF2
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -93,10 +93,10 @@ namespace RoF2
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -382,7 +382,7 @@ namespace RoF2
if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
} }
@ -617,7 +617,7 @@ namespace RoF2
if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
@ -651,7 +651,7 @@ namespace RoF2
safe_delete_array(Serialized); safe_delete_array(Serialized);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -1452,7 +1452,7 @@ namespace RoF2
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0, old_item_pkt->PacketType); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0, old_item_pkt->PacketType);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -2640,7 +2640,7 @@ namespace RoF2
// Think we need 1 byte of padding at the end // Think we need 1 byte of padding at the end
outapp->WriteUInt8(0); // Unknown outapp->WriteUInt8(0); // Unknown
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition());
unsigned char *NewBuffer = new unsigned char[outapp->GetWritePosition()]; unsigned char *NewBuffer = new unsigned char[outapp->GetWritePosition()];
memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition()); memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition());
@ -3387,7 +3387,7 @@ namespace RoF2
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -3721,7 +3721,7 @@ namespace RoF2
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -3973,7 +3973,7 @@ namespace RoF2
Buffer += 29; Buffer += 29;
if (Buffer != (BufferStart + PacketSize)) if (Buffer != (BufferStart + PacketSize))
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize));
} }
//logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size); //logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size);
//_hex(NET__ERROR, outapp->pBuffer, outapp->size); //_hex(NET__ERROR, outapp->pBuffer, outapp->size);
@ -4569,7 +4569,7 @@ namespace RoF2
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
//logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot.MainSlot, eq->to_slot.MainSlot); //logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot.MainSlot, eq->to_slot.MainSlot);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] MoveItem SlotType from %i to %i, MainSlot from %i to %i, SubSlot from %i to %i, AugSlot from %i to %i, Unknown01 from %i to %i, Number %u", eq->from_slot.SlotType, eq->to_slot.SlotType, eq->from_slot.MainSlot, eq->to_slot.MainSlot, eq->from_slot.SubSlot, eq->to_slot.SubSlot, eq->from_slot.AugSlot, eq->to_slot.AugSlot, eq->from_slot.Unknown01, eq->to_slot.Unknown01, eq->number_in_stack); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] MoveItem SlotType from %i to %i, MainSlot from %i to %i, SubSlot from %i to %i, AugSlot from %i to %i, Unknown01 from %i to %i, Number %u", eq->from_slot.SlotType, eq->to_slot.SlotType, eq->from_slot.MainSlot, eq->to_slot.MainSlot, eq->from_slot.SubSlot, eq->to_slot.SubSlot, eq->from_slot.AugSlot, eq->to_slot.AugSlot, eq->from_slot.Unknown01, eq->to_slot.Unknown01, eq->number_in_stack);
emu->from_slot = RoF2ToServerSlot(eq->from_slot); emu->from_slot = RoF2ToServerSlot(eq->from_slot);
emu->to_slot = RoF2ToServerSlot(eq->to_slot); emu->to_slot = RoF2ToServerSlot(eq->to_slot);
IN(number_in_stack); IN(number_in_stack);
@ -5546,7 +5546,7 @@ namespace RoF2
RoF2Slot.MainSlot = TempSlot; RoF2Slot.MainSlot = TempSlot;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoF2Slot.SlotType, RoF2Slot.Unknown02, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoF2Slot.SlotType, RoF2Slot.Unknown02, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01);
return RoF2Slot; return RoF2Slot;
} }
@ -5587,7 +5587,7 @@ namespace RoF2
RoF2Slot.SubSlot = TempSlot - ((RoF2Slot.MainSlot + 2) * EmuConstants::ITEM_CONTAINER_SIZE); RoF2Slot.SubSlot = TempSlot - ((RoF2Slot.MainSlot + 2) * EmuConstants::ITEM_CONTAINER_SIZE);
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i", ServerSlot, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01);
return RoF2Slot; return RoF2Slot;
} }
@ -5696,7 +5696,7 @@ namespace RoF2
ServerSlot = RoF2Slot.MainSlot + EmuConstants::CORPSE_BEGIN; ServerSlot = RoF2Slot.MainSlot + EmuConstants::CORPSE_BEGIN;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF2 Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoF2Slot.SlotType, RoF2Slot.Unknown02, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01, ServerSlot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF2 Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoF2Slot.SlotType, RoF2Slot.Unknown02, RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01, ServerSlot);
return ServerSlot; return ServerSlot;
} }
@ -5731,7 +5731,7 @@ namespace RoF2
ServerSlot = TempSlot; ServerSlot = TempSlot;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01, ServerSlot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Convert RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", RoF2Slot.MainSlot, RoF2Slot.SubSlot, RoF2Slot.AugSlot, RoF2Slot.Unknown01, ServerSlot);
return ServerSlot; return ServerSlot;
} }

22
common/patches/sod.cpp
View File

@ -50,7 +50,7 @@ namespace SoD
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -76,7 +76,7 @@ namespace SoD
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -91,10 +91,10 @@ namespace SoD
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -247,7 +247,7 @@ namespace SoD
if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
} }
@ -359,7 +359,7 @@ namespace SoD
if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
@ -391,7 +391,7 @@ namespace SoD
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -967,7 +967,7 @@ namespace SoD
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -2108,7 +2108,7 @@ namespace SoD
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -2363,7 +2363,7 @@ namespace SoD
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -3091,7 +3091,7 @@ namespace SoD
DECODE_LENGTH_EXACT(structs::MoveItem_Struct); DECODE_LENGTH_EXACT(structs::MoveItem_Struct);
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot);
emu->from_slot = SoDToServerSlot(eq->from_slot); emu->from_slot = SoDToServerSlot(eq->from_slot);
emu->to_slot = SoDToServerSlot(eq->to_slot); emu->to_slot = SoDToServerSlot(eq->to_slot);

22
common/patches/sof.cpp
View File

@ -50,7 +50,7 @@ namespace SoF
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -76,7 +76,7 @@ namespace SoF
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -91,10 +91,10 @@ namespace SoF
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -214,7 +214,7 @@ namespace SoF
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(BazaarSearchResults_Struct); int entrycount = in->size / sizeof(BazaarSearchResults_Struct);
if (entrycount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
@ -337,7 +337,7 @@ namespace SoF
if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
@ -371,7 +371,7 @@ namespace SoF
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -766,7 +766,7 @@ namespace SoF
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -1707,7 +1707,7 @@ namespace SoF
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -1887,7 +1887,7 @@ namespace SoF
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -2429,7 +2429,7 @@ namespace SoF
DECODE_LENGTH_EXACT(structs::MoveItem_Struct); DECODE_LENGTH_EXACT(structs::MoveItem_Struct);
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot);
emu->from_slot = SoFToServerSlot(eq->from_slot); emu->from_slot = SoFToServerSlot(eq->from_slot);
emu->to_slot = SoFToServerSlot(eq->to_slot); emu->to_slot = SoFToServerSlot(eq->to_slot);

22
common/patches/titanium.cpp
View File

@ -48,7 +48,7 @@ namespace Titanium
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -74,7 +74,7 @@ namespace Titanium
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -89,10 +89,10 @@ namespace Titanium
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -187,7 +187,7 @@ namespace Titanium
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(BazaarSearchResults_Struct); int entrycount = in->size / sizeof(BazaarSearchResults_Struct);
if (entrycount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
@ -268,7 +268,7 @@ namespace Titanium
int itemcount = in->size / sizeof(InternalSerializedItem_Struct); int itemcount = in->size / sizeof(InternalSerializedItem_Struct);
if (itemcount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (itemcount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
return; return;
} }
@ -285,7 +285,7 @@ namespace Titanium
safe_delete_array(serialized); safe_delete_array(serialized);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -635,7 +635,7 @@ namespace Titanium
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -1157,7 +1157,7 @@ namespace Titanium
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -1274,7 +1274,7 @@ namespace Titanium
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -1623,7 +1623,7 @@ namespace Titanium
DECODE_LENGTH_EXACT(structs::MoveItem_Struct); DECODE_LENGTH_EXACT(structs::MoveItem_Struct);
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot);
emu->from_slot = TitaniumToServerSlot(eq->from_slot); emu->from_slot = TitaniumToServerSlot(eq->from_slot);
emu->to_slot = TitaniumToServerSlot(eq->to_slot); emu->to_slot = TitaniumToServerSlot(eq->to_slot);

22
common/patches/underfoot.cpp
View File

@ -50,7 +50,7 @@ namespace Underfoot
//TODO: figure out how to support shared memory with multiple patches... //TODO: figure out how to support shared memory with multiple patches...
opcodes = new RegularOpcodeManager(); opcodes = new RegularOpcodeManager();
if (!opcodes->LoadOpcodes(opfile.c_str())) { if (!opcodes->LoadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
return; return;
} }
} }
@ -76,7 +76,7 @@ namespace Underfoot
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[IDENTIFY] Registered patch %s", name);
} }
void Reload() void Reload()
@ -91,10 +91,10 @@ namespace Underfoot
opfile += name; opfile += name;
opfile += ".conf"; opfile += ".conf";
if (!opcodes->ReloadOpcodes(opfile.c_str())) { if (!opcodes->ReloadOpcodes(opfile.c_str())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
} }
} }
@ -307,7 +307,7 @@ namespace Underfoot
if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0) if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
delete in; delete in;
return; return;
} }
@ -494,7 +494,7 @@ namespace Underfoot
if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) { if (ItemCount == 0 || (in->size % sizeof(InternalSerializedItem_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d",
opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct)); opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(InternalSerializedItem_Struct));
delete in; delete in;
@ -526,7 +526,7 @@ namespace Underfoot
safe_delete_array(Serialized); safe_delete_array(Serialized);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Serialization failed on item slot %d during OP_CharInventory. Item skipped.", eq->slot_id);
} }
} }
@ -1190,7 +1190,7 @@ namespace Underfoot
char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0); char *serialized = SerializeItem((ItemInst *)int_struct->inst, int_struct->slot_id, &length, 0);
if (!serialized) { if (!serialized) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
delete in; delete in;
return; return;
} }
@ -2374,7 +2374,7 @@ namespace Underfoot
if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0) if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
delete in; delete in;
return; return;
} }
@ -2624,7 +2624,7 @@ namespace Underfoot
//determine and verify length //determine and verify length
int entrycount = in->size / sizeof(Spawn_Struct); int entrycount = in->size / sizeof(Spawn_Struct);
if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) { if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
delete in; delete in;
return; return;
} }
@ -3406,7 +3406,7 @@ namespace Underfoot
DECODE_LENGTH_EXACT(structs::MoveItem_Struct); DECODE_LENGTH_EXACT(structs::MoveItem_Struct);
SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct); SETUP_DIRECT_DECODE(MoveItem_Struct, structs::MoveItem_Struct);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[ERROR] Moved item from %u to %u", eq->from_slot, eq->to_slot);
emu->from_slot = UnderfootToServerSlot(eq->from_slot); emu->from_slot = UnderfootToServerSlot(eq->from_slot);
emu->to_slot = UnderfootToServerSlot(eq->to_slot); emu->to_slot = UnderfootToServerSlot(eq->to_slot);

28
common/rulesys.cpp
View File

@ -107,7 +107,7 @@ bool RuleManager::ListRules(const char *catname, std::vector<const char *> &into
if(catname != nullptr) { if(catname != nullptr) {
cat = FindCategory(catname); cat = FindCategory(catname);
if(cat == InvalidCategory) { if(cat == InvalidCategory) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find category '%s'", catname); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find category '%s'", catname);
return(false); return(false);
} }
} }
@ -168,18 +168,18 @@ bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Databas
switch(type) { switch(type) {
case IntRule: case IntRule:
m_RuleIntValues [index] = atoi(rule_value); m_RuleIntValues [index] = atoi(rule_value);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]);
break; break;
case RealRule: case RealRule:
m_RuleRealValues[index] = atof(rule_value); m_RuleRealValues[index] = atof(rule_value);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]);
break; break;
case BoolRule: case BoolRule:
uint32 val = 0; uint32 val = 0;
if(!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1")) if(!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1"))
val = 1; val = 1;
m_RuleBoolValues[index] = val; m_RuleBoolValues[index] = val;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ?"true":"false"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ?"true":"false");
break; break;
} }
@ -190,7 +190,7 @@ bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Databas
} }
void RuleManager::ResetRules() { void RuleManager::ResetRules() {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Resetting running rules to default values"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Resetting running rules to default values");
#define RULE_INT(cat, rule, default_value) \ #define RULE_INT(cat, rule, default_value) \
m_RuleIntValues[ Int__##rule ] = default_value; m_RuleIntValues[ Int__##rule ] = default_value;
#define RULE_REAL(cat, rule, default_value) \ #define RULE_REAL(cat, rule, default_value) \
@ -214,7 +214,7 @@ bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 &
return(true); return(true);
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find rule '%s'", rule_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find rule '%s'", rule_name);
return(false); return(false);
} }
@ -241,14 +241,14 @@ void RuleManager::SaveRules(Database *db, const char *ruleset) {
m_activeRuleset = _FindOrCreateRuleset(db, ruleset); m_activeRuleset = _FindOrCreateRuleset(db, ruleset);
if(m_activeRuleset == -1) { if(m_activeRuleset == -1) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find or create rule set %s", ruleset); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to find or create rule set %s", ruleset);
return; return;
} }
m_activeName = ruleset; m_activeName = ruleset;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Saving running rules into rule set %s (%d)", ruleset, m_activeRuleset); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Saving running rules into rule set %s (%d)", ruleset, m_activeRuleset);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Saving running rules into running rule set %s", m_activeName.c_str(), m_activeRuleset); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Saving running rules into running rule set %s", m_activeName.c_str(), m_activeRuleset);
} }
int r; int r;
@ -269,11 +269,11 @@ bool RuleManager::LoadRules(Database *db, const char *ruleset) {
int rsid = GetRulesetID(db, ruleset); int rsid = GetRulesetID(db, ruleset);
if(rsid < 0) { if(rsid < 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset);
return(false); return(false);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Loading rule set '%s' (%d)", ruleset, rsid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Loading rule set '%s' (%d)", ruleset, rsid);
m_activeRuleset = rsid; m_activeRuleset = rsid;
m_activeName = ruleset; m_activeName = ruleset;
@ -288,7 +288,7 @@ bool RuleManager::LoadRules(Database *db, const char *ruleset) {
for(auto row = results.begin(); row != results.end(); ++row) for(auto row = results.begin(); row != results.end(); ++row)
if(!SetRule(row[0], row[1], nullptr, false)) if(!SetRule(row[0], row[1], nullptr, false))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to interpret rule record for %s", row[0]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Unable to interpret rule record for %s", row[0]);
return true; return true;
} }
@ -314,7 +314,7 @@ void RuleManager::_SaveRule(Database *db, RuleType type, uint16 index) {
m_activeRuleset, _GetRuleName(type, index), vstr); m_activeRuleset, _GetRuleName(type, index), vstr);
auto results = db->QueryDatabase(query); auto results = db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Fauled to set rule in the database: %s: %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Fauled to set rule in the database: %s: %s", query.c_str(), results.ErrorMessage().c_str());
} }
@ -356,7 +356,7 @@ int RuleManager::_FindOrCreateRuleset(Database *db, const char *ruleset) {
auto results = db->QueryDatabase(query); auto results = db->QueryDatabase(query);
if (!results.Success()) if (!results.Success())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Fauled to create rule set in the database: %s: %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Rules, "Fauled to create rule set in the database: %s: %s", query.c_str(), results.ErrorMessage().c_str());
return -1; return -1;
} }

8
common/shareddb.cpp
View File

@ -1482,7 +1482,7 @@ int SharedDatabase::GetMaxSpellID() {
std::string query = "SELECT MAX(id) FROM spells_new"; std::string query = "SELECT MAX(id) FROM spells_new";
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Error in GetMaxSpellID query '%s' %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Error in GetMaxSpellID query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
return -1; return -1;
} }
@ -1497,12 +1497,12 @@ void SharedDatabase::LoadSpells(void *data, int max_spells) {
const std::string query = "SELECT * FROM spells_new ORDER BY id ASC"; const std::string query = "SELECT * FROM spells_new ORDER BY id ASC";
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Error in LoadSpells query '%s' %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Error in LoadSpells query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
return; return;
} }
if(results.ColumnCount() <= SPELL_LOAD_FIELD_COUNT) { if(results.ColumnCount() <= SPELL_LOAD_FIELD_COUNT) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Fatal error loading spells: Spell field count < SPELL_LOAD_FIELD_COUNT(%u)", SPELL_LOAD_FIELD_COUNT); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Fatal error loading spells: Spell field count < SPELL_LOAD_FIELD_COUNT(%u)", SPELL_LOAD_FIELD_COUNT);
return; return;
} }
@ -1512,7 +1512,7 @@ void SharedDatabase::LoadSpells(void *data, int max_spells) {
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
tempid = atoi(row[0]); tempid = atoi(row[0]);
if(tempid >= max_spells) { if(tempid >= max_spells) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Non fatal error: spell.id >= max_spells, ignoring."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Non fatal error: spell.id >= max_spells, ignoring.");
continue; continue;
} }

2
common/spdat.cpp
View File

@ -839,7 +839,7 @@ DmgShieldType GetDamageShieldType(uint16 spell_id, int32 DSType)
// If we have a DamageShieldType for this spell from the damageshieldtypes table, return that, // If we have a DamageShieldType for this spell from the damageshieldtypes table, return that,
// else, make a guess, based on the resist type. Default return value is DS_THORNS // else, make a guess, based on the resist type. Default return value is DS_THORNS
if (IsValidSpell(spell_id)) { if (IsValidSpell(spell_id)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "DamageShieldType for spell %i (%s) is %X\n", spell_id, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "DamageShieldType for spell %i (%s) is %X\n", spell_id,
spells[spell_id].name, spells[spell_id].DamageShieldType); spells[spell_id].name, spells[spell_id].DamageShieldType);
if (spells[spell_id].DamageShieldType) if (spells[spell_id].DamageShieldType)

4
common/struct_strategy.cpp
View File

@ -39,13 +39,13 @@ void StructStrategy::ErrorEncoder(EQApplicationPacket **in_p, EQStream *dest, bo
EQApplicationPacket *p = *in_p; EQApplicationPacket *p = *in_p;
*in_p = nullptr; *in_p = nullptr;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Error encoding opcode %s: no encoder provided. Dropping.", OpcodeManager::EmuToName(p->GetOpcode())); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Error encoding opcode %s: no encoder provided. Dropping.", OpcodeManager::EmuToName(p->GetOpcode()));
delete p; delete p;
} }
void StructStrategy::ErrorDecoder(EQApplicationPacket *p) { void StructStrategy::ErrorDecoder(EQApplicationPacket *p) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Error decoding opcode %s: no decoder provided. Invalidating.", OpcodeManager::EmuToName(p->GetOpcode())); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[STRUCTS] Error decoding opcode %s: no decoder provided. Invalidating.", OpcodeManager::EmuToName(p->GetOpcode()));
p->SetOpcode(OP_Unknown); p->SetOpcode(OP_Unknown);
} }

4
common/tcp_connection.cpp
View File

@ -900,7 +900,7 @@ ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) {
} }
TCPConnection* tcpc = (TCPConnection*) tmp; TCPConnection* tcpc = (TCPConnection*) tmp;
#ifndef WIN32 #ifndef WIN32
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::TCP_Connection, __FUNCTION__ " Starting TCPConnectionLoop with thread ID %d", pthread_self()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::TCP_Connection, __FUNCTION__ " Starting TCPConnectionLoop with thread ID %d", pthread_self());
#endif #endif
tcpc->MLoopRunning.lock(); tcpc->MLoopRunning.lock();
while (tcpc->RunLoop()) { while (tcpc->RunLoop()) {
@ -927,7 +927,7 @@ ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) {
tcpc->MLoopRunning.unlock(); tcpc->MLoopRunning.unlock();
#ifndef WIN32 #ifndef WIN32
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::TCP_Connection, __FUNCTION__ "Ending TCPConnectionLoop with thread ID %d", pthread_self()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::TCP_Connection, __FUNCTION__ "Ending TCPConnectionLoop with thread ID %d", pthread_self());
#endif #endif
THREAD_RETURN(nullptr); THREAD_RETURN(nullptr);

4
common/worldconn.cpp
View File

@ -44,7 +44,7 @@ bool WorldConnection::SendPacket(ServerPacket* pack) {
void WorldConnection::OnConnected() { void WorldConnection::OnConnected() {
const EQEmuConfig *Config=EQEmuConfig::get(); const EQEmuConfig *Config=EQEmuConfig::get();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[WORLD] Connected to World: %s:%d", Config->WorldIP.c_str(), Config->WorldTCPPort); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[WORLD] Connected to World: %s:%d", Config->WorldIP.c_str(), Config->WorldTCPPort);
ServerPacket* pack = new ServerPacket(ServerOP_ZAAuth, 16); ServerPacket* pack = new ServerPacket(ServerOP_ZAAuth, 16);
MD5::Generate((const uchar*) m_password.c_str(), m_password.length(), pack->pBuffer); MD5::Generate((const uchar*) m_password.c_str(), m_password.length(), pack->pBuffer);
@ -76,7 +76,7 @@ bool WorldConnection::Connect() {
if (tcpc.Connect(Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf)) { if (tcpc.Connect(Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf)) {
return true; return true;
} else { } else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[WORLD] WorldConnection connect: Connecting to the server %s:%d failed: %s", Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Netcode, "[WORLD] WorldConnection connect: Connecting to the server %s:%d failed: %s", Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf);
} }
return false; return false;
} }

18
eqlaunch/eqlaunch.cpp
View File

@ -47,13 +47,13 @@ int main(int argc, char *argv[]) {
launcher_name = argv[1]; launcher_name = argv[1];
} }
if(launcher_name.length() < 1) { if(launcher_name.length() < 1) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "You must specfify a launcher name as the first argument to this program."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "You must specfify a launcher name as the first argument to this program.");
return 1; return 1;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Loading server configuration.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Loading server configuration..");
if (!EQEmuConfig::LoadConfig()) { if (!EQEmuConfig::LoadConfig()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Loading server configuration failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Loading server configuration failed.");
return 1; return 1;
} }
const EQEmuConfig *Config = EQEmuConfig::get(); const EQEmuConfig *Config = EQEmuConfig::get();
@ -62,16 +62,16 @@ int main(int argc, char *argv[]) {
* Setup nice signal handlers * Setup nice signal handlers
*/ */
if (signal(SIGINT, CatchSignal) == SIG_ERR) { if (signal(SIGINT, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler");
return 1; return 1;
} }
if (signal(SIGTERM, CatchSignal) == SIG_ERR) { if (signal(SIGTERM, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler");
return 1; return 1;
} }
#ifndef WIN32 #ifndef WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Could not set signal handler");
return 1; return 1;
} }
@ -92,7 +92,7 @@ int main(int argc, char *argv[]) {
std::map<std::string, ZoneLaunch *> zones; std::map<std::string, ZoneLaunch *> zones;
WorldServer world(zones, launcher_name.c_str(), Config); WorldServer world(zones, launcher_name.c_str(), Config);
if (!world.Connect()) { if (!world.Connect()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "worldserver.Connect() FAILED! Will retry."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "worldserver.Connect() FAILED! Will retry.");
} }
std::map<std::string, ZoneLaunch *>::iterator zone, zend; std::map<std::string, ZoneLaunch *>::iterator zone, zend;
@ -100,7 +100,7 @@ int main(int argc, char *argv[]) {
Timer InterserverTimer(INTERSERVER_TIMER); // does auto-reconnect Timer InterserverTimer(INTERSERVER_TIMER); // does auto-reconnect
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Starting main loop..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Starting main loop...");
// zones["test"] = new ZoneLaunch(&world, "./zone", "dynamic_1"); // zones["test"] = new ZoneLaunch(&world, "./zone", "dynamic_1");
@ -182,7 +182,7 @@ int main(int argc, char *argv[]) {
void CatchSignal(int sig_num) { void CatchSignal(int sig_num) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Caught signal %d", sig_num); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Caught signal %d", sig_num);
RunLoops = false; RunLoops = false;
} }

18
eqlaunch/worldserver.cpp
View File

@ -74,14 +74,14 @@ void WorldServer::Process() {
break; break;
} }
case ServerOP_ZAAuthFailed: { case ServerOP_ZAAuthFailed: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World server responded 'Not Authorized', disabling reconnect"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World server responded 'Not Authorized', disabling reconnect");
pTryReconnect = false; pTryReconnect = false;
Disconnect(); Disconnect();
break; break;
} }
case ServerOP_LauncherZoneRequest: { case ServerOP_LauncherZoneRequest: {
if(pack->size != sizeof(LauncherZoneRequest)) { if(pack->size != sizeof(LauncherZoneRequest)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Invalid size of LauncherZoneRequest: %d", pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Invalid size of LauncherZoneRequest: %d", pack->size);
break; break;
} }
const LauncherZoneRequest *lzr = (const LauncherZoneRequest *) pack->pBuffer; const LauncherZoneRequest *lzr = (const LauncherZoneRequest *) pack->pBuffer;
@ -90,9 +90,9 @@ void WorldServer::Process() {
switch(ZoneRequestCommands(lzr->command)) { switch(ZoneRequestCommands(lzr->command)) {
case ZR_Start: { case ZR_Start: {
if(m_zones.find(lzr->short_name) != m_zones.end()) { if(m_zones.find(lzr->short_name) != m_zones.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to start zone %s, but it is already running.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to start zone %s, but it is already running.", lzr->short_name);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to start zone %s.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to start zone %s.", lzr->short_name);
ZoneLaunch *l = new ZoneLaunch(this, m_name, lzr->short_name, m_config); ZoneLaunch *l = new ZoneLaunch(this, m_name, lzr->short_name, m_config);
m_zones[lzr->short_name] = l; m_zones[lzr->short_name] = l;
} }
@ -101,9 +101,9 @@ void WorldServer::Process() {
case ZR_Restart: { case ZR_Restart: {
std::map<std::string, ZoneLaunch *>::iterator res = m_zones.find(lzr->short_name); std::map<std::string, ZoneLaunch *>::iterator res = m_zones.find(lzr->short_name);
if(res == m_zones.end()) { if(res == m_zones.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to restart zone %s, but it is not running.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to restart zone %s, but it is not running.", lzr->short_name);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to restart zone %s.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to restart zone %s.", lzr->short_name);
res->second->Restart(); res->second->Restart();
} }
break; break;
@ -111,9 +111,9 @@ void WorldServer::Process() {
case ZR_Stop: { case ZR_Stop: {
std::map<std::string, ZoneLaunch *>::iterator res = m_zones.find(lzr->short_name); std::map<std::string, ZoneLaunch *>::iterator res = m_zones.find(lzr->short_name);
if(res == m_zones.end()) { if(res == m_zones.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to stop zone %s, but it is not running.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to stop zone %s, but it is not running.", lzr->short_name);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to stop zone %s.", lzr->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "World told us to stop zone %s.", lzr->short_name);
res->second->Stop(); res->second->Stop();
} }
break; break;
@ -127,7 +127,7 @@ void WorldServer::Process() {
} }
default: { default: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Unknown opcode 0x%x from World of len %d", pack->opcode, pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Unknown opcode 0x%x from World of len %d", pack->opcode, pack->size);
break; break;
} }
} }

46
eqlaunch/zone_launch.cpp
View File

@ -72,7 +72,7 @@ void ZoneLaunch::Start() {
//spec is consumed, even on failure //spec is consumed, even on failure
m_ref = ProcLauncher::get()->Launch(spec); m_ref = ProcLauncher::get()->Launch(spec);
if(m_ref == ProcLauncher::ProcError) { if(m_ref == ProcLauncher::ProcError) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failure to launch '%s %s %s'. ", m_config->ZoneExe.c_str(), m_zone.c_str(), m_launcherName); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failure to launch '%s %s %s'. ", m_config->ZoneExe.c_str(), m_zone.c_str(), m_launcherName);
m_timer.Start(m_config->RestartWait); m_timer.Start(m_config->RestartWait);
return; return;
} }
@ -84,17 +84,17 @@ void ZoneLaunch::Start() {
SendStatus(); SendStatus();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has been started.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has been started.", m_zone.c_str());
} }
void ZoneLaunch::Restart() { void ZoneLaunch::Restart() {
switch(m_state) { switch(m_state) {
case StateRestartPending: case StateRestartPending:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of zone %s requested when a restart is already pending.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of zone %s requested when a restart is already pending.", m_zone.c_str());
break; break;
case StateStartPending: case StateStartPending:
//we havent started yet, do nothing //we havent started yet, do nothing
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of %s before it has started. Ignoring.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of %s before it has started. Ignoring.", m_zone.c_str());
break; break;
case StateStarted: case StateStarted:
//process is running along, kill it off.. //process is running along, kill it off..
@ -102,20 +102,20 @@ void ZoneLaunch::Restart() {
break; //we have no proc ref... cannot stop.. break; //we have no proc ref... cannot stop..
if(!ProcLauncher::get()->Terminate(m_ref, true)) { if(!ProcLauncher::get()->Terminate(m_ref, true)) {
//failed to terminate the process, its not likely that it will work if we try again, so give up. //failed to terminate the process, its not likely that it will work if we try again, so give up.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failed to terminate zone %s. Giving up and moving to stopped.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failed to terminate zone %s. Giving up and moving to stopped.", m_zone.c_str());
m_state = StateStopped; m_state = StateStopped;
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Termination signal sent to zone %s.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Termination signal sent to zone %s.", m_zone.c_str());
m_timer.Start(m_config->TerminateWait); m_timer.Start(m_config->TerminateWait);
m_state = StateRestartPending; m_state = StateRestartPending;
break; break;
case StateStopPending: case StateStopPending:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of zone %s requested when a stop is pending. Ignoring.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart of zone %s requested when a stop is pending. Ignoring.", m_zone.c_str());
break; break;
case StateStopped: case StateStopped:
//process is already stopped... nothing to do.. //process is already stopped... nothing to do..
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart requested when zone %s is already stopped.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Restart requested when zone %s is already stopped.", m_zone.c_str());
break; break;
} }
} }
@ -124,7 +124,7 @@ void ZoneLaunch::Stop(bool graceful) {
switch(m_state) { switch(m_state) {
case StateStartPending: case StateStartPending:
//we havent started yet, transition directly to stopped. //we havent started yet, transition directly to stopped.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Stopping zone %s before it has started.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Stopping zone %s before it has started.", m_zone.c_str());
m_state = StateStopped; m_state = StateStopped;
break; break;
case StateStarted: case StateStarted:
@ -134,17 +134,17 @@ void ZoneLaunch::Stop(bool graceful) {
break; //we have no proc ref... cannot stop.. break; //we have no proc ref... cannot stop..
if(!ProcLauncher::get()->Terminate(m_ref, graceful)) { if(!ProcLauncher::get()->Terminate(m_ref, graceful)) {
//failed to terminate the process, its not likely that it will work if we try again, so give up. //failed to terminate the process, its not likely that it will work if we try again, so give up.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failed to terminate zone %s. Giving up and moving to stopped.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Failed to terminate zone %s. Giving up and moving to stopped.", m_zone.c_str());
m_state = StateStopped; m_state = StateStopped;
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Termination signal sent to zone %s.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Termination signal sent to zone %s.", m_zone.c_str());
m_timer.Start(m_config->TerminateWait); m_timer.Start(m_config->TerminateWait);
m_state = StateStopPending; m_state = StateStopPending;
break; break;
case StateStopped: case StateStopped:
//process is already stopped... nothing to do.. //process is already stopped... nothing to do..
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Stop requested when zone %s is already stopped.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Stop requested when zone %s is already stopped.", m_zone.c_str());
break; break;
} }
} }
@ -164,17 +164,17 @@ bool ZoneLaunch::Process() {
m_timer.Disable(); m_timer.Disable();
//actually start up the program //actually start up the program
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Starting zone %s", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Starting zone %s", m_zone.c_str());
Start(); Start();
//now update the shared timer to reflect the proper start interval. //now update the shared timer to reflect the proper start interval.
if(s_running == 1) { if(s_running == 1) {
//we are the first zone started. wait that interval. //we are the first zone started. wait that interval.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Waiting %d milliseconds before booting the second zone.", m_config->InitialBootWait); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Waiting %d milliseconds before booting the second zone.", m_config->InitialBootWait);
s_startTimer.Start(m_config->InitialBootWait); s_startTimer.Start(m_config->InitialBootWait);
} else { } else {
//just some follow on zone, use that interval. //just some follow on zone, use that interval.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Waiting %d milliseconds before booting the next zone.", m_config->ZoneBootInterval); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Waiting %d milliseconds before booting the next zone.", m_config->ZoneBootInterval);
s_startTimer.Start(m_config->ZoneBootInterval); s_startTimer.Start(m_config->ZoneBootInterval);
} }
@ -187,7 +187,7 @@ bool ZoneLaunch::Process() {
//waiting for notification that our child has died.. //waiting for notification that our child has died..
if(m_timer.Check()) { if(m_timer.Check()) {
//we have timed out, try to kill the child again //we have timed out, try to kill the child again
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, killing again.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, killing again.", m_zone.c_str());
Restart(); Restart();
} }
break; break;
@ -197,12 +197,12 @@ bool ZoneLaunch::Process() {
//we have timed out, try to kill the child again //we have timed out, try to kill the child again
m_killFails++; m_killFails++;
if(m_killFails > 5) { //should get this number from somewhere.. if(m_killFails > 5) { //should get this number from somewhere..
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, giving up and acting like its dead.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, giving up and acting like its dead.", m_zone.c_str());
m_state = StateStopped; m_state = StateStopped;
s_running--; s_running--;
SendStatus(); SendStatus();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, killing again.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s refused to die, killing again.", m_zone.c_str());
Stop(false); Stop(false);
} }
} }
@ -221,29 +221,29 @@ void ZoneLaunch::OnTerminate(const ProcLauncher::ProcRef &ref, const ProcLaunche
switch(m_state) { switch(m_state) {
case StateStartPending: case StateStartPending:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has gone down before we started it..?? Restart timer started.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has gone down before we started it..?? Restart timer started.", m_zone.c_str());
m_state = StateStartPending; m_state = StateStartPending;
m_timer.Start(m_config->RestartWait); m_timer.Start(m_config->RestartWait);
break; break;
case StateStarted: case StateStarted:
//something happened to our happy process... //something happened to our happy process...
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has gone down. Restart timer started.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has gone down. Restart timer started.", m_zone.c_str());
m_state = StateStartPending; m_state = StateStartPending;
m_timer.Start(m_config->RestartWait); m_timer.Start(m_config->RestartWait);
break; break;
case StateRestartPending: case StateRestartPending:
//it finally died, start it on up again //it finally died, start it on up again
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has terminated. Transitioning to starting state.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has terminated. Transitioning to starting state.", m_zone.c_str());
m_state = StateStartPending; m_state = StateStartPending;
break; break;
case StateStopPending: case StateStopPending:
//it finally died, transition to close. //it finally died, transition to close.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has terminated. Transitioning to stopped state.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Zone %s has terminated. Transitioning to stopped state.", m_zone.c_str());
m_state = StateStopped; m_state = StateStopped;
break; break;
case StateStopped: case StateStopped:
//we already thought it was stopped... dont care... //we already thought it was stopped... dont care...
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Notified of zone %s terminating when we thought it was stopped.", m_zone.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Launcher, "Notified of zone %s terminating when we thought it was stopped.", m_zone.c_str());
break; break;
} }

56
queryserv/database.cpp
View File

@ -116,8 +116,8 @@ void Database::AddSpeech(const char* from, const char* to, const char* message,
safe_delete_array(escapedMessage); safe_delete_array(escapedMessage);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Speech Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Speech Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
@ -136,8 +136,8 @@ void Database::LogPlayerTrade(QSPlayerLogTrade_Struct* QS, uint32 detailCount) {
QS->char2_money.silver, QS->char2_money.copper, QS->char2_count); QS->char2_money.silver, QS->char2_money.copper, QS->char2_count);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Trade Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Trade Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(detailCount == 0) if(detailCount == 0)
@ -156,8 +156,8 @@ void Database::LogPlayerTrade(QSPlayerLogTrade_Struct* QS, uint32 detailCount) {
QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5); QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5);
results = QueryDatabase(query); results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Trade Log Record Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Trade Log Record Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -179,8 +179,8 @@ void Database::LogPlayerHandin(QSPlayerLogHandin_Struct* QS, uint32 detailCount)
QS->npc_count); QS->npc_count);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Handin Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Handin Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(detailCount == 0) if(detailCount == 0)
@ -198,8 +198,8 @@ void Database::LogPlayerHandin(QSPlayerLogHandin_Struct* QS, uint32 detailCount)
QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4,
QS->items[i].aug_5); QS->items[i].aug_5);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Handin Log Record Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Handin Log Record Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -213,8 +213,8 @@ void Database::LogPlayerNPCKill(QSPlayerLogNPCKill_Struct* QS, uint32 members){
QS->s1.NPCID, QS->s1.Type, QS->s1.ZoneID); QS->s1.NPCID, QS->s1.Type, QS->s1.ZoneID);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed NPC Kill Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed NPC Kill Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(members == 0) if(members == 0)
@ -228,8 +228,8 @@ void Database::LogPlayerNPCKill(QSPlayerLogNPCKill_Struct* QS, uint32 members){
lastIndex, QS->Chars[i].char_id); lastIndex, QS->Chars[i].char_id);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed NPC Kill Log Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed NPC Kill Log Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -243,8 +243,8 @@ void Database::LogPlayerDelete(QSPlayerLogDelete_Struct* QS, uint32 items) {
QS->char_id, QS->stack_size, QS->char_count, QS->char_count); QS->char_id, QS->stack_size, QS->char_count, QS->char_count);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(items == 0) if(items == 0)
@ -261,8 +261,8 @@ void Database::LogPlayerDelete(QSPlayerLogDelete_Struct* QS, uint32 items) {
QS->items[i].aug_5); QS->items[i].aug_5);
results = QueryDatabase(query); results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -279,8 +279,8 @@ void Database::LogPlayerMove(QSPlayerLogMove_Struct* QS, uint32 items) {
QS->char_count, QS->postaction); QS->char_count, QS->postaction);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Move Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Move Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(items == 0) if(items == 0)
@ -297,8 +297,8 @@ void Database::LogPlayerMove(QSPlayerLogMove_Struct* QS, uint32 items) {
QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5); QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5);
results = QueryDatabase(query); results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Move Log Record Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Move Log Record Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -320,8 +320,8 @@ void Database::LogMerchantTransaction(QSMerchantLogTransaction_Struct* QS, uint3
QS->char_money.copper, QS->char_count); QS->char_money.copper, QS->char_count);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Transaction Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Transaction Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
if(items == 0) if(items == 0)
@ -338,8 +338,8 @@ void Database::LogMerchantTransaction(QSMerchantLogTransaction_Struct* QS, uint3
QS->items[i].aug_5); QS->items[i].aug_5);
results = QueryDatabase(query); results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Transaction Log Record Entry Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Transaction Log Record Entry Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
} }
@ -356,8 +356,8 @@ void Database::GeneralQueryReceive(ServerPacket *pack) {
std::string query(queryBuffer); std::string query(queryBuffer);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Insert: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed Delete Log Record Insert: %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "%s", query.c_str());
} }
safe_delete(pack); safe_delete(pack);

14
queryserv/lfguild.cpp
View File

@ -40,7 +40,7 @@ bool LFGuildManager::LoadDatabase()
"`aacount`, `timezone`, `timeposted` FROM `lfguild`"; "`aacount`, `timezone`, `timeposted` FROM `lfguild`";
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed to load LFGuild info from database. %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Failed to load LFGuild info from database. %s %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -242,7 +242,7 @@ void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char
std::string query = StringFormat("DELETE FROM `lfguild` WHERE `type` = 0 AND `name` = '%s'", From); std::string query = StringFormat("DELETE FROM `lfguild` WHERE `type` = 0 AND `name` = '%s'", From);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing player from LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing player from LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
uint32 Now = time(nullptr); uint32 Now = time(nullptr);
@ -257,7 +257,7 @@ void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char
From, Comments, Level, Class, AAPoints, TimeZone, Now); From, Comments, Level, Class, AAPoints, TimeZone, Now);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error inserting player into LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error inserting player into LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
} }
ServerPacket *pack = new ServerPacket(ServerOP_QueryServGeneric, strlen(From) + strlen(Comments) + 30); ServerPacket *pack = new ServerPacket(ServerOP_QueryServGeneric, strlen(From) + strlen(Comments) + 30);
@ -288,7 +288,7 @@ void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char
std::string query = StringFormat("DELETE FROM `lfguild` WHERE `type` = 1 AND `name` = '%s'", GuildName); std::string query = StringFormat("DELETE FROM `lfguild` WHERE `type` = 1 AND `name` = '%s'", GuildName);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing guild from LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing guild from LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
uint32 Now = time(nullptr); uint32 Now = time(nullptr);
@ -305,7 +305,7 @@ void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char
Classes, AACount, TimeZone, Now); Classes, AACount, TimeZone, Now);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error inserting guild into LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error inserting guild into LFGuild table, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
} }
@ -335,7 +335,7 @@ void LFGuildManager::ExpireEntries()
std::string query = StringFormat("DELETE from `lfguild` WHERE `type` = 0 AND `name` = '%s'", (*it).Name.c_str()); std::string query = StringFormat("DELETE from `lfguild` WHERE `type` = 0 AND `name` = '%s'", (*it).Name.c_str());
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error expiring player LFGuild entry, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error expiring player LFGuild entry, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
it = Players.erase(it); it = Players.erase(it);
} }
@ -348,7 +348,7 @@ void LFGuildManager::ExpireEntries()
std::string query = StringFormat("DELETE from `lfguild` WHERE `type` = 1 AND `name` = '%s'", (*it2).Name.c_str()); std::string query = StringFormat("DELETE from `lfguild` WHERE `type` = 1 AND `name` = '%s'", (*it2).Name.c_str());
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing guild LFGuild entry, query was %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Error removing guild LFGuild entry, query was %s, %s", query.c_str(), results.ErrorMessage().c_str());
it2 = Guilds.erase(it2); it2 = Guilds.erase(it2);
} }

16
queryserv/queryserv.cpp
View File

@ -65,16 +65,16 @@ int main() {
</qsdatabase> </qsdatabase>
*/ */
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Starting EQEmu QueryServ."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Starting EQEmu QueryServ.");
if (!queryservconfig::LoadConfig()) { if (!queryservconfig::LoadConfig()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Loading server configuration failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Loading server configuration failed.");
return 1; return 1;
} }
Config = queryservconfig::get(); Config = queryservconfig::get();
WorldShortName = Config->ShortName; WorldShortName = Config->ShortName;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Connecting to MySQL..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Connecting to MySQL...");
/* MySQL Connection */ /* MySQL Connection */
if (!database.Connect( if (!database.Connect(
@ -83,22 +83,22 @@ int main() {
Config->QSDatabasePassword.c_str(), Config->QSDatabasePassword.c_str(),
Config->QSDatabaseDB.c_str(), Config->QSDatabaseDB.c_str(),
Config->QSDatabasePort)) { Config->QSDatabasePort)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection.");
return 1; return 1;
} }
/* Initialize Logging */ /* Initialize Logging */
if (!load_log_settings(Config->LogSettingsFile.c_str())) if (!load_log_settings(Config->LogSettingsFile.c_str()))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str());
if (signal(SIGINT, CatchSignal) == SIG_ERR) { if (signal(SIGINT, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Could not set signal handler");
return 1; return 1;
} }
if (signal(SIGTERM, CatchSignal) == SIG_ERR) { if (signal(SIGTERM, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Could not set signal handler");
return 1; return 1;
} }

6
queryserv/worldserver.cpp
View File

@ -53,7 +53,7 @@ WorldServer::~WorldServer()
void WorldServer::OnConnected() void WorldServer::OnConnected()
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Connected to World."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Connected to World.");
WorldConnection::OnConnected(); WorldConnection::OnConnected();
} }
@ -66,7 +66,7 @@ void WorldServer::Process()
ServerPacket *pack = 0; ServerPacket *pack = 0;
while((pack = tcpc.PopPacket())) while((pack = tcpc.PopPacket()))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Received Opcode: %4X", pack->opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Received Opcode: %4X", pack->opcode);
switch(pack->opcode) { switch(pack->opcode) {
case 0: { case 0: {
break; break;
@ -148,7 +148,7 @@ void WorldServer::Process()
break; break;
} }
default: default:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Received unhandled ServerOP_QueryServGeneric", Type); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Received unhandled ServerOP_QueryServGeneric", Type);
break; break;
} }
break; break;

32
ucs/chatchannel.cpp
View File

@ -42,7 +42,7 @@ ChatChannel::ChatChannel(std::string inName, std::string inOwner, std::string in
Moderated = false; Moderated = false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New ChatChannel created: Name: [%s], Owner: [%s], Password: [%s], MinStatus: %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New ChatChannel created: Name: [%s], Owner: [%s], Password: [%s], MinStatus: %i",
Name.c_str(), Owner.c_str(), Password.c_str(), MinimumStatus); Name.c_str(), Owner.c_str(), Password.c_str(), MinimumStatus);
} }
@ -149,7 +149,7 @@ void ChatChannelList::SendAllChannels(Client *c) {
void ChatChannelList::RemoveChannel(ChatChannel *Channel) { void ChatChannelList::RemoveChannel(ChatChannel *Channel) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveChannel(%s)", Channel->GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveChannel(%s)", Channel->GetName().c_str());
LinkedListIterator<ChatChannel*> iterator(ChatChannels); LinkedListIterator<ChatChannel*> iterator(ChatChannels);
@ -170,7 +170,7 @@ void ChatChannelList::RemoveChannel(ChatChannel *Channel) {
void ChatChannelList::RemoveAllChannels() { void ChatChannelList::RemoveAllChannels() {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveAllChannels"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveAllChannels");
LinkedListIterator<ChatChannel*> iterator(ChatChannels); LinkedListIterator<ChatChannel*> iterator(ChatChannels);
@ -228,7 +228,7 @@ void ChatChannel::AddClient(Client *c) {
if(IsClientInChannel(c)) { if(IsClientInChannel(c)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client %s already in channel %s", c->GetName().c_str(), GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client %s already in channel %s", c->GetName().c_str(), GetName().c_str());
return; return;
} }
@ -237,7 +237,7 @@ void ChatChannel::AddClient(Client *c) {
int AccountStatus = c->GetAccountStatus(); int AccountStatus = c->GetAccountStatus();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Adding %s to channel %s", c->GetName().c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Adding %s to channel %s", c->GetName().c_str(), Name.c_str());
LinkedListIterator<Client*> iterator(ClientsInChannel); LinkedListIterator<Client*> iterator(ClientsInChannel);
@ -262,7 +262,7 @@ bool ChatChannel::RemoveClient(Client *c) {
if(!c) return false; if(!c) return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveClient %s from channel %s", c->GetName().c_str(), GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "RemoveClient %s from channel %s", c->GetName().c_str(), GetName().c_str());
bool HideMe = c->GetHideMe(); bool HideMe = c->GetHideMe();
@ -299,7 +299,7 @@ bool ChatChannel::RemoveClient(Client *c) {
if((Password.length() == 0) || (RuleI(Channels, DeleteTimer) == 0)) if((Password.length() == 0) || (RuleI(Channels, DeleteTimer) == 0))
return false; return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Starting delete timer for empty password protected channel %s", Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Starting delete timer for empty password protected channel %s", Name.c_str());
DeleteTimer.Start(RuleI(Channels, DeleteTimer) * 60000); DeleteTimer.Start(RuleI(Channels, DeleteTimer) * 60000);
} }
@ -397,7 +397,7 @@ void ChatChannel::SendMessageToChannel(std::string Message, Client* Sender) {
if(ChannelClient) if(ChannelClient)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Sending message to %s from %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Sending message to %s from %s",
ChannelClient->GetName().c_str(), Sender->GetName().c_str()); ChannelClient->GetName().c_str(), Sender->GetName().c_str());
ChannelClient->SendChannelMessage(Name, Message, Sender); ChannelClient->SendChannelMessage(Name, Message, Sender);
} }
@ -479,7 +479,7 @@ ChatChannel *ChatChannelList::AddClientToChannel(std::string ChannelName, Client
return nullptr; return nullptr;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "AddClient to channel [%s] with password [%s]", NormalisedName.c_str(), Password.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "AddClient to channel [%s] with password [%s]", NormalisedName.c_str(), Password.c_str());
ChatChannel *RequiredChannel = FindChannel(NormalisedName); ChatChannel *RequiredChannel = FindChannel(NormalisedName);
@ -555,7 +555,7 @@ void ChatChannelList::Process() {
if(CurrentChannel && CurrentChannel->ReadyToDelete()) { if(CurrentChannel && CurrentChannel->ReadyToDelete()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Empty temporary password protected channel %s being destroyed.", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Empty temporary password protected channel %s being destroyed.",
CurrentChannel->GetName().c_str()); CurrentChannel->GetName().c_str());
RemoveChannel(CurrentChannel); RemoveChannel(CurrentChannel);
@ -572,7 +572,7 @@ void ChatChannel::AddInvitee(std::string Invitee) {
Invitees.push_back(Invitee); Invitees.push_back(Invitee);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as invitee to channel %s", Invitee.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as invitee to channel %s", Invitee.c_str(), Name.c_str());
} }
} }
@ -587,7 +587,7 @@ void ChatChannel::RemoveInvitee(std::string Invitee) {
Invitees.erase(Iterator); Invitees.erase(Iterator);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as invitee to channel %s", Invitee.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as invitee to channel %s", Invitee.c_str(), Name.c_str());
return; return;
} }
@ -613,7 +613,7 @@ void ChatChannel::AddModerator(std::string Moderator) {
Moderators.push_back(Moderator); Moderators.push_back(Moderator);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as moderator to channel %s", Moderator.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as moderator to channel %s", Moderator.c_str(), Name.c_str());
} }
} }
@ -628,7 +628,7 @@ void ChatChannel::RemoveModerator(std::string Moderator) {
Moderators.erase(Iterator); Moderators.erase(Iterator);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as moderator to channel %s", Moderator.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as moderator to channel %s", Moderator.c_str(), Name.c_str());
return; return;
} }
@ -654,7 +654,7 @@ void ChatChannel::AddVoice(std::string inVoiced) {
Voiced.push_back(inVoiced); Voiced.push_back(inVoiced);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as voiced to channel %s", inVoiced.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added %s as voiced to channel %s", inVoiced.c_str(), Name.c_str());
} }
} }
@ -669,7 +669,7 @@ void ChatChannel::RemoveVoice(std::string inVoiced) {
Voiced.erase(Iterator); Voiced.erase(Iterator);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as voiced to channel %s", inVoiced.c_str(), Name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed %s as voiced to channel %s", inVoiced.c_str(), Name.c_str());
return; return;
} }

78
ucs/clientlist.cpp
View File

@ -236,7 +236,7 @@ std::vector<std::string> ParseRecipients(std::string RecipientString) {
static void ProcessMailTo(Client *c, std::string MailMessage) { static void ProcessMailTo(Client *c, std::string MailMessage) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MAILTO: From %s, %s", c->MailBoxName().c_str(), MailMessage.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MAILTO: From %s, %s", c->MailBoxName().c_str(), MailMessage.c_str());
std::vector<std::string> Recipients; std::vector<std::string> Recipients;
@ -305,7 +305,7 @@ static void ProcessMailTo(Client *c, std::string MailMessage) {
if (!database.SendMail(Recipient, c->MailBoxName(), Subject, Body, RecipientsString)) { if (!database.SendMail(Recipient, c->MailBoxName(), Subject, Body, RecipientsString)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed in SendMail(%s, %s, %s, %s)", Recipient.c_str(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed in SendMail(%s, %s, %s, %s)", Recipient.c_str(),
c->MailBoxName().c_str(), Subject.c_str(), RecipientsString.c_str()); c->MailBoxName().c_str(), Subject.c_str(), RecipientsString.c_str());
int PacketLength = 10 + Recipient.length() + Subject.length(); int PacketLength = 10 + Recipient.length() + Subject.length();
@ -400,7 +400,7 @@ static void ProcessSetMessageStatus(std::string SetMessageCommand) {
static void ProcessCommandBuddy(Client *c, std::string Buddy) { static void ProcessCommandBuddy(Client *c, std::string Buddy) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received buddy command with parameters %s", Buddy.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received buddy command with parameters %s", Buddy.c_str());
c->GeneralChannelMessage("Buddy list modified"); c->GeneralChannelMessage("Buddy list modified");
uint8 SubAction = 1; uint8 SubAction = 1;
@ -430,7 +430,7 @@ static void ProcessCommandBuddy(Client *c, std::string Buddy) {
static void ProcessCommandIgnore(Client *c, std::string Ignoree) { static void ProcessCommandIgnore(Client *c, std::string Ignoree) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received ignore command with parameters %s", Ignoree.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received ignore command with parameters %s", Ignoree.c_str());
c->GeneralChannelMessage("Ignore list modified"); c->GeneralChannelMessage("Ignore list modified");
uint8 SubAction = 0; uint8 SubAction = 0;
@ -481,9 +481,9 @@ Clientlist::Clientlist(int ChatPort) {
exit(1); exit(1);
if (chatsf->Open()) if (chatsf->Open())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"Client (UDP) Chat listener started on port %i.", ChatPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"Client (UDP) Chat listener started on port %i.", ChatPort);
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"Failed to start client (UDP) listener (port %-4i)", ChatPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"Failed to start client (UDP) listener (port %-4i)", ChatPort);
exit(1); exit(1);
} }
@ -560,13 +560,13 @@ void Clientlist::CheckForStaleConnections(Client *c) {
if(((*Iterator) != c) && ((c->GetName() == (*Iterator)->GetName()) if(((*Iterator) != c) && ((c->GetName() == (*Iterator)->GetName())
&& (c->GetConnectionType() == (*Iterator)->GetConnectionType()))) { && (c->GetConnectionType() == (*Iterator)->GetConnectionType()))) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removing old connection for %s", c->GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removing old connection for %s", c->GetName().c_str());
struct in_addr in; struct in_addr in;
in.s_addr = (*Iterator)->ClientStream->GetRemoteIP(); in.s_addr = (*Iterator)->ClientStream->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client connection from %s:%d closed.", inet_ntoa(in), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client connection from %s:%d closed.", inet_ntoa(in),
ntohs((*Iterator)->ClientStream->GetRemotePort())); ntohs((*Iterator)->ClientStream->GetRemotePort()));
safe_delete((*Iterator)); safe_delete((*Iterator));
@ -586,7 +586,7 @@ void Clientlist::Process() {
in.s_addr = eqs->GetRemoteIP(); in.s_addr = eqs->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New Client UDP connection from %s:%d", inet_ntoa(in), ntohs(eqs->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New Client UDP connection from %s:%d", inet_ntoa(in), ntohs(eqs->GetRemotePort()));
eqs->SetOpcodeManager(&ChatOpMgr); eqs->SetOpcodeManager(&ChatOpMgr);
@ -606,7 +606,7 @@ void Clientlist::Process() {
in.s_addr = (*Iterator)->ClientStream->GetRemoteIP(); in.s_addr = (*Iterator)->ClientStream->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client connection from %s:%d closed.", inet_ntoa(in), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client connection from %s:%d closed.", inet_ntoa(in),
ntohs((*Iterator)->ClientStream->GetRemotePort())); ntohs((*Iterator)->ClientStream->GetRemotePort()));
safe_delete((*Iterator)); safe_delete((*Iterator));
@ -646,7 +646,7 @@ void Clientlist::Process() {
if(strlen(PacketBuffer) != 9) if(strlen(PacketBuffer) != 9)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Mail key is the wrong size. Version of world incompatible with UCS."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Mail key is the wrong size. Version of world incompatible with UCS.");
KeyValid = false; KeyValid = false;
break; break;
} }
@ -667,11 +667,11 @@ void Clientlist::Process() {
else else
CharacterName = MailBoxString.substr(LastPeriod + 1); CharacterName = MailBoxString.substr(LastPeriod + 1);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received login for user %s with key %s", MailBox, Key); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received login for user %s with key %s", MailBox, Key);
if(!database.VerifyMailKey(CharacterName, (*Iterator)->ClientStream->GetRemoteIP(), Key)) { if(!database.VerifyMailKey(CharacterName, (*Iterator)->ClientStream->GetRemoteIP(), Key)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Chat Key for %s does not match, closing connection.", MailBox); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Chat Key for %s does not match, closing connection.", MailBox);
KeyValid = false; KeyValid = false;
@ -703,7 +703,7 @@ void Clientlist::Process() {
default: { default: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unhandled chat opcode %8X", opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unhandled chat opcode %8X", opcode);
break; break;
} }
} }
@ -716,7 +716,7 @@ void Clientlist::Process() {
in.s_addr = (*Iterator)->ClientStream->GetRemoteIP(); in.s_addr = (*Iterator)->ClientStream->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Force disconnecting client: %s:%d, KeyValid=%i, GetForceDisconnect()=%i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Force disconnecting client: %s:%d, KeyValid=%i, GetForceDisconnect()=%i",
inet_ntoa(in), ntohs((*Iterator)->ClientStream->GetRemotePort()), inet_ntoa(in), ntohs((*Iterator)->ClientStream->GetRemotePort()),
KeyValid, (*Iterator)->GetForceDisconnect()); KeyValid, (*Iterator)->GetForceDisconnect());
@ -860,7 +860,7 @@ void Clientlist::ProcessOPMailCommand(Client *c, std::string CommandString)
break; break;
case CommandSetMessageStatus: case CommandSetMessageStatus:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set Message Status, Params: %s", Parameters.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set Message Status, Params: %s", Parameters.c_str());
ProcessSetMessageStatus(Parameters); ProcessSetMessageStatus(Parameters);
break; break;
@ -885,7 +885,7 @@ void Clientlist::ProcessOPMailCommand(Client *c, std::string CommandString)
default: default:
c->SendHelp(); c->SendHelp();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unhandled OP_Mail command: %s", CommandString.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unhandled OP_Mail command: %s", CommandString.c_str());
} }
} }
@ -896,7 +896,7 @@ void Clientlist::CloseAllConnections() {
for(Iterator = ClientChatConnections.begin(); Iterator != ClientChatConnections.end(); ++Iterator) { for(Iterator = ClientChatConnections.begin(); Iterator != ClientChatConnections.end(); ++Iterator) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removing client %s", (*Iterator)->GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removing client %s", (*Iterator)->GetName().c_str());
(*Iterator)->CloseConnection(); (*Iterator)->CloseConnection();
} }
@ -905,7 +905,7 @@ void Clientlist::CloseAllConnections() {
void Client::AddCharacter(int CharID, const char *CharacterName, int Level) { void Client::AddCharacter(int CharID, const char *CharacterName, int Level) {
if(!CharacterName) return; if(!CharacterName) return;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Adding character %s with ID %i for %s", CharacterName, CharID, GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Adding character %s with ID %i for %s", CharacterName, CharID, GetName().c_str());
CharacterEntry NewCharacter; CharacterEntry NewCharacter;
NewCharacter.CharID = CharID; NewCharacter.CharID = CharID;
NewCharacter.Name = CharacterName; NewCharacter.Name = CharacterName;
@ -971,7 +971,7 @@ void Client::AddToChannelList(ChatChannel *JoinedChannel) {
for(int i = 0; i < MAX_JOINED_CHANNELS; i++) for(int i = 0; i < MAX_JOINED_CHANNELS; i++)
if(JoinedChannels[i] == nullptr) { if(JoinedChannels[i] == nullptr) {
JoinedChannels[i] = JoinedChannel; JoinedChannels[i] = JoinedChannel;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Channel %s to slot %i for %s", JoinedChannel->GetName().c_str(), i + 1, GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Channel %s to slot %i for %s", JoinedChannel->GetName().c_str(), i + 1, GetName().c_str());
return; return;
} }
} }
@ -1012,7 +1012,7 @@ void Client::JoinChannels(std::string ChannelNameList) {
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client: %s joining channels %s", GetName().c_str(), ChannelNameList.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client: %s joining channels %s", GetName().c_str(), ChannelNameList.c_str());
int NumberOfChannels = ChannelCount(); int NumberOfChannels = ChannelCount();
@ -1113,7 +1113,7 @@ void Client::JoinChannels(std::string ChannelNameList) {
void Client::LeaveChannels(std::string ChannelNameList) { void Client::LeaveChannels(std::string ChannelNameList) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client: %s leaving channels %s", GetName().c_str(), ChannelNameList.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client: %s leaving channels %s", GetName().c_str(), ChannelNameList.c_str());
std::string::size_type CurrentPos = 0; std::string::size_type CurrentPos = 0;
@ -1292,7 +1292,7 @@ void Client::SendChannelMessage(std::string Message)
std::string ChannelName = Message.substr(1, MessageStart-1); std::string ChannelName = Message.substr(1, MessageStart-1);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s tells %s, [%s]", GetName().c_str(), ChannelName.c_str(), Message.substr(MessageStart + 1).c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s tells %s, [%s]", GetName().c_str(), ChannelName.c_str(), Message.substr(MessageStart + 1).c_str());
ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName); ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName);
@ -1435,7 +1435,7 @@ void Client::SendChannelMessageByNumber(std::string Message) {
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s tells %s, [%s]", GetName().c_str(), RequiredChannel->GetName().c_str(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s tells %s, [%s]", GetName().c_str(), RequiredChannel->GetName().c_str(),
Message.substr(MessageStart + 1).c_str()); Message.substr(MessageStart + 1).c_str());
if(RuleB(Chat, EnableAntiSpam)) if(RuleB(Chat, EnableAntiSpam))
@ -1647,7 +1647,7 @@ void Client::SetChannelPassword(std::string ChannelPassword) {
else else
Message = "Password change on channel " + ChannelName; Message = "Password change on channel " + ChannelName;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set password of channel [%s] to [%s] by %s", ChannelName.c_str(), Password.c_str(), GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set password of channel [%s] to [%s] by %s", ChannelName.c_str(), Password.c_str(), GetName().c_str());
ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName); ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName);
@ -1702,7 +1702,7 @@ void Client::SetChannelOwner(std::string CommandString) {
if((ChannelName.length() > 0) && isdigit(ChannelName[0])) if((ChannelName.length() > 0) && isdigit(ChannelName[0]))
ChannelName = ChannelSlotName(atoi(ChannelName.c_str())); ChannelName = ChannelSlotName(atoi(ChannelName.c_str()));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set owner of channel [%s] to [%s]", ChannelName.c_str(), NewOwner.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set owner of channel [%s] to [%s]", ChannelName.c_str(), NewOwner.c_str());
ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName); ChatChannel *RequiredChannel = ChannelList->FindChannel(ChannelName);
@ -1790,7 +1790,7 @@ void Client::ChannelInvite(std::string CommandString) {
if((ChannelName.length() > 0) && isdigit(ChannelName[0])) if((ChannelName.length() > 0) && isdigit(ChannelName[0]))
ChannelName = ChannelSlotName(atoi(ChannelName.c_str())); ChannelName = ChannelSlotName(atoi(ChannelName.c_str()));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] invites [%s] to channel [%s]", GetName().c_str(), Invitee.c_str(), ChannelName.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] invites [%s] to channel [%s]", GetName().c_str(), Invitee.c_str(), ChannelName.c_str());
Client *RequiredClient = CL->FindCharacter(Invitee); Client *RequiredClient = CL->FindCharacter(Invitee);
@ -1918,7 +1918,7 @@ void Client::ChannelGrantModerator(std::string CommandString) {
if((ChannelName.length() > 0) && isdigit(ChannelName[0])) if((ChannelName.length() > 0) && isdigit(ChannelName[0]))
ChannelName = ChannelSlotName(atoi(ChannelName.c_str())); ChannelName = ChannelSlotName(atoi(ChannelName.c_str()));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] gives [%s] moderator rights to channel [%s]", GetName().c_str(), Moderator.c_str(), ChannelName.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] gives [%s] moderator rights to channel [%s]", GetName().c_str(), Moderator.c_str(), ChannelName.c_str());
Client *RequiredClient = CL->FindCharacter(Moderator); Client *RequiredClient = CL->FindCharacter(Moderator);
@ -1999,7 +1999,7 @@ void Client::ChannelGrantVoice(std::string CommandString) {
if((ChannelName.length() > 0) && isdigit(ChannelName[0])) if((ChannelName.length() > 0) && isdigit(ChannelName[0]))
ChannelName = ChannelSlotName(atoi(ChannelName.c_str())); ChannelName = ChannelSlotName(atoi(ChannelName.c_str()));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] gives [%s] voice to channel [%s]", GetName().c_str(), Voicee.c_str(), ChannelName.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] gives [%s] voice to channel [%s]", GetName().c_str(), Voicee.c_str(), ChannelName.c_str());
Client *RequiredClient = CL->FindCharacter(Voicee); Client *RequiredClient = CL->FindCharacter(Voicee);
@ -2087,7 +2087,7 @@ void Client::ChannelKick(std::string CommandString) {
if((ChannelName.length() > 0) && isdigit(ChannelName[0])) if((ChannelName.length() > 0) && isdigit(ChannelName[0]))
ChannelName = ChannelSlotName(atoi(ChannelName.c_str())); ChannelName = ChannelSlotName(atoi(ChannelName.c_str()));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] kicks [%s] from channel [%s]", GetName().c_str(), Kickee.c_str(), ChannelName.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "[%s] kicks [%s] from channel [%s]", GetName().c_str(), Kickee.c_str(), ChannelName.c_str());
Client *RequiredClient = CL->FindCharacter(Kickee); Client *RequiredClient = CL->FindCharacter(Kickee);
@ -2196,32 +2196,32 @@ void Client::SetConnectionType(char c) {
case 'S': case 'S':
{ {
TypeOfConnection = ConnectionTypeCombined; TypeOfConnection = ConnectionTypeCombined;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Combined (SoF/SoD)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Combined (SoF/SoD)");
break; break;
} }
case 'U': case 'U':
{ {
TypeOfConnection = ConnectionTypeCombined; TypeOfConnection = ConnectionTypeCombined;
UnderfootOrLater = true; UnderfootOrLater = true;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Combined (Underfoot+)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Combined (Underfoot+)");
break; break;
} }
case 'M': case 'M':
{ {
TypeOfConnection = ConnectionTypeMail; TypeOfConnection = ConnectionTypeMail;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Mail (6.2 or Titanium client)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Mail (6.2 or Titanium client)");
break; break;
} }
case 'C': case 'C':
{ {
TypeOfConnection = ConnectionTypeChat; TypeOfConnection = ConnectionTypeChat;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Chat (6.2 or Titanium client)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is Chat (6.2 or Titanium client)");
break; break;
} }
default: default:
{ {
TypeOfConnection = ConnectionTypeUnknown; TypeOfConnection = ConnectionTypeUnknown;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is unknown."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connection type is unknown.");
} }
} }
} }
@ -2299,11 +2299,11 @@ void Client::SendNotification(int MailBoxNumber, std::string Subject, std::strin
void Client::ChangeMailBox(int NewMailBox) { void Client::ChangeMailBox(int NewMailBox) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s Change to mailbox %i", MailBoxName().c_str(), NewMailBox); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "%s Change to mailbox %i", MailBoxName().c_str(), NewMailBox);
SetMailBox(NewMailBox); SetMailBox(NewMailBox);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New mailbox is %s", MailBoxName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "New mailbox is %s", MailBoxName().c_str());
auto outapp = new EQApplicationPacket(OP_MailboxChange, 2); auto outapp = new EQApplicationPacket(OP_MailboxChange, 2);
@ -2377,13 +2377,13 @@ std::string Client::MailBoxName() {
if((Characters.size() == 0) || (CurrentMailBox > (Characters.size() - 1))) if((Characters.size() == 0) || (CurrentMailBox > (Characters.size() - 1)))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailBoxName() called with CurrentMailBox set to %i and Characters.size() is %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailBoxName() called with CurrentMailBox set to %i and Characters.size() is %i",
CurrentMailBox, Characters.size()); CurrentMailBox, Characters.size());
return ""; return "";
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailBoxName() called with CurrentMailBox set to %i and Characters.size() is %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailBoxName() called with CurrentMailBox set to %i and Characters.size() is %i",
CurrentMailBox, Characters.size()); CurrentMailBox, Characters.size());
return Characters[CurrentMailBox].Name; return Characters[CurrentMailBox].Name;

86
ucs/database.cpp
View File

@ -110,15 +110,15 @@ void Database::GetAccountStatus(Client *client) {
client->GetAccountID()); client->GetAccountID());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get account status for character %s, error %s", client->GetName().c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get account status for character %s, error %s", client->GetName().c_str(), results.ErrorMessage().c_str());
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "GetAccountStatus Query: %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "GetAccountStatus Query: %s", query.c_str());
if(results.RowCount() != 1) if(results.RowCount() != 1)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error in GetAccountStatus"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error in GetAccountStatus");
return; return;
} }
@ -129,13 +129,13 @@ void Database::GetAccountStatus(Client *client) {
client->SetKarma(atoi(row[2])); client->SetKarma(atoi(row[2]));
client->SetRevoked((atoi(row[3])==1?true:false)); client->SetRevoked((atoi(row[3])==1?true:false));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set account status to %i, hideme to %i and karma to %i for %s", client->GetAccountStatus(), client->GetHideMe(), client->GetKarma(), client->GetName().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Set account status to %i, hideme to %i and karma to %i for %s", client->GetAccountStatus(), client->GetHideMe(), client->GetKarma(), client->GetName().c_str());
} }
int Database::FindAccount(const char *characterName, Client *client) { int Database::FindAccount(const char *characterName, Client *client) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindAccount for character %s", characterName); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindAccount for character %s", characterName);
client->ClearCharacters(); client->ClearCharacters();
@ -144,12 +144,12 @@ int Database::FindAccount(const char *characterName, Client *client) {
characterName); characterName);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindAccount query failed: %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindAccount query failed: %s", query.c_str());
return -1; return -1;
} }
if (results.RowCount() != 1) { if (results.RowCount() != 1) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Bad result from query"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Bad result from query");
return -1; return -1;
} }
@ -158,7 +158,7 @@ int Database::FindAccount(const char *characterName, Client *client) {
int accountID = atoi(row[1]); int accountID = atoi(row[1]);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Account ID for %s is %i", characterName, accountID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Account ID for %s is %i", characterName, accountID);
query = StringFormat("SELECT `id`, `name`, `level` FROM `character_data` " query = StringFormat("SELECT `id`, `name`, `level` FROM `character_data` "
"WHERE `account_id` = %i AND `name` != '%s'", "WHERE `account_id` = %i AND `name` != '%s'",
@ -179,7 +179,7 @@ bool Database::VerifyMailKey(std::string characterName, int IPAddress, std::stri
characterName.c_str()); characterName.c_str());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error retrieving mailkey from database: %s", results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error retrieving mailkey from database: %s", results.ErrorMessage().c_str());
return false; return false;
} }
@ -195,7 +195,7 @@ bool Database::VerifyMailKey(std::string characterName, int IPAddress, std::stri
else else
sprintf(combinedKey, "%s", MailKey.c_str()); sprintf(combinedKey, "%s", MailKey.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "DB key is [%s], Client key is [%s]", row[0], combinedKey); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "DB key is [%s], Client key is [%s]", row[0], combinedKey);
return !strcmp(row[0], combinedKey); return !strcmp(row[0], combinedKey);
} }
@ -206,14 +206,14 @@ int Database::FindCharacter(const char *characterName) {
std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name`='%s' LIMIT 1", safeCharName); std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name`='%s' LIMIT 1", safeCharName);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindCharacter failed. %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "FindCharacter failed. %s %s", query.c_str(), results.ErrorMessage().c_str());
safe_delete(safeCharName); safe_delete(safeCharName);
return -1; return -1;
} }
safe_delete(safeCharName); safe_delete(safeCharName);
if (results.RowCount() != 1) { if (results.RowCount() != 1) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Bad result from FindCharacter query for character %s", characterName); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Bad result from FindCharacter query for character %s", characterName);
return -1; return -1;
} }
@ -229,7 +229,7 @@ bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_
std::string query = StringFormat("SELECT `value` FROM `variables` WHERE `varname` = '%s'", varname); std::string query = StringFormat("SELECT `value` FROM `variables` WHERE `varname` = '%s'", varname);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get message count from database. %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get message count from database. %s %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -245,12 +245,12 @@ bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_
bool Database::LoadChatChannels() { bool Database::LoadChatChannels() {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loading chat channels from the database."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loading chat channels from the database.");
const std::string query = "SELECT `name`, `owner`, `password`, `minstatus` FROM `chatchannels`"; const std::string query = "SELECT `name`, `owner`, `password`, `minstatus` FROM `chatchannels`";
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed to load channels. %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed to load channels. %s %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
@ -267,25 +267,25 @@ bool Database::LoadChatChannels() {
void Database::SetChannelPassword(std::string channelName, std::string password) { void Database::SetChannelPassword(std::string channelName, std::string password) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Database::SetChannelPassword(%s, %s)", channelName.c_str(), password.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Database::SetChannelPassword(%s, %s)", channelName.c_str(), password.c_str());
std::string query = StringFormat("UPDATE `chatchannels` SET `password` = '%s' WHERE `name` = '%s'", std::string query = StringFormat("UPDATE `chatchannels` SET `password` = '%s' WHERE `name` = '%s'",
password.c_str(), channelName.c_str()); password.c_str(), channelName.c_str());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating password in database: %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating password in database: %s, %s", query.c_str(), results.ErrorMessage().c_str());
} }
void Database::SetChannelOwner(std::string channelName, std::string owner) { void Database::SetChannelOwner(std::string channelName, std::string owner) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Database::SetChannelOwner(%s, %s)", channelName.c_str(), owner.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Database::SetChannelOwner(%s, %s)", channelName.c_str(), owner.c_str());
std::string query = StringFormat("UPDATE `chatchannels` SET `owner` = '%s' WHERE `name` = '%s'", std::string query = StringFormat("UPDATE `chatchannels` SET `owner` = '%s' WHERE `name` = '%s'",
owner.c_str(), channelName.c_str()); owner.c_str(), channelName.c_str());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating Owner in database: %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating Owner in database: %s, %s", query.c_str(), results.ErrorMessage().c_str());
} }
@ -295,7 +295,7 @@ void Database::SendHeaders(Client *client) {
int unknownField3 = 1; int unknownField3 = 1;
int characterID = FindCharacter(client->MailBoxName().c_str()); int characterID = FindCharacter(client->MailBoxName().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Sendheaders for %s, CharID is %i", client->MailBoxName().c_str(), characterID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Sendheaders for %s, CharID is %i", client->MailBoxName().c_str(), characterID);
if(characterID <= 0) if(characterID <= 0)
return; return;
@ -382,7 +382,7 @@ void Database::SendBody(Client *client, int messageNumber) {
int characterID = FindCharacter(client->MailBoxName().c_str()); int characterID = FindCharacter(client->MailBoxName().c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendBody: MsgID %i, to %s, CharID is %i", messageNumber, client->MailBoxName().c_str(), characterID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendBody: MsgID %i, to %s, CharID is %i", messageNumber, client->MailBoxName().c_str(), characterID);
if(characterID <= 0) if(characterID <= 0)
return; return;
@ -399,7 +399,7 @@ void Database::SendBody(Client *client, int messageNumber) {
auto row = results.begin(); auto row = results.begin();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Message: %i body (%i bytes)", messageNumber, strlen(row[1])); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Message: %i body (%i bytes)", messageNumber, strlen(row[1]));
int packetLength = 12 + strlen(row[0]) + strlen(row[1]) + strlen(row[2]); int packetLength = 12 + strlen(row[0]) + strlen(row[1]) + strlen(row[2]);
@ -445,7 +445,7 @@ bool Database::SendMail(std::string recipient, std::string from, std::string sub
characterID = FindCharacter(characterName.c_str()); characterID = FindCharacter(characterName.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendMail: CharacterID for recipient %s is %i", characterName.c_str(), characterID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendMail: CharacterID for recipient %s is %i", characterName.c_str(), characterID);
if(characterID <= 0) if(characterID <= 0)
return false; return false;
@ -467,11 +467,11 @@ bool Database::SendMail(std::string recipient, std::string from, std::string sub
safe_delete_array(escBody); safe_delete_array(escBody);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendMail: Query %s failed with error %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SendMail: Query %s failed with error %s", query.c_str(), results.ErrorMessage().c_str());
return false; return false;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MessageID %i generated, from %s, to %s", results.LastInsertedID(), from.c_str(), recipient.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MessageID %i generated, from %s, to %s", results.LastInsertedID(), from.c_str(), recipient.c_str());
Client *client = CL->IsCharacterOnline(characterName); Client *client = CL->IsCharacterOnline(characterName);
@ -488,7 +488,7 @@ bool Database::SendMail(std::string recipient, std::string from, std::string sub
void Database::SetMessageStatus(int messageNumber, int status) { void Database::SetMessageStatus(int messageNumber, int status) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SetMessageStatus %i %i", messageNumber, status); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "SetMessageStatus %i %i", messageNumber, status);
if(status == 0) { if(status == 0) {
std::string query = StringFormat("DELETE FROM `mail` WHERE `msgid` = %i", messageNumber); std::string query = StringFormat("DELETE FROM `mail` WHERE `msgid` = %i", messageNumber);
@ -499,24 +499,24 @@ void Database::SetMessageStatus(int messageNumber, int status) {
std::string query = StringFormat("UPDATE `mail` SET `status` = %i WHERE `msgid`=%i", status, messageNumber); std::string query = StringFormat("UPDATE `mail` SET `status` = %i WHERE `msgid`=%i", status, messageNumber);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) if (!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating status %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error updating status %s, %s", query.c_str(), results.ErrorMessage().c_str());
} }
void Database::ExpireMail() { void Database::ExpireMail() {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expiring mail..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expiring mail...");
std::string query = "SELECT COUNT(*) FROM `mail`"; std::string query = "SELECT COUNT(*) FROM `mail`";
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get message count from database. %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unable to get message count from database. %s %s", query.c_str(), results.ErrorMessage().c_str());
return; return;
} }
auto row = results.begin(); auto row = results.begin();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "There are %s messages in the database.", row[0]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "There are %s messages in the database.", row[0]);
// Expire Trash // Expire Trash
if(RuleI(Mail, ExpireTrash) >= 0) { if(RuleI(Mail, ExpireTrash) >= 0) {
@ -524,9 +524,9 @@ void Database::ExpireMail() {
time(nullptr) - RuleI(Mail, ExpireTrash)); time(nullptr) - RuleI(Mail, ExpireTrash));
results = QueryDatabase(query); results = QueryDatabase(query);
if(results.Success()) if(results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i trash messages.", results.RowsAffected()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i trash messages.", results.RowsAffected());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring trash messages, %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring trash messages, %s %s", query.c_str(), results.ErrorMessage().c_str());
} }
@ -536,9 +536,9 @@ void Database::ExpireMail() {
time(nullptr) - RuleI(Mail, ExpireRead)); time(nullptr) - RuleI(Mail, ExpireRead));
results = QueryDatabase(query); results = QueryDatabase(query);
if(results.Success()) if(results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i read messages.", results.RowsAffected()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i read messages.", results.RowsAffected());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring read messages, %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring read messages, %s %s", query.c_str(), results.ErrorMessage().c_str());
} }
// Expire Unread // Expire Unread
@ -547,9 +547,9 @@ void Database::ExpireMail() {
time(nullptr) - RuleI(Mail, ExpireUnread)); time(nullptr) - RuleI(Mail, ExpireUnread));
results = QueryDatabase(query); results = QueryDatabase(query);
if(results.Success()) if(results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i unread messages.", results.RowsAffected()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Expired %i unread messages.", results.RowsAffected());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring unread messages, %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error expiring unread messages, %s %s", query.c_str(), results.ErrorMessage().c_str());
} }
} }
@ -560,9 +560,9 @@ void Database::AddFriendOrIgnore(int charID, int type, std::string name) {
charID, type, CapitaliseName(name).c_str()); charID, type, CapitaliseName(name).c_str());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error adding friend/ignore, query was %s : %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error adding friend/ignore, query was %s : %s", query.c_str(), results.ErrorMessage().c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Wrote Friend/Ignore entry for charid %i, type %i, name %s to database.", charID, type, name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Wrote Friend/Ignore entry for charid %i, type %i, name %s to database.", charID, type, name.c_str());
} }
@ -573,9 +573,9 @@ void Database::RemoveFriendOrIgnore(int charID, int type, std::string name) {
charID, type, CapitaliseName(name).c_str()); charID, type, CapitaliseName(name).c_str());
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error removing friend/ignore, query was %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Error removing friend/ignore, query was %s", query.c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed Friend/Ignore entry for charid %i, type %i, name %s from database.", charID, type, name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Removed Friend/Ignore entry for charid %i, type %i, name %s from database.", charID, type, name.c_str());
} }
@ -584,7 +584,7 @@ void Database::GetFriendsAndIgnore(int charID, std::vector<std::string> &friends
std::string query = StringFormat("select `type`, `name` FROM `friends` WHERE `charid`=%i", charID); std::string query = StringFormat("select `type`, `name` FROM `friends` WHERE `charid`=%i", charID);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "GetFriendsAndIgnore query error %s, %s", query.c_str(), results.ErrorMessage().c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "GetFriendsAndIgnore query error %s, %s", query.c_str(), results.ErrorMessage().c_str());
return; return;
} }
@ -595,12 +595,12 @@ void Database::GetFriendsAndIgnore(int charID, std::vector<std::string> &friends
if(atoi(row[0]) == 0) if(atoi(row[0]) == 0)
{ {
ignorees.push_back(name); ignorees.push_back(name);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Ignoree from DB %s", name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Ignoree from DB %s", name.c_str());
continue; continue;
} }
friends.push_back(name); friends.push_back(name);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Friend from DB %s", name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Added Friend from DB %s", name.c_str());
} }
} }

26
ucs/ucs.cpp
View File

@ -78,11 +78,11 @@ int main() {
Timer InterserverTimer(INTERSERVER_TIMER); // does auto-reconnect Timer InterserverTimer(INTERSERVER_TIMER); // does auto-reconnect
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Starting EQEmu Universal Chat Server."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Starting EQEmu Universal Chat Server.");
if (!ucsconfig::LoadConfig()) { if (!ucsconfig::LoadConfig()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loading server configuration failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loading server configuration failed.");
return 1; return 1;
} }
@ -90,13 +90,13 @@ int main() {
Config = ucsconfig::get(); Config = ucsconfig::get();
if(!load_log_settings(Config->LogSettingsFile.c_str())) if(!load_log_settings(Config->LogSettingsFile.c_str()))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str());
WorldShortName = Config->ShortName; WorldShortName = Config->ShortName;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connecting to MySQL..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connecting to MySQL...");
if (!database.Connect( if (!database.Connect(
Config->DatabaseHost.c_str(), Config->DatabaseHost.c_str(),
@ -104,22 +104,22 @@ int main() {
Config->DatabasePassword.c_str(), Config->DatabasePassword.c_str(),
Config->DatabaseDB.c_str(), Config->DatabaseDB.c_str(),
Config->DatabasePort)) { Config->DatabasePort)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection.");
return 1; return 1;
} }
char tmp[64]; char tmp[64];
if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) { if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading rule set '%s'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading rule set '%s'", tmp);
if(!RuleManager::Instance()->LoadRules(&database, tmp)) { if(!RuleManager::Instance()->LoadRules(&database, tmp)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed to load ruleset '%s', falling back to defaults.", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Failed to load ruleset '%s', falling back to defaults.", tmp);
} }
} else { } else {
if(!RuleManager::Instance()->LoadRules(&database, "default")) { if(!RuleManager::Instance()->LoadRules(&database, "default")) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "No rule set configured, using default rules"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "No rule set configured, using default rules");
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loaded default rule set 'default'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Loaded default rule set 'default'", tmp);
} }
} }
@ -127,7 +127,7 @@ int main() {
if(Config->ChatPort != Config->MailPort) if(Config->ChatPort != Config->MailPort)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailPort and CharPort must be the same in eqemu_config.xml for UCS."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "MailPort and CharPort must be the same in eqemu_config.xml for UCS.");
exit(1); exit(1);
} }
@ -138,11 +138,11 @@ int main() {
database.LoadChatChannels(); database.LoadChatChannels();
if (signal(SIGINT, CatchSignal) == SIG_ERR) { if (signal(SIGINT, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Could not set signal handler");
return 1; return 1;
} }
if (signal(SIGTERM, CatchSignal) == SIG_ERR) { if (signal(SIGTERM, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Could not set signal handler");
return 1; return 1;
} }

8
ucs/worldserver.cpp
View File

@ -52,7 +52,7 @@ WorldServer::~WorldServer()
void WorldServer::OnConnected() void WorldServer::OnConnected()
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connected to World."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Connected to World.");
WorldConnection::OnConnected(); WorldConnection::OnConnected();
} }
@ -67,7 +67,7 @@ void WorldServer::Process()
while((pack = tcpc.PopPacket())) while((pack = tcpc.PopPacket()))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received Opcode: %4X", pack->opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Received Opcode: %4X", pack->opcode);
switch(pack->opcode) switch(pack->opcode)
{ {
@ -88,7 +88,7 @@ void WorldServer::Process()
std::string Message = Buffer; std::string Message = Buffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Player: %s, Sent Message: %s", From, Message.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Player: %s, Sent Message: %s", From, Message.c_str());
Client *c = CL->FindCharacter(From); Client *c = CL->FindCharacter(From);
@ -99,7 +99,7 @@ void WorldServer::Process()
if(!c) if(!c)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client not found."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Client not found.");
break; break;
} }

48
world/client.cpp
View File

@ -1519,7 +1519,7 @@ bool CheckCharCreateInfoSoF(CharCreate_Struct *cc)
if (!cc) if (!cc)
return false; return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Validating char creation info..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Validating char creation info...");
RaceClassCombos class_combo; RaceClassCombos class_combo;
bool found = false; bool found = false;
@ -1536,7 +1536,7 @@ bool CheckCharCreateInfoSoF(CharCreate_Struct *cc)
} }
if (!found) { if (!found) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not find class/race/deity/start_zone combination"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not find class/race/deity/start_zone combination");
return false; return false;
} }
@ -1553,7 +1553,7 @@ bool CheckCharCreateInfoSoF(CharCreate_Struct *cc)
} }
if (!found) { if (!found) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not find starting stats for selected character combo, cannot verify stats"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not find starting stats for selected character combo, cannot verify stats");
return false; return false;
} }
@ -1566,37 +1566,37 @@ bool CheckCharCreateInfoSoF(CharCreate_Struct *cc)
allocation.DefaultPointAllocation[6]; allocation.DefaultPointAllocation[6];
if (cc->STR > allocation.BaseStats[0] + max_stats || cc->STR < allocation.BaseStats[0]) { if (cc->STR > allocation.BaseStats[0] + max_stats || cc->STR < allocation.BaseStats[0]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Strength out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Strength out of range");
return false; return false;
} }
if (cc->DEX > allocation.BaseStats[1] + max_stats || cc->DEX < allocation.BaseStats[1]) { if (cc->DEX > allocation.BaseStats[1] + max_stats || cc->DEX < allocation.BaseStats[1]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Dexterity out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Dexterity out of range");
return false; return false;
} }
if (cc->AGI > allocation.BaseStats[2] + max_stats || cc->AGI < allocation.BaseStats[2]) { if (cc->AGI > allocation.BaseStats[2] + max_stats || cc->AGI < allocation.BaseStats[2]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Agility out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Agility out of range");
return false; return false;
} }
if (cc->STA > allocation.BaseStats[3] + max_stats || cc->STA < allocation.BaseStats[3]) { if (cc->STA > allocation.BaseStats[3] + max_stats || cc->STA < allocation.BaseStats[3]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Stamina out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Stamina out of range");
return false; return false;
} }
if (cc->INT > allocation.BaseStats[4] + max_stats || cc->INT < allocation.BaseStats[4]) { if (cc->INT > allocation.BaseStats[4] + max_stats || cc->INT < allocation.BaseStats[4]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Intelligence out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Intelligence out of range");
return false; return false;
} }
if (cc->WIS > allocation.BaseStats[5] + max_stats || cc->WIS < allocation.BaseStats[5]) { if (cc->WIS > allocation.BaseStats[5] + max_stats || cc->WIS < allocation.BaseStats[5]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Wisdom out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Wisdom out of range");
return false; return false;
} }
if (cc->CHA > allocation.BaseStats[6] + max_stats || cc->CHA < allocation.BaseStats[6]) { if (cc->CHA > allocation.BaseStats[6] + max_stats || cc->CHA < allocation.BaseStats[6]) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Charisma out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Charisma out of range");
return false; return false;
} }
@ -1609,7 +1609,7 @@ bool CheckCharCreateInfoSoF(CharCreate_Struct *cc)
current_stats += cc->WIS - allocation.BaseStats[5]; current_stats += cc->WIS - allocation.BaseStats[5];
current_stats += cc->CHA - allocation.BaseStats[6]; current_stats += cc->CHA - allocation.BaseStats[6];
if (current_stats > max_stats) { if (current_stats > max_stats) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Current Stats > Maximum Stats"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Current Stats > Maximum Stats");
return false; return false;
} }
@ -1690,7 +1690,7 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
if (!cc) if (!cc)
return false; return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Validating char creation info..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Validating char creation info...");
classtemp = cc->class_ - 1; classtemp = cc->class_ - 1;
racetemp = cc->race - 1; racetemp = cc->race - 1;
@ -1703,16 +1703,16 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
// if out of range looking it up in the table would crash stuff // if out of range looking it up in the table would crash stuff
// so we return from these // so we return from these
if (classtemp >= PLAYER_CLASS_COUNT) { if (classtemp >= PLAYER_CLASS_COUNT) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," class is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," class is out of range");
return false; return false;
} }
if (racetemp >= _TABLE_RACES) { if (racetemp >= _TABLE_RACES) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," race is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," race is out of range");
return false; return false;
} }
if (!ClassRaceLookupTable[classtemp][racetemp]) { //Lookup table better than a bunch of ifs? if (!ClassRaceLookupTable[classtemp][racetemp]) { //Lookup table better than a bunch of ifs?
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," invalid race/class combination"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," invalid race/class combination");
// we return from this one, since if it's an invalid combination our table // we return from this one, since if it's an invalid combination our table
// doesn't have meaningful values for the stats // doesn't have meaningful values for the stats
return false; return false;
@ -1740,43 +1740,43 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
// that are messed up not just the first hit // that are messed up not just the first hit
if (bTOTAL + stat_points != cTOTAL) { if (bTOTAL + stat_points != cTOTAL) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat points total doesn't match expected value: expecting %d got %d", bTOTAL + stat_points, cTOTAL); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat points total doesn't match expected value: expecting %d got %d", bTOTAL + stat_points, cTOTAL);
Charerrors++; Charerrors++;
} }
if (cc->STR > bSTR + stat_points || cc->STR < bSTR) { if (cc->STR > bSTR + stat_points || cc->STR < bSTR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat STR is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat STR is out of range");
Charerrors++; Charerrors++;
} }
if (cc->STA > bSTA + stat_points || cc->STA < bSTA) { if (cc->STA > bSTA + stat_points || cc->STA < bSTA) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat STA is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat STA is out of range");
Charerrors++; Charerrors++;
} }
if (cc->AGI > bAGI + stat_points || cc->AGI < bAGI) { if (cc->AGI > bAGI + stat_points || cc->AGI < bAGI) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat AGI is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat AGI is out of range");
Charerrors++; Charerrors++;
} }
if (cc->DEX > bDEX + stat_points || cc->DEX < bDEX) { if (cc->DEX > bDEX + stat_points || cc->DEX < bDEX) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat DEX is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat DEX is out of range");
Charerrors++; Charerrors++;
} }
if (cc->WIS > bWIS + stat_points || cc->WIS < bWIS) { if (cc->WIS > bWIS + stat_points || cc->WIS < bWIS) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat WIS is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat WIS is out of range");
Charerrors++; Charerrors++;
} }
if (cc->INT > bINT + stat_points || cc->INT < bINT) { if (cc->INT > bINT + stat_points || cc->INT < bINT) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat INT is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat INT is out of range");
Charerrors++; Charerrors++;
} }
if (cc->CHA > bCHA + stat_points || cc->CHA < bCHA) { if (cc->CHA > bCHA + stat_points || cc->CHA < bCHA) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat CHA is out of range"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," stat CHA is out of range");
Charerrors++; Charerrors++;
} }
/*TODO: Check for deity/class/race.. it'd be nice, but probably of any real use to hack(faction, deity based items are all I can think of) /*TODO: Check for deity/class/race.. it'd be nice, but probably of any real use to hack(faction, deity based items are all I can think of)
I am NOT writing those tables - kathgar*/ I am NOT writing those tables - kathgar*/
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Found %d errors in character creation request", Charerrors); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Found %d errors in character creation request", Charerrors);
return Charerrors == 0; return Charerrors == 0;
} }

2
world/cliententry.cpp
View File

@ -267,7 +267,7 @@ bool ClientListEntry::CheckAuth(uint32 iLSID, const char* iKey) {
int16 tmpStatus = WorldConfig::get()->DefaultStatus; int16 tmpStatus = WorldConfig::get()->DefaultStatus;
paccountid = database.CreateAccount(plsname, 0, tmpStatus, LSID()); paccountid = database.CreateAccount(plsname, 0, tmpStatus, LSID());
if (!paccountid) { if (!paccountid) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Error adding local account for LS login: '%s', duplicate name?" ,plsname); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Error adding local account for LS login: '%s', duplicate name?" ,plsname);
return false; return false;
} }
strn0cpy(paccountname, plsname, sizeof(paccountname)); strn0cpy(paccountname, plsname, sizeof(paccountname));

12
world/clientlist.cpp
View File

@ -56,7 +56,7 @@ void ClientList::Process() {
if (!iterator.GetData()->Process()) { if (!iterator.GetData()->Process()) {
struct in_addr in; struct in_addr in;
in.s_addr = iterator.GetData()->GetIP(); in.s_addr = iterator.GetData()->GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing client from %s:%d", inet_ntoa(in), iterator.GetData()->GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing client from %s:%d", inet_ntoa(in), iterator.GetData()->GetPort());
//the client destructor should take care of this. //the client destructor should take care of this.
// iterator.GetData()->Free(); // iterator.GetData()->Free();
iterator.RemoveCurrent(); iterator.RemoveCurrent();
@ -447,7 +447,7 @@ void ClientList::SendOnlineGuildMembers(uint32 FromID, uint32 GuildID)
if(!from) if(!from)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Invalid client. FromID=%i GuildID=%i", FromID, GuildID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Invalid client. FromID=%i GuildID=%i", FromID, GuildID);
return; return;
} }
@ -751,7 +751,7 @@ void ClientList::SendWhoAll(uint32 fromid,const char* to, int16 admin, Who_All_S
safe_delete(output); safe_delete(output);
} }
catch(...){ catch(...){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unknown error in world's SendWhoAll (probably mem error), ignoring..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unknown error in world's SendWhoAll (probably mem error), ignoring...");
return; return;
} }
} }
@ -895,7 +895,7 @@ void ClientList::SendFriendsWho(ServerFriendsWho_Struct *FriendsWho, WorldTCPCon
safe_delete(pack2); safe_delete(pack2);
} }
catch(...){ catch(...){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unknown error in world's SendFriendsWho (probably mem error), ignoring..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unknown error in world's SendFriendsWho (probably mem error), ignoring...");
return; return;
} }
} }
@ -1130,7 +1130,7 @@ Client* ClientList::FindByAccountID(uint32 account_id) {
iterator.Reset(); iterator.Reset();
while(iterator.MoreElements()) { while(iterator.MoreElements()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "ClientList[0x%08x]::FindByAccountID(%p) iterator.GetData()[%p]", this, account_id, iterator.GetData()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "ClientList[0x%08x]::FindByAccountID(%p) iterator.GetData()[%p]", this, account_id, iterator.GetData());
if (iterator.GetData()->GetAccountID() == account_id) { if (iterator.GetData()->GetAccountID() == account_id) {
Client* tmp = iterator.GetData(); Client* tmp = iterator.GetData();
return tmp; return tmp;
@ -1145,7 +1145,7 @@ Client* ClientList::FindByName(char* charname) {
iterator.Reset(); iterator.Reset();
while(iterator.MoreElements()) { while(iterator.MoreElements()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "ClientList[0x%08x]::FindByName(\"%s\") iterator.GetData()[%p]", this, charname, iterator.GetData()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "ClientList[0x%08x]::FindByName(\"%s\") iterator.GetData()[%p]", this, charname, iterator.GetData());
if (iterator.GetData()->GetCharName() == charname) { if (iterator.GetData()->GetCharName() == charname) {
Client* tmp = iterator.GetData(); Client* tmp = iterator.GetData();
return tmp; return tmp;

24
world/console.cpp
View File

@ -88,7 +88,7 @@ void Console::Die() {
state = CONSOLE_STATE_CLOSED; state = CONSOLE_STATE_CLOSED;
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing console from %s:%d",inet_ntoa(in),GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing console from %s:%d",inet_ntoa(in),GetPort());
tcpc->Disconnect(); tcpc->Disconnect();
} }
@ -219,7 +219,7 @@ bool Console::Process() {
if (!tcpc->Connected()) { if (!tcpc->Connected()) {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing console (!tcpc->Connected) from %s:%d",inet_ntoa(in),GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing console (!tcpc->Connected) from %s:%d",inet_ntoa(in),GetPort());
return false; return false;
} }
//if we have not gotten the special markers after this timer, send login prompt //if we have not gotten the special markers after this timer, send login prompt
@ -234,7 +234,7 @@ bool Console::Process() {
SendMessage(1, "Timeout, disconnecting..."); SendMessage(1, "Timeout, disconnecting...");
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP connection timeout from %s:%d",inet_ntoa(in),GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP connection timeout from %s:%d",inet_ntoa(in),GetPort());
return false; return false;
} }
@ -243,29 +243,29 @@ bool Console::Process() {
in.s_addr = GetIP(); in.s_addr = GetIP();
if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeZone) { if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeZone) {
auto zs = new ZoneServer(tcpc); auto zs = new ZoneServer(tcpc);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New zoneserver #%d from %s:%d", zs->GetID(), inet_ntoa(in), GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New zoneserver #%d from %s:%d", zs->GetID(), inet_ntoa(in), GetPort());
zoneserver_list.Add(zs); zoneserver_list.Add(zs);
numzones++; numzones++;
tcpc = 0; tcpc = 0;
} else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeLauncher) { } else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeLauncher) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New launcher from %s:%d", inet_ntoa(in), GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New launcher from %s:%d", inet_ntoa(in), GetPort());
launcher_list.Add(tcpc); launcher_list.Add(tcpc);
tcpc = 0; tcpc = 0;
} }
else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeUCS) else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeUCS)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New UCS Connection from %s:%d", inet_ntoa(in), GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New UCS Connection from %s:%d", inet_ntoa(in), GetPort());
UCSLink.SetConnection(tcpc); UCSLink.SetConnection(tcpc);
tcpc = 0; tcpc = 0;
} }
else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeQueryServ) else if(tcpc->GetPacketMode() == EmuTCPConnection::packetModeQueryServ)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New QS Connection from %s:%d", inet_ntoa(in), GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"New QS Connection from %s:%d", inet_ntoa(in), GetPort());
QSLink.SetConnection(tcpc); QSLink.SetConnection(tcpc);
tcpc = 0; tcpc = 0;
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unsupported packet mode from %s:%d", inet_ntoa(in), GetPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Unsupported packet mode from %s:%d", inet_ntoa(in), GetPort());
} }
return false; return false;
} }
@ -422,7 +422,7 @@ void Console::ProcessCommand(const char* command) {
state = CONSOLE_STATE_CLOSED; state = CONSOLE_STATE_CLOSED;
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP console authenticated: Username=%s, Admin=%d",paccountname,admin); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP console authenticated: Username=%s, Admin=%d",paccountname,admin);
SendMessage(1, 0); SendMessage(1, 0);
SendMessage(2, "Login accepted."); SendMessage(2, "Login accepted.");
state = CONSOLE_STATE_CONNECTED; state = CONSOLE_STATE_CONNECTED;
@ -431,7 +431,7 @@ void Console::ProcessCommand(const char* command) {
break; break;
} }
case CONSOLE_STATE_CONNECTED: { case CONSOLE_STATE_CONNECTED: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP command: %s: \"%s\"",paccountname,command); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"TCP command: %s: \"%s\"",paccountname,command);
Seperator sep(command); Seperator sep(command);
if (strcasecmp(sep.arg[0], "help") == 0 || strcmp(sep.arg[0], "?") == 0) { if (strcasecmp(sep.arg[0], "help") == 0 || strcmp(sep.arg[0], "?") == 0) {
SendMessage(1, " whoami"); SendMessage(1, " whoami");
@ -719,7 +719,7 @@ void Console::ProcessCommand(const char* command) {
tmpname[0] = '*'; tmpname[0] = '*';
strcpy(&tmpname[1], paccountname); strcpy(&tmpname[1], paccountname);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Console ZoneBootup: %s, %s, %s",tmpname,sep.arg[2],sep.arg[1]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Console ZoneBootup: %s, %s, %s",tmpname,sep.arg[2],sep.arg[1]);
zoneserver_list.SOPZoneBootup(tmpname, atoi(sep.arg[1]), sep.arg[2], (bool) (strcasecmp(sep.arg[3], "static") == 0)); zoneserver_list.SOPZoneBootup(tmpname, atoi(sep.arg[1]), sep.arg[2], (bool) (strcasecmp(sep.arg[3], "static") == 0));
} }
} }
@ -803,7 +803,7 @@ void Console::ProcessCommand(const char* command) {
#endif #endif
RunLoops = true; RunLoops = true;
SendMessage(1, " Login Server Reconnect manually restarted by Console"); SendMessage(1, " Login Server Reconnect manually restarted by Console");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Login Server Reconnect manually restarted by Console"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Login Server Reconnect manually restarted by Console");
} }
else if (strcasecmp(sep.arg[0], "zonelock") == 0 && admin >= consoleZoneStatus) { else if (strcasecmp(sep.arg[0], "zonelock") == 0 && admin >= consoleZoneStatus) {
if (strcasecmp(sep.arg[1], "list") == 0) { if (strcasecmp(sep.arg[1], "list") == 0) {

2
world/eqw.cpp
View File

@ -269,7 +269,7 @@ void EQW::LSReconnect() {
pthread_create(&thread, nullptr, &AutoInitLoginServer, nullptr); pthread_create(&thread, nullptr, &AutoInitLoginServer, nullptr);
#endif #endif
RunLoops = true; RunLoops = true;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Login Server Reconnect manually restarted by Web Tool"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Login Server Reconnect manually restarted by Web Tool");
} }
/*EQLConfig * EQW::FindLauncher(Const_char *zone_ref) { /*EQLConfig * EQW::FindLauncher(Const_char *zone_ref) {

14
world/eqw_http_handler.cpp
View File

@ -139,11 +139,11 @@ bool EQWHTTPHandler::CheckAuth() const {
int16 status = 0; int16 status = 0;
uint32 acctid = database.CheckLogin(m_username.c_str(), m_password.c_str(), &status); uint32 acctid = database.CheckLogin(m_username.c_str(), m_password.c_str(), &status);
if(acctid == 0) { if(acctid == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login autentication failed for %s with '%s'", m_username.c_str(), m_password.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login autentication failed for %s with '%s'", m_username.c_str(), m_password.c_str());
return(false); return(false);
} }
if(status < httpLoginStatus) { if(status < httpLoginStatus) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login of %s failed: status too low.", m_username.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login of %s failed: status too low.", m_username.c_str());
return(false); return(false);
} }
@ -278,29 +278,29 @@ void EQWHTTPServer::CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP
} }
void EQWHTTPServer::Stop() { void EQWHTTPServer::Stop() {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Requesting that HTTP Service stop."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Requesting that HTTP Service stop.");
m_running = false; m_running = false;
Close(); Close();
} }
bool EQWHTTPServer::Start(uint16 port, const char *mime_file) { bool EQWHTTPServer::Start(uint16 port, const char *mime_file) {
if(m_running) { if(m_running) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "HTTP Service is already running on port %d", m_port); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "HTTP Service is already running on port %d", m_port);
return(false); return(false);
} }
//load up our nice mime types //load up our nice mime types
if(!EQWHTTPHandler::LoadMimeTypes(mime_file)) { if(!EQWHTTPHandler::LoadMimeTypes(mime_file)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Failed to load mime types from '%s'", mime_file); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Failed to load mime types from '%s'", mime_file);
return(false); return(false);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loaded mime types from %s", mime_file); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loaded mime types from %s", mime_file);
} }
//fire up the server thread //fire up the server thread
char errbuf[TCPServer_ErrorBufferSize]; char errbuf[TCPServer_ErrorBufferSize];
if(!Open(port, errbuf)) { if(!Open(port, errbuf)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to bind to port %d for HTTP service: %s", port, errbuf); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to bind to port %d for HTTP service: %s", port, errbuf);
return(false); return(false);
} }

6
world/eqw_parser.cpp
View File

@ -65,7 +65,7 @@ EQWParser::EQWParser() {
my_perl = perl_alloc(); my_perl = perl_alloc();
_empty_sv = newSV(0); _empty_sv = newSV(0);
if(!my_perl) if(!my_perl)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: perl_alloc failed!"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: perl_alloc failed!");
else else
DoInit(); DoInit();
} }
@ -182,10 +182,10 @@ void EQWParser::DoInit() {
#ifdef EMBPERL_PLUGIN #ifdef EMBPERL_PLUGIN
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading worldui perl plugins."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading worldui perl plugins.");
std::string err; std::string err;
if(!eval_file("world", "worldui.pl", err)) { if(!eval_file("world", "worldui.pl", err)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Warning - world.pl: %s", err.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Warning - world.pl: %s", err.c_str());
} }
eval_pv( eval_pv(

24
world/launcher_link.cpp
View File

@ -79,7 +79,7 @@ bool LauncherLink::Process() {
else { else {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -90,7 +90,7 @@ bool LauncherLink::Process() {
else { else {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -100,7 +100,7 @@ bool LauncherLink::Process() {
} }
else else
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access.");
authenticated = true; authenticated = true;
} }
delete pack; delete pack;
@ -114,25 +114,25 @@ bool LauncherLink::Process() {
break; break;
} }
case ServerOP_ZAAuth: { case ServerOP_ZAAuth: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Got authentication from %s when they are already authenticated.", m_name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Got authentication from %s when they are already authenticated.", m_name.c_str());
break; break;
} }
case ServerOP_LauncherConnectInfo: { case ServerOP_LauncherConnectInfo: {
const LauncherConnectInfo *it = (const LauncherConnectInfo *) pack->pBuffer; const LauncherConnectInfo *it = (const LauncherConnectInfo *) pack->pBuffer;
if(HasName()) { if(HasName()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher '%s' received an additional connect packet with name '%s'. Ignoring.", m_name.c_str(), it->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher '%s' received an additional connect packet with name '%s'. Ignoring.", m_name.c_str(), it->name);
break; break;
} }
m_name = it->name; m_name = it->name;
EQLConfig *config = launcher_list.GetConfig(m_name.c_str()); EQLConfig *config = launcher_list.GetConfig(m_name.c_str());
if(config == nullptr) { if(config == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown launcher '%s' connected. Disconnecting.", it->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown launcher '%s' connected. Disconnecting.", it->name);
Disconnect(); Disconnect();
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher Identified itself as '%s'. Loading zone list.", it->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Launcher Identified itself as '%s'. Loading zone list.", it->name);
std::vector<LauncherZone> result; std::vector<LauncherZone> result;
//database.GetLauncherZones(it->name, result); //database.GetLauncherZones(it->name, result);
@ -146,7 +146,7 @@ bool LauncherLink::Process() {
zs.port = cur->port; zs.port = cur->port;
zs.up = false; zs.up = false;
zs.starts = 0; zs.starts = 0;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: Loaded zone '%s' on port %d", m_name.c_str(), cur->name.c_str(), zs.port); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: Loaded zone '%s' on port %d", m_name.c_str(), cur->name.c_str(), zs.port);
m_states[cur->name] = zs; m_states[cur->name] = zs;
} }
@ -162,17 +162,17 @@ bool LauncherLink::Process() {
std::map<std::string, ZoneState>::iterator res; std::map<std::string, ZoneState>::iterator res;
res = m_states.find(it->short_name); res = m_states.find(it->short_name);
if(res == m_states.end()) { if(res == m_states.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: reported state for zone %s which it does not have.", m_name.c_str(), it->short_name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: reported state for zone %s which it does not have.", m_name.c_str(), it->short_name);
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: %s reported state %s (%d starts)", m_name.c_str(), it->short_name, it->running?"STARTED":"STOPPED", it->start_count); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: %s reported state %s (%d starts)", m_name.c_str(), it->short_name, it->running?"STARTED":"STOPPED", it->start_count);
res->second.up = it->running; res->second.up = it->running;
res->second.starts = it->start_count; res->second.starts = it->start_count;
break; break;
} }
default: default:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown ServerOPcode from launcher 0x%04x, size %d",pack->opcode,pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown ServerOPcode from launcher 0x%04x, size %d",pack->opcode,pack->size);
DumpPacket(pack->pBuffer, pack->size); DumpPacket(pack->pBuffer, pack->size);
break; break;
} }
@ -200,7 +200,7 @@ void LauncherLink::BootZone(const char *short_name, uint16 port) {
zs.port = port; zs.port = port;
zs.up = false; zs.up = false;
zs.starts = 0; zs.starts = 0;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: Loaded zone '%s' on port %d", m_name.c_str(), short_name, zs.port); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "%s: Loaded zone '%s' on port %d", m_name.c_str(), short_name, zs.port);
m_states[short_name] = zs; m_states[short_name] = zs;
StartZone(short_name); StartZone(short_name);

10
world/launcher_list.cpp
View File

@ -60,7 +60,7 @@ void LauncherList::Process() {
//printf("ProcP %d: %p\n", l->GetID(), l); //printf("ProcP %d: %p\n", l->GetID(), l);
if(!l->Process()) { if(!l->Process()) {
//launcher has died before it identified itself. //launcher has died before it identified itself.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing pending launcher %d", l->GetID()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing pending launcher %d", l->GetID());
cur = m_pendingLaunchers.erase(cur); cur = m_pendingLaunchers.erase(cur);
delete l; delete l;
} else if(l->HasName()) { } else if(l->HasName()) {
@ -72,10 +72,10 @@ void LauncherList::Process() {
std::map<std::string, LauncherLink *>::iterator res; std::map<std::string, LauncherLink *>::iterator res;
res = m_launchers.find(name); res = m_launchers.find(name);
if(res != m_launchers.end()) { if(res != m_launchers.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Ghosting launcher %s", name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Ghosting launcher %s", name.c_str());
delete res->second; delete res->second;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing pending launcher %d. Adding %s to active list.", l->GetID(), name.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing pending launcher %d. Adding %s to active list.", l->GetID(), name.c_str());
//put the launcher in the list. //put the launcher in the list.
m_launchers[name] = l; m_launchers[name] = l;
} else { } else {
@ -91,7 +91,7 @@ void LauncherList::Process() {
//printf("Proc %s(%d): %p\n", l->GetName(), l->GetID(), l); //printf("Proc %s(%d): %p\n", l->GetName(), l->GetID(), l);
if(!l->Process()) { if(!l->Process()) {
//launcher has died before it identified itself. //launcher has died before it identified itself.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing launcher %s (%d)", l->GetName(), l->GetID()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Removing launcher %s (%d)", l->GetName(), l->GetID());
curl = m_launchers.erase(curl); curl = m_launchers.erase(curl);
delete l; delete l;
} else { } else {
@ -131,7 +131,7 @@ LauncherLink *LauncherList::FindByZone(const char *short_name) {
void LauncherList::Add(EmuTCPConnection *conn) { void LauncherList::Add(EmuTCPConnection *conn) {
auto it = new LauncherLink(nextID++, conn); auto it = new LauncherLink(nextID++, conn);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Adding pending launcher %d", it->GetID()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Adding pending launcher %d", it->GetID());
m_pendingLaunchers.push_back(it); m_pendingLaunchers.push_back(it);
} }

32
world/login_server.cpp
View File

@ -96,7 +96,7 @@ bool LoginServer::Process() {
ServerPacket *pack = 0; ServerPacket *pack = 0;
while((pack = tcpc->PopPacket())) while((pack = tcpc->PopPacket()))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Recevied ServerPacket from LS OpCode 0x04x",pack->opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Recevied ServerPacket from LS OpCode 0x04x",pack->opcode);
_hex(WORLD__LS_TRACE,pack->pBuffer,pack->size); _hex(WORLD__LS_TRACE,pack->pBuffer,pack->size);
switch(pack->opcode) { switch(pack->opcode) {
@ -160,12 +160,12 @@ bool LoginServer::Process() {
case ServerOP_LSFatalError: { case ServerOP_LSFatalError: {
#ifndef IGNORE_LS_FATAL_ERROR #ifndef IGNORE_LS_FATAL_ERROR
WorldConfig::DisableLoginserver(); WorldConfig::DisableLoginserver();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login server responded with FatalError. Disabling reconnect."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login server responded with FatalError. Disabling reconnect.");
#else #else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login server responded with FatalError."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Login server responded with FatalError.");
#endif #endif
if (pack->size > 1) { if (pack->size > 1) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, " %s",pack->pBuffer); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, " %s",pack->pBuffer);
} }
break; break;
} }
@ -177,18 +177,18 @@ bool LoginServer::Process() {
case ServerOP_LSRemoteAddr: { case ServerOP_LSRemoteAddr: {
if (!Config->WorldAddress.length()) { if (!Config->WorldAddress.length()) {
WorldConfig::SetWorldAddress((char *)pack->pBuffer); WorldConfig::SetWorldAddress((char *)pack->pBuffer);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loginserver provided %s as world address",pack->pBuffer); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loginserver provided %s as world address",pack->pBuffer);
} }
break; break;
} }
case ServerOP_LSAccountUpdate: { case ServerOP_LSAccountUpdate: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Received ServerOP_LSAccountUpdate packet from loginserver"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Received ServerOP_LSAccountUpdate packet from loginserver");
CanAccountUpdate = true; CanAccountUpdate = true;
break; break;
} }
default: default:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown LSOpCode: 0x%04x size=%d",(int)pack->opcode,pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unknown LSOpCode: 0x%04x size=%d",(int)pack->opcode,pack->size);
DumpPacket(pack->pBuffer, pack->size); DumpPacket(pack->pBuffer, pack->size);
break; break;
} }
@ -202,10 +202,10 @@ bool LoginServer::Process() {
bool LoginServer::InitLoginServer() { bool LoginServer::InitLoginServer() {
if(Connected() == false) { if(Connected() == false) {
if(ConnectReady()) { if(ConnectReady()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connecting to login server: %s:%d",LoginServerAddress,LoginServerPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connecting to login server: %s:%d",LoginServerAddress,LoginServerPort);
Connect(); Connect();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Not connected but not ready to connect, this is bad: %s:%d", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Not connected but not ready to connect, this is bad: %s:%d",
LoginServerAddress,LoginServerPort); LoginServerAddress,LoginServerPort);
} }
} }
@ -216,29 +216,29 @@ bool LoginServer::Connect() {
char tmp[25]; char tmp[25];
if(database.GetVariable("loginType",tmp,sizeof(tmp)) && strcasecmp(tmp,"MinILogin") == 0){ if(database.GetVariable("loginType",tmp,sizeof(tmp)) && strcasecmp(tmp,"MinILogin") == 0){
minilogin = true; minilogin = true;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Setting World to MiniLogin Server type"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Setting World to MiniLogin Server type");
} }
else else
minilogin = false; minilogin = false;
if (minilogin && WorldConfig::get()->WorldAddress.length()==0) { if (minilogin && WorldConfig::get()->WorldAddress.length()==0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "**** For minilogin to work, you need to set the <address> element in the <world> section."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "**** For minilogin to work, you need to set the <address> element in the <world> section.");
return false; return false;
} }
char errbuf[TCPConnection_ErrorBufferSize]; char errbuf[TCPConnection_ErrorBufferSize];
if ((LoginServerIP = ResolveIP(LoginServerAddress, errbuf)) == 0) { if ((LoginServerIP = ResolveIP(LoginServerAddress, errbuf)) == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to resolve '%s' to an IP.",LoginServerAddress); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to resolve '%s' to an IP.",LoginServerAddress);
return false; return false;
} }
if (LoginServerIP == 0 || LoginServerPort == 0) { if (LoginServerIP == 0 || LoginServerPort == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connect info incomplete, cannot connect: %s:%d",LoginServerAddress,LoginServerPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connect info incomplete, cannot connect: %s:%d",LoginServerAddress,LoginServerPort);
return false; return false;
} }
if (tcpc->ConnectIP(LoginServerIP, LoginServerPort, errbuf)) { if (tcpc->ConnectIP(LoginServerIP, LoginServerPort, errbuf)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connected to Loginserver: %s:%d",LoginServerAddress,LoginServerPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connected to Loginserver: %s:%d",LoginServerAddress,LoginServerPort);
if (minilogin) if (minilogin)
SendInfo(); SendInfo();
else else
@ -248,7 +248,7 @@ bool LoginServer::Connect() {
return true; return true;
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not connect to login server: %s:%d %s",LoginServerAddress,LoginServerPort,errbuf); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not connect to login server: %s:%d %s",LoginServerAddress,LoginServerPort,errbuf);
return false; return false;
} }
} }
@ -324,7 +324,7 @@ void LoginServer::SendStatus() {
void LoginServer::SendAccountUpdate(ServerPacket* pack) { void LoginServer::SendAccountUpdate(ServerPacket* pack) {
ServerLSAccountUpdate_Struct* s = (ServerLSAccountUpdate_Struct *) pack->pBuffer; ServerLSAccountUpdate_Struct* s = (ServerLSAccountUpdate_Struct *) pack->pBuffer;
if(CanUpdate()) { if(CanUpdate()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Sending ServerOP_LSAccountUpdate packet to loginserver: %s:%d",LoginServerAddress,LoginServerPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Sending ServerOP_LSAccountUpdate packet to loginserver: %s:%d",LoginServerAddress,LoginServerPort);
strn0cpy(s->worldaccount, LoginAccount, 30); strn0cpy(s->worldaccount, LoginAccount, 30);
strn0cpy(s->worldpassword, LoginPassword, 30); strn0cpy(s->worldpassword, LoginPassword, 30);
SendPacket(pack); SendPacket(pack);

2
world/login_server_list.cpp
View File

@ -134,7 +134,7 @@ bool LoginServerList::SendPacket(ServerPacket* pack) {
bool LoginServerList::SendAccountUpdate(ServerPacket* pack) { bool LoginServerList::SendAccountUpdate(ServerPacket* pack) {
LinkedListIterator<LoginServer*> iterator(list); LinkedListIterator<LoginServer*> iterator(list);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Requested to send ServerOP_LSAccountUpdate packet to all loginservers"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Requested to send ServerOP_LSAccountUpdate packet to all loginservers");
iterator.Reset(); iterator.Reset();
while(iterator.MoreElements()){ while(iterator.MoreElements()){
if(iterator.GetData()->CanUpdate()) { if(iterator.GetData()->CanUpdate()) {

116
world/net.cpp
View File

@ -126,36 +126,36 @@ int main(int argc, char** argv) {
} }
// Load server configuration // Load server configuration
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading server configuration.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading server configuration..");
if (!WorldConfig::LoadConfig()) { if (!WorldConfig::LoadConfig()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading server configuration failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading server configuration failed.");
return 1; return 1;
} }
const WorldConfig *Config=WorldConfig::get(); const WorldConfig *Config=WorldConfig::get();
if(!load_log_settings(Config->LogSettingsFile.c_str())) if(!load_log_settings(Config->LogSettingsFile.c_str()))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "CURRENT_VERSION: %s", CURRENT_VERSION); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "CURRENT_VERSION: %s", CURRENT_VERSION);
#ifdef _DEBUG #ifdef _DEBUG
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif #endif
if (signal(SIGINT, CatchSignal) == SIG_ERR) { if (signal(SIGINT, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler");
return 1; return 1;
} }
if (signal(SIGTERM, CatchSignal) == SIG_ERR) { if (signal(SIGTERM, CatchSignal) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler");
return 1; return 1;
} }
#ifndef WIN32 #ifndef WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Could not set signal handler");
return 1; return 1;
} }
#endif #endif
@ -164,7 +164,7 @@ int main(int argc, char** argv) {
if (Config->LoginCount == 0) { if (Config->LoginCount == 0) {
if (Config->LoginHost.length()) { if (Config->LoginHost.length()) {
loginserverlist.Add(Config->LoginHost.c_str(), Config->LoginPort, Config->LoginAccount.c_str(), Config->LoginPassword.c_str()); loginserverlist.Add(Config->LoginHost.c_str(), Config->LoginPort, Config->LoginAccount.c_str(), Config->LoginPassword.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Added loginserver %s:%i", Config->LoginHost.c_str(), Config->LoginPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Added loginserver %s:%i", Config->LoginHost.c_str(), Config->LoginPort);
} }
} else { } else {
LinkedList<LoginConfig*> loginlist=Config->loginlist; LinkedList<LoginConfig*> loginlist=Config->loginlist;
@ -172,19 +172,19 @@ int main(int argc, char** argv) {
iterator.Reset(); iterator.Reset();
while(iterator.MoreElements()) { while(iterator.MoreElements()) {
loginserverlist.Add(iterator.GetData()->LoginHost.c_str(), iterator.GetData()->LoginPort, iterator.GetData()->LoginAccount.c_str(), iterator.GetData()->LoginPassword.c_str()); loginserverlist.Add(iterator.GetData()->LoginHost.c_str(), iterator.GetData()->LoginPort, iterator.GetData()->LoginAccount.c_str(), iterator.GetData()->LoginPassword.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Added loginserver %s:%i", iterator.GetData()->LoginHost.c_str(), iterator.GetData()->LoginPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Added loginserver %s:%i", iterator.GetData()->LoginHost.c_str(), iterator.GetData()->LoginPort);
iterator.Advance(); iterator.Advance();
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connecting to MySQL..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connecting to MySQL...");
if (!database.Connect( if (!database.Connect(
Config->DatabaseHost.c_str(), Config->DatabaseHost.c_str(),
Config->DatabaseUsername.c_str(), Config->DatabaseUsername.c_str(),
Config->DatabasePassword.c_str(), Config->DatabasePassword.c_str(),
Config->DatabaseDB.c_str(), Config->DatabaseDB.c_str(),
Config->DatabasePort)) { Config->DatabasePort)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Cannot continue without a database connection.");
return 1; return 1;
} }
guild_mgr.SetDatabase(&database); guild_mgr.SetDatabase(&database);
@ -280,56 +280,56 @@ int main(int argc, char** argv) {
} }
if(Config->WorldHTTPEnabled) { if(Config->WorldHTTPEnabled) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Starting HTTP world service..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Starting HTTP world service...");
http_server.Start(Config->WorldHTTPPort, Config->WorldHTTPMimeFile.c_str()); http_server.Start(Config->WorldHTTPPort, Config->WorldHTTPMimeFile.c_str());
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "HTTP world service disabled."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "HTTP world service disabled.");
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Checking Database Conversions.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Checking Database Conversions..");
database.CheckDatabaseConversions(); database.CheckDatabaseConversions();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading variables.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading variables..");
database.LoadVariables(); database.LoadVariables();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading zones.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading zones..");
database.LoadZoneNames(); database.LoadZoneNames();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing groups.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing groups..");
database.ClearGroup(); database.ClearGroup();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing raids.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing raids..");
database.ClearRaid(); database.ClearRaid();
database.ClearRaidDetails(); database.ClearRaidDetails();
database.ClearRaidLeader(); database.ClearRaidLeader();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading items.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading items..");
if (!database.LoadItems()) if (!database.LoadItems())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: Could not load item data. But ignoring"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: Could not load item data. But ignoring");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading skill caps.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading skill caps..");
if (!database.LoadSkillCaps()) if (!database.LoadSkillCaps())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: Could not load skill cap data. But ignoring"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Error: Could not load skill cap data. But ignoring");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading guilds.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading guilds..");
guild_mgr.LoadGuilds(); guild_mgr.LoadGuilds();
//rules: //rules:
{ {
char tmp[64]; char tmp[64];
if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) { if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading rule set '%s'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading rule set '%s'", tmp);
if(!RuleManager::Instance()->LoadRules(&database, tmp)) { if(!RuleManager::Instance()->LoadRules(&database, tmp)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Failed to load ruleset '%s', falling back to defaults.", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Failed to load ruleset '%s', falling back to defaults.", tmp);
} }
} else { } else {
if(!RuleManager::Instance()->LoadRules(&database, "default")) { if(!RuleManager::Instance()->LoadRules(&database, "default")) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "No rule set configured, using default rules"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "No rule set configured, using default rules");
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loaded default rule set 'default'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loaded default rule set 'default'", tmp);
} }
} }
} }
if(RuleB(World, ClearTempMerchantlist)){ if(RuleB(World, ClearTempMerchantlist)){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing temporary merchant lists.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Clearing temporary merchant lists..");
database.ClearMerchantTemp(); database.ClearMerchantTemp();
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading EQ time of day.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading EQ time of day..");
if (!zoneserver_list.worldclock.loadFile(Config->EQTimeFile.c_str())) if (!zoneserver_list.worldclock.loadFile(Config->EQTimeFile.c_str()))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load %s", Config->EQTimeFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load %s", Config->EQTimeFile.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading launcher list.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading launcher list..");
launcher_list.LoadList(); launcher_list.LoadList();
char tmp[20]; char tmp[20];
@ -338,45 +338,45 @@ int main(int argc, char** argv) {
if ((strcasecmp(tmp, "1") == 0)) { if ((strcasecmp(tmp, "1") == 0)) {
holdzones = true; holdzones = true;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Reboot zone modes %s",holdzones ? "ON" : "OFF"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Reboot zone modes %s",holdzones ? "ON" : "OFF");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Deleted %i stale player corpses from database", database.DeleteStalePlayerCorpses()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Deleted %i stale player corpses from database", database.DeleteStalePlayerCorpses());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading adventures..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading adventures...");
if(!adventure_manager.LoadAdventureTemplates()) if(!adventure_manager.LoadAdventureTemplates())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load adventure templates."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load adventure templates.");
} }
if(!adventure_manager.LoadAdventureEntries()) if(!adventure_manager.LoadAdventureEntries())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load adventure templates."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Unable to load adventure templates.");
} }
adventure_manager.Load(); adventure_manager.Load();
adventure_manager.LoadLeaderboardInfo(); adventure_manager.LoadLeaderboardInfo();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Purging expired instances"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Purging expired instances");
database.PurgeExpiredInstances(); database.PurgeExpiredInstances();
Timer PurgeInstanceTimer(450000); Timer PurgeInstanceTimer(450000);
PurgeInstanceTimer.Start(450000); PurgeInstanceTimer.Start(450000);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading char create info..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Loading char create info...");
database.LoadCharacterCreateAllocations(); database.LoadCharacterCreateAllocations();
database.LoadCharacterCreateCombos(); database.LoadCharacterCreateCombos();
char errbuf[TCPConnection_ErrorBufferSize]; char errbuf[TCPConnection_ErrorBufferSize];
if (tcps.Open(Config->WorldTCPPort, errbuf)) { if (tcps.Open(Config->WorldTCPPort, errbuf)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Zone (TCP) listener started."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Zone (TCP) listener started.");
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to start zone (TCP) listener on port %d:",Config->WorldTCPPort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to start zone (TCP) listener on port %d:",Config->WorldTCPPort);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," %s",errbuf); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server," %s",errbuf);
return 1; return 1;
} }
if (eqsf.Open()) { if (eqsf.Open()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Client (UDP) listener started."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Client (UDP) listener started.");
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to start client (UDP) listener (port 9000)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to start client (UDP) listener (port 9000)");
return 1; return 1;
} }
@ -404,7 +404,7 @@ int main(int argc, char** argv) {
//structures and opcodes for that patch. //structures and opcodes for that patch.
struct in_addr in; struct in_addr in;
in.s_addr = eqs->GetRemoteIP(); in.s_addr = eqs->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d", inet_ntoa(in),ntohs(eqs->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d", inet_ntoa(in),ntohs(eqs->GetRemotePort()));
stream_identifier.AddStream(eqs); //takes the stream stream_identifier.AddStream(eqs); //takes the stream
} }
@ -417,19 +417,19 @@ int main(int argc, char** argv) {
struct in_addr in; struct in_addr in;
in.s_addr = eqsi->GetRemoteIP(); in.s_addr = eqsi->GetRemoteIP();
if (RuleB(World, UseBannedIPsTable)){ //Lieka: Check to see if we have the responsibility for blocking IPs. if (RuleB(World, UseBannedIPsTable)){ //Lieka: Check to see if we have the responsibility for blocking IPs.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Checking inbound connection %s against BannedIPs table", inet_ntoa(in)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Checking inbound connection %s against BannedIPs table", inet_ntoa(in));
if (!database.CheckBannedIPs(inet_ntoa(in))){ //Lieka: Check inbound IP against banned IP table. if (!database.CheckBannedIPs(inet_ntoa(in))){ //Lieka: Check inbound IP against banned IP table.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connection %s PASSED banned IPs check. Processing connection.", inet_ntoa(in)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connection %s PASSED banned IPs check. Processing connection.", inet_ntoa(in));
auto client = new Client(eqsi); auto client = new Client(eqsi);
// @merth: client->zoneattempt=0; // @merth: client->zoneattempt=0;
client_list.Add(client); client_list.Add(client);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connection from %s FAILED banned IPs check. Closing connection.", inet_ntoa(in)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Connection from %s FAILED banned IPs check. Closing connection.", inet_ntoa(in));
eqsi->Close(); //Lieka: If the inbound IP is on the banned table, close the EQStream. eqsi->Close(); //Lieka: If the inbound IP is on the banned table, close the EQStream.
} }
} }
if (!RuleB(World, UseBannedIPsTable)){ if (!RuleB(World, UseBannedIPsTable)){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d, processing connection", inet_ntoa(in), ntohs(eqsi->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d, processing connection", inet_ntoa(in), ntohs(eqsi->GetRemotePort()));
auto client = new Client(eqsi); auto client = new Client(eqsi);
// @merth: client->zoneattempt=0; // @merth: client->zoneattempt=0;
client_list.Add(client); client_list.Add(client);
@ -441,7 +441,7 @@ int main(int argc, char** argv) {
while ((tcpc = tcps.NewQueuePop())) { while ((tcpc = tcps.NewQueuePop())) {
struct in_addr in; struct in_addr in;
in.s_addr = tcpc->GetrIP(); in.s_addr = tcpc->GetrIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New TCP connection from %s:%d", inet_ntoa(in),tcpc->GetrPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New TCP connection from %s:%d", inet_ntoa(in),tcpc->GetrPort());
console_list.Add(new Console(tcpc)); console_list.Add(new Console(tcpc));
} }
@ -492,16 +492,16 @@ int main(int argc, char** argv) {
} }
Sleep(20); Sleep(20);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"World main loop completed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"World main loop completed.");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Shutting down console connections (if any)."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Shutting down console connections (if any).");
console_list.KillAll(); console_list.KillAll();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Shutting down zone connections (if any)."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Shutting down zone connections (if any).");
zoneserver_list.KillAll(); zoneserver_list.KillAll();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Zone (TCP) listener stopped."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Zone (TCP) listener stopped.");
tcps.Close(); tcps.Close();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Client (UDP) listener stopped."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Client (UDP) listener stopped.");
eqsf.Close(); eqsf.Close();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Signaling HTTP service to stop..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Signaling HTTP service to stop...");
http_server.Stop(); http_server.Stop();
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
@ -509,9 +509,9 @@ int main(int argc, char** argv) {
} }
void CatchSignal(int sig_num) { void CatchSignal(int sig_num) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Caught signal %d",sig_num); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Caught signal %d",sig_num);
if(zoneserver_list.worldclock.saveFile(WorldConfig::get()->EQTimeFile.c_str())==false) if(zoneserver_list.worldclock.saveFile(WorldConfig::get()->EQTimeFile.c_str())==false)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to save time file."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Failed to save time file.");
RunLoops = false; RunLoops = false;
} }

12
world/queryserv.cpp
View File

@ -23,7 +23,7 @@ void QueryServConnection::SetConnection(EmuTCPConnection *inStream)
{ {
if(Stream) if(Stream)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Incoming QueryServ Connection while we were already connected to a QueryServ."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Incoming QueryServ Connection while we were already connected to a QueryServ.");
Stream->Disconnect(); Stream->Disconnect();
} }
@ -57,7 +57,7 @@ bool QueryServConnection::Process()
{ {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "QueryServ authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "QueryServ authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -69,7 +69,7 @@ bool QueryServConnection::Process()
{ {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "QueryServ authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "QueryServ authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -79,7 +79,7 @@ bool QueryServConnection::Process()
} }
else else
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access.");
authenticated = true; authenticated = true;
} }
delete pack; delete pack;
@ -97,7 +97,7 @@ bool QueryServConnection::Process()
} }
case ServerOP_ZAAuth: case ServerOP_ZAAuth:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Got authentication from QueryServ when they are already authenticated."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Got authentication from QueryServ when they are already authenticated.");
break; break;
} }
case ServerOP_QueryServGeneric: case ServerOP_QueryServGeneric:
@ -114,7 +114,7 @@ bool QueryServConnection::Process()
} }
default: default:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Unknown ServerOPcode from QueryServ 0x%04x, size %d", pack->opcode, pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::QS_Server, "Unknown ServerOPcode from QueryServ 0x%04x, size %d", pack->opcode, pack->size);
DumpPacket(pack->pBuffer, pack->size); DumpPacket(pack->pBuffer, pack->size);
break; break;
} }

12
world/ucs.cpp
View File

@ -18,7 +18,7 @@ void UCSConnection::SetConnection(EmuTCPConnection *inStream)
{ {
if(Stream) if(Stream)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Incoming UCS Connection while we were already connected to a UCS."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Incoming UCS Connection while we were already connected to a UCS.");
Stream->Disconnect(); Stream->Disconnect();
} }
@ -52,7 +52,7 @@ bool UCSConnection::Process()
{ {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "UCS authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "UCS authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -64,7 +64,7 @@ bool UCSConnection::Process()
{ {
struct in_addr in; struct in_addr in;
in.s_addr = GetIP(); in.s_addr = GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "UCS authorization failed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "UCS authorization failed.");
auto pack = new ServerPacket(ServerOP_ZAAuthFailed); auto pack = new ServerPacket(ServerOP_ZAAuthFailed);
SendPacket(pack); SendPacket(pack);
delete pack; delete pack;
@ -74,7 +74,7 @@ bool UCSConnection::Process()
} }
else else
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access.");
authenticated = true; authenticated = true;
} }
delete pack; delete pack;
@ -92,12 +92,12 @@ bool UCSConnection::Process()
} }
case ServerOP_ZAAuth: case ServerOP_ZAAuth:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Got authentication from UCS when they are already authenticated."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Got authentication from UCS when they are already authenticated.");
break; break;
} }
default: default:
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unknown ServerOPcode from UCS 0x%04x, size %d", pack->opcode, pack->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::UCS_Server, "Unknown ServerOPcode from UCS 0x%04x, size %d", pack->opcode, pack->size);
DumpPacket(pack->pBuffer, pack->size); DumpPacket(pack->pBuffer, pack->size);
break; break;
} }

26
world/wguild_mgr.cpp
View File

@ -34,7 +34,7 @@ WorldGuildManager guild_mgr;
void WorldGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd, bool rank, bool relation) { void WorldGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd, bool rank, bool relation) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting guild refresh for %d, changes: name=%d, motd=%d, rank=d, relation=%d", guild_id, name, motd, rank, relation); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting guild refresh for %d, changes: name=%d, motd=%d, rank=d, relation=%d", guild_id, name, motd, rank, relation);
auto pack = new ServerPacket(ServerOP_RefreshGuild, sizeof(ServerGuildRefresh_Struct)); auto pack = new ServerPacket(ServerOP_RefreshGuild, sizeof(ServerGuildRefresh_Struct));
ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer; ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer;
s->guild_id = guild_id; s->guild_id = guild_id;
@ -47,7 +47,7 @@ void WorldGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd,
} }
void WorldGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, uint32 charid) { void WorldGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, uint32 charid) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting char refresh for %d from guild %d to world", charid, guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting char refresh for %d from guild %d to world", charid, guild_id);
auto pack = new ServerPacket(ServerOP_GuildCharRefresh, sizeof(ServerGuildCharRefresh_Struct)); auto pack = new ServerPacket(ServerOP_GuildCharRefresh, sizeof(ServerGuildCharRefresh_Struct));
ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer; ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer;
s->guild_id = guild_id; s->guild_id = guild_id;
@ -58,7 +58,7 @@ void WorldGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, ui
} }
void WorldGuildManager::SendGuildDelete(uint32 guild_id) { void WorldGuildManager::SendGuildDelete(uint32 guild_id) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting guild delete for guild %d to world", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Broadcasting guild delete for guild %d to world", guild_id);
auto pack = new ServerPacket(ServerOP_DeleteGuild, sizeof(ServerGuildID_Struct)); auto pack = new ServerPacket(ServerOP_DeleteGuild, sizeof(ServerGuildID_Struct));
ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer; ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer;
s->guild_id = guild_id; s->guild_id = guild_id;
@ -71,18 +71,18 @@ void WorldGuildManager::ProcessZonePacket(ServerPacket *pack) {
case ServerOP_RefreshGuild: { case ServerOP_RefreshGuild: {
if(pack->size != sizeof(ServerGuildRefresh_Struct)) { if(pack->size != sizeof(ServerGuildRefresh_Struct)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_RefreshGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildRefresh_Struct)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_RefreshGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildRefresh_Struct));
return; return;
} }
ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer; ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild refresh for %d, changes: name=%d, motd=%d, rank=d, relation=%d", s->guild_id, s->name_change, s->motd_change, s->rank_change, s->relation_change); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild refresh for %d, changes: name=%d, motd=%d, rank=d, relation=%d", s->guild_id, s->name_change, s->motd_change, s->rank_change, s->relation_change);
//broadcast this packet to all zones. //broadcast this packet to all zones.
zoneserver_list.SendPacket(pack); zoneserver_list.SendPacket(pack);
//preform a local refresh. //preform a local refresh.
if(!RefreshGuild(s->guild_id)) { if(!RefreshGuild(s->guild_id)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to preform local refresh on guild %d", s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to preform local refresh on guild %d", s->guild_id);
//can we do anything? //can we do anything?
} }
@ -91,11 +91,11 @@ void WorldGuildManager::ProcessZonePacket(ServerPacket *pack) {
case ServerOP_GuildCharRefresh: { case ServerOP_GuildCharRefresh: {
if(pack->size != sizeof(ServerGuildCharRefresh_Struct)) { if(pack->size != sizeof(ServerGuildCharRefresh_Struct)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_RefreshGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildCharRefresh_Struct)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_RefreshGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildCharRefresh_Struct));
return; return;
} }
ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer; ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild member refresh for char %d to all zones with members of guild %d", s->char_id, s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild member refresh for char %d to all zones with members of guild %d", s->char_id, s->guild_id);
//preform the local update //preform the local update
client_list.UpdateClientGuild(s->char_id, s->guild_id); client_list.UpdateClientGuild(s->char_id, s->guild_id);
@ -110,18 +110,18 @@ void WorldGuildManager::ProcessZonePacket(ServerPacket *pack) {
case ServerOP_DeleteGuild: { case ServerOP_DeleteGuild: {
if(pack->size != sizeof(ServerGuildID_Struct)) { if(pack->size != sizeof(ServerGuildID_Struct)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_DeleteGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildID_Struct)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_DeleteGuild of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildID_Struct));
return; return;
} }
ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer; ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild delete for guild %d", s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received and broadcasting guild delete for guild %d", s->guild_id);
//broadcast this packet to all zones. //broadcast this packet to all zones.
zoneserver_list.SendPacket(pack); zoneserver_list.SendPacket(pack);
//preform a local refresh. //preform a local refresh.
if(!LocalDeleteGuild(s->guild_id)) { if(!LocalDeleteGuild(s->guild_id)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to preform local delete on guild %d", s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unable to preform local delete on guild %d", s->guild_id);
//can we do anything? //can we do anything?
} }
@ -131,7 +131,7 @@ void WorldGuildManager::ProcessZonePacket(ServerPacket *pack) {
case ServerOP_GuildMemberUpdate: { case ServerOP_GuildMemberUpdate: {
if(pack->size != sizeof(ServerGuildMemberUpdate_Struct)) if(pack->size != sizeof(ServerGuildMemberUpdate_Struct))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_GuildMemberUpdate of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildMemberUpdate_Struct)); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received ServerOP_GuildMemberUpdate of incorrect size %d, expected %d", pack->size, sizeof(ServerGuildMemberUpdate_Struct));
return; return;
} }
@ -141,7 +141,7 @@ void WorldGuildManager::ProcessZonePacket(ServerPacket *pack) {
} }
default: default:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unknown packet 0x%x received from zone??", pack->opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Unknown packet 0x%x received from zone??", pack->opcode);
break; break;
} }
} }

8
world/zonelist.cpp
View File

@ -79,7 +79,7 @@ void ZSList::KillAll() {
void ZSList::Process() { void ZSList::Process() {
if(shutdowntimer && shutdowntimer->Check()){ if(shutdowntimer && shutdowntimer->Check()){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Shutdown timer has expired. Telling all zones to shut down and exiting. (fake sigint)"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "Shutdown timer has expired. Telling all zones to shut down and exiting. (fake sigint)");
auto pack2 = new ServerPacket; auto pack2 = new ServerPacket;
pack2->opcode = ServerOP_ShutdownAll; pack2->opcode = ServerOP_ShutdownAll;
pack2->size=0; pack2->size=0;
@ -99,10 +99,10 @@ void ZSList::Process() {
ZoneServer* zs = iterator.GetData(); ZoneServer* zs = iterator.GetData();
struct in_addr in; struct in_addr in;
in.s_addr = zs->GetIP(); in.s_addr = zs->GetIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing zoneserver #%d at %s:%d",zs->GetID(),zs->GetCAddress(),zs->GetCPort()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Removing zoneserver #%d at %s:%d",zs->GetID(),zs->GetCAddress(),zs->GetCPort());
zs->LSShutDownUpdate(zs->GetZoneID()); zs->LSShutDownUpdate(zs->GetZoneID());
if (holdzones){ if (holdzones){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Hold Zones mode is ON - rebooting lost zone"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Hold Zones mode is ON - rebooting lost zone");
if(!zs->IsStaticZone()) if(!zs->IsStaticZone())
RebootZone(inet_ntoa(in),zs->GetCPort(),zs->GetCAddress(),zs->GetID()); RebootZone(inet_ntoa(in),zs->GetCPort(),zs->GetCAddress(),zs->GetID());
else else
@ -576,7 +576,7 @@ void ZSList::RebootZone(const char* ip1,uint16 port,const char* ip2, uint32 skip
s->port = port; s->port = port;
s->zoneid = zoneid; s->zoneid = zoneid;
if(zoneid != 0) if(zoneid != 0)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Rebooting static zone with the ID of: %i",zoneid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Rebooting static zone with the ID of: %i",zoneid);
tmp[z]->SendPacket(pack); tmp[z]->SendPacket(pack);
delete pack; delete pack;
safe_delete_array(tmp); safe_delete_array(tmp);

8
world/zoneserver.cpp
View File

@ -209,7 +209,7 @@ bool ZoneServer::Process() {
} }
else else
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"**WARNING** You have not configured a world shared key in your config file. You should add a <key>STRING</key> element to your <world> element to prevent unauthroized zone access.");
authenticated = true; authenticated = true;
} }
} }
@ -708,20 +708,20 @@ bool ZoneServer::Process() {
/* Zone was already running*/ /* Zone was already running*/
if(ingress_server) { if(ingress_server) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Found a zone already booted for %s\n", ztz->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Found a zone already booted for %s\n", ztz->name);
ztz->response = 1; ztz->response = 1;
} }
/* Boot the Zone*/ /* Boot the Zone*/
else { else {
int server_id; int server_id;
if ((server_id = zoneserver_list.TriggerBootup(ztz->requested_zone_id, ztz->requested_instance_id))){ if ((server_id = zoneserver_list.TriggerBootup(ztz->requested_zone_id, ztz->requested_instance_id))){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Successfully booted a zone for %s\n", ztz->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"Successfully booted a zone for %s\n", ztz->name);
// bootup successful, ready to rock // bootup successful, ready to rock
ztz->response = 1; ztz->response = 1;
ingress_server = zoneserver_list.FindByID(server_id); ingress_server = zoneserver_list.FindByID(server_id);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"FAILED to boot a zone for %s\n", ztz->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server,"FAILED to boot a zone for %s\n", ztz->name);
// bootup failed, send back error code 0 // bootup failed, send back error code 0
ztz->response = 0; ztz->response = 0;
} }

14
zone/aggro.cpp
View File

@ -342,17 +342,17 @@ bool Mob::CheckWillAggro(Mob *mob) {
{ {
//FatherNiwtit: make sure we can see them. last since it is very expensive //FatherNiwtit: make sure we can see them. last since it is very expensive
if(CheckLosFN(mob)) { if(CheckLosFN(mob)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Check aggro for %s target %s.", GetName(), mob->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Check aggro for %s target %s.", GetName(), mob->GetName());
return( mod_will_aggro(mob, this) ); return( mod_will_aggro(mob, this) );
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Is In zone?:%d\n", mob->InZone()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Is In zone?:%d\n", mob->InZone());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Dist^2: %f\n", dist2); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Dist^2: %f\n", dist2);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Range^2: %f\n", iAggroRange2); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Range^2: %f\n", iAggroRange2);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Faction: %d\n", fv); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Faction: %d\n", fv);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Int: %d\n", GetINT()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Int: %d\n", GetINT());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Con: %d\n", GetLevelCon(mob->GetLevel())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Aggro, "Con: %d\n", GetLevelCon(mob->GetLevel()));
return(false); return(false);
} }

26
zone/attack.cpp
View File

@ -57,7 +57,7 @@ bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* w
if (weapon && weapon->IsType(ItemClassCommon)) { if (weapon && weapon->IsType(ItemClassCommon)) {
const Item_Struct* item = weapon->GetItem(); const Item_Struct* item = weapon->GetItem();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Weapon skill : %i", item->ItemType); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Weapon skill : %i", item->ItemType);
switch (item->ItemType) switch (item->ItemType)
{ {
@ -187,7 +187,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
if(attacker->IsNPC() && !attacker->IsPet()) if(attacker->IsNPC() && !attacker->IsPet())
chancetohit += RuleR(Combat, NPCBonusHitChance); chancetohit += RuleR(Combat, NPCBonusHitChance);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "CheckHitChance(%s) attacked by %s", defender->GetName(), attacker->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "CheckHitChance(%s) attacked by %s", defender->GetName(), attacker->GetName());
bool pvpmode = false; bool pvpmode = false;
if(IsClient() && other->IsClient()) if(IsClient() && other->IsClient())
@ -208,7 +208,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
//Calculate the level difference //Calculate the level difference
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit before level diff calc %.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit before level diff calc %.2f", chancetohit);
double level_difference = attacker_level - defender_level; double level_difference = attacker_level - defender_level;
double range = defender->GetLevel(); double range = defender->GetLevel();
@ -236,32 +236,32 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
chancetohit += (RuleR(Combat,HitBonusPerLevel) * level_difference); chancetohit += (RuleR(Combat,HitBonusPerLevel) * level_difference);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after level diff calc %.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after level diff calc %.2f", chancetohit);
chancetohit -= ((float)defender->GetAGI() * RuleR(Combat, AgiHitFactor)); chancetohit -= ((float)defender->GetAGI() * RuleR(Combat, AgiHitFactor));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after Agility calc %.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after Agility calc %.2f", chancetohit);
if(attacker->IsClient()) if(attacker->IsClient())
{ {
chancetohit -= (RuleR(Combat,WeaponSkillFalloff) * (attacker->CastToClient()->MaxSkill(skillinuse) - attacker->GetSkill(skillinuse))); chancetohit -= (RuleR(Combat,WeaponSkillFalloff) * (attacker->CastToClient()->MaxSkill(skillinuse) - attacker->GetSkill(skillinuse)));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after agil calc %.2f", "Chance to hit after weapon falloff calc (attack) %.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after agil calc %.2f", "Chance to hit after weapon falloff calc (attack) %.2f", chancetohit);
} }
if(defender->IsClient()) if(defender->IsClient())
{ {
chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense))); chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense)));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after weapon falloff calc (defense) %.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit after weapon falloff calc (defense) %.2f", chancetohit);
} }
//I dont think this is 100% correct, but at least it does something... //I dont think this is 100% correct, but at least it does something...
if(attacker->spellbonuses.MeleeSkillCheckSkill == skillinuse || attacker->spellbonuses.MeleeSkillCheckSkill == 255) { if(attacker->spellbonuses.MeleeSkillCheckSkill == skillinuse || attacker->spellbonuses.MeleeSkillCheckSkill == 255) {
chancetohit += attacker->spellbonuses.MeleeSkillCheck; chancetohit += attacker->spellbonuses.MeleeSkillCheck;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Applied spell melee skill bonus %d, yeilding %.2f", attacker->spellbonuses.MeleeSkillCheck, chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Applied spell melee skill bonus %d, yeilding %.2f", attacker->spellbonuses.MeleeSkillCheck, chancetohit);
} }
if(attacker->itembonuses.MeleeSkillCheckSkill == skillinuse || attacker->itembonuses.MeleeSkillCheckSkill == 255) { if(attacker->itembonuses.MeleeSkillCheckSkill == skillinuse || attacker->itembonuses.MeleeSkillCheckSkill == 255) {
chancetohit += attacker->itembonuses.MeleeSkillCheck; chancetohit += attacker->itembonuses.MeleeSkillCheck;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Applied item melee skill bonus %d, yeilding %.2f", attacker->spellbonuses.MeleeSkillCheck, chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Applied item melee skill bonus %d, yeilding %.2f", attacker->spellbonuses.MeleeSkillCheck, chancetohit);
} }
//Avoidance Bonuses on defender decreases baseline hit chance by percent. //Avoidance Bonuses on defender decreases baseline hit chance by percent.
@ -308,7 +308,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
//Calculate final chance to hit //Calculate final chance to hit
chancetohit += ((chancetohit * (hitBonus - avoidanceBonus)) / 100.0f); chancetohit += ((chancetohit * (hitBonus - avoidanceBonus)) / 100.0f);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit %.2f after accuracy calc %.2f and avoidance calc %.2f", chancetohit, hitBonus, avoidanceBonus); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Chance to hit %.2f after accuracy calc %.2f and avoidance calc %.2f", chancetohit, hitBonus, avoidanceBonus);
chancetohit = mod_hit_chance(chancetohit, skillinuse, attacker); chancetohit = mod_hit_chance(chancetohit, skillinuse, attacker);
@ -327,7 +327,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
//agains a garunteed riposte (for example) discipline... for now, garunteed hit wins //agains a garunteed riposte (for example) discipline... for now, garunteed hit wins
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "3 FINAL calculated chance to hit is: %5.2f", chancetohit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "3 FINAL calculated chance to hit is: %5.2f", chancetohit);
// //
@ -336,7 +336,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
float tohit_roll = zone->random.Real(0, 100); float tohit_roll = zone->random.Real(0, 100);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Final hit chance: %.2f%%. Hit roll %.2f", chancetohit, tohit_roll); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "Final hit chance: %.2f%%. Hit roll %.2f", chancetohit, tohit_roll);
return(tohit_roll <= chancetohit); return(tohit_roll <= chancetohit);
} }
@ -2028,7 +2028,7 @@ bool NPC::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack
if (IsEngaged()) if (IsEngaged())
{ {
zone->DelAggroMob(); zone->DelAggroMob();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "%s Mobs currently Aggro %i", __FUNCTION__, zone->MobsAggroCount()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Attack, "%s Mobs currently Aggro %i", __FUNCTION__, zone->MobsAggroCount());
} }
SetHP(0); SetHP(0);
SetPet(0); SetPet(0);

6
zone/bonuses.cpp
View File

@ -77,9 +77,9 @@ void Client::CalcBonuses()
CalcSpellBonuses(&spellbonuses); CalcSpellBonuses(&spellbonuses);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Calculating AA Bonuses for %s.", this->GetCleanName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Calculating AA Bonuses for %s.", this->GetCleanName());
CalcAABonuses(&aabonuses); //we're not quite ready for this CalcAABonuses(&aabonuses); //we're not quite ready for this
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Finished calculating AA Bonuses for %s.", this->GetCleanName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Finished calculating AA Bonuses for %s.", this->GetCleanName());
RecalcWeight(); RecalcWeight();
@ -634,7 +634,7 @@ void Client::ApplyAABonuses(uint32 aaid, uint32 slots, StatBonuses* newbon)
if (effect == SE_Blank || (effect == SE_CHA && base1 == 0) || effect == SE_StackingCommand_Block || effect == SE_StackingCommand_Overwrite) if (effect == SE_Blank || (effect == SE_CHA && base1 == 0) || effect == SE_StackingCommand_Block || effect == SE_StackingCommand_Overwrite)
continue; continue;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Applying Effect %d from AA %u in slot %d (base1: %d, base2: %d) on %s", effect, aaid, slot, base1, base2, this->GetCleanName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Applying Effect %d from AA %u in slot %d (base1: %d, base2: %d) on %s", effect, aaid, slot, base1, base2, this->GetCleanName());
uint8 focus = IsFocusEffect(0, 0, true,effect); uint8 focus = IsFocusEffect(0, 0, true,effect);
if (focus) if (focus)

4
zone/bot.cpp
View File

@ -1564,7 +1564,7 @@ void Bot::ApplyAABonuses(uint32 aaid, uint32 slots, StatBonuses* newbon)
if (effect == SE_Blank || (effect == SE_CHA && base1 == 0) || effect == SE_StackingCommand_Block || effect == SE_StackingCommand_Overwrite) if (effect == SE_Blank || (effect == SE_CHA && base1 == 0) || effect == SE_StackingCommand_Block || effect == SE_StackingCommand_Overwrite)
continue; continue;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Applying Effect %d from AA %u in slot %d (base1: %d, base2: %d) on %s", effect, aaid, slot, base1, base2, this->GetCleanName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::AA, "Applying Effect %d from AA %u in slot %d (base1: %d, base2: %d) on %s", effect, aaid, slot, base1, base2, this->GetCleanName());
uint8 focus = IsFocusEffect(0, 0, true,effect); uint8 focus = IsFocusEffect(0, 0, true,effect);
if (focus) if (focus)
@ -7335,7 +7335,7 @@ int32 Bot::CalcBotFocusEffect(BotfocusType bottype, uint16 focus_id, uint16 spel
//this spits up a lot of garbage when calculating spell focuses //this spits up a lot of garbage when calculating spell focuses
//since they have all kinds of extra effects on them. //since they have all kinds of extra effects on them.
default: default:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Spells, "CalcFocusEffect: unknown effectid %d", focus_spell.effectid[i]); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Spells, "CalcFocusEffect: unknown effectid %d", focus_spell.effectid[i]);
} }
} }
//Check for spell skill limits. //Check for spell skill limits.

16
zone/client.cpp
View File

@ -650,7 +650,7 @@ bool Client::SendAllPackets() {
if(eqs) if(eqs)
eqs->FastQueuePacket((EQApplicationPacket **)&cp->app, cp->ack_req); eqs->FastQueuePacket((EQApplicationPacket **)&cp->app, cp->ack_req);
iterator.RemoveCurrent(); iterator.RemoveCurrent();
logger.LogDebugType(EQEmuLogSys::Moderate, EQEmuLogSys::Client_Server_Packet, "Transmitting a packet"); logger.DebugCategory(EQEmuLogSys::Moderate, EQEmuLogSys::Client_Server_Packet, "Transmitting a packet");
} }
return true; return true;
} }
@ -698,7 +698,7 @@ void Client::ChannelMessageReceived(uint8 chan_num, uint8 language, uint8 lang_s
char message[4096]; char message[4096];
strn0cpy(message, orig_message, sizeof(message)); strn0cpy(message, orig_message, sizeof(message));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Client::ChannelMessageReceived() Channel:%i message:'%s'", chan_num, message); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Client::ChannelMessageReceived() Channel:%i message:'%s'", chan_num, message);
if (targetname == nullptr) { if (targetname == nullptr) {
targetname = (!GetTarget()) ? "" : GetTarget()->GetName(); targetname = (!GetTarget()) ? "" : GetTarget()->GetName();
@ -1506,7 +1506,7 @@ void Client::UpdateAdmin(bool iFromDB) {
if(m_pp.gm) if(m_pp.gm)
{ {
logger.LogDebugType(EQEmuLogSys::Moderate, EQEmuLogSys::Zone_Server, __FUNCTION__ " - %s is a GM", GetName()); logger.DebugCategory(EQEmuLogSys::Moderate, EQEmuLogSys::Zone_Server, __FUNCTION__ " - %s is a GM", GetName());
// no need for this, having it set in pp you already start as gm // no need for this, having it set in pp you already start as gm
// and it's also set in your spawn packet so other people see it too // and it's also set in your spawn packet so other people see it too
// SendAppearancePacket(AT_GM, 1, false); // SendAppearancePacket(AT_GM, 1, false);
@ -2235,13 +2235,13 @@ bool Client::CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int cha
if(zone->random.Real(0, 99) < Chance) if(zone->random.Real(0, 99) < Chance)
{ {
SetSkill(skillid, GetRawSkill(skillid) + 1); SetSkill(skillid, GetRawSkill(skillid) + 1);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d successfully gain with %.4f%%chance (mod %d)", skillid, skillval, Chance, chancemodi); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d successfully gain with %.4f%%chance (mod %d)", skillid, skillval, Chance, chancemodi);
return true; return true;
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d failed to gain with %.4f%%chance (mod %d)", skillid, skillval, Chance, chancemodi); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d failed to gain with %.4f%%chance (mod %d)", skillid, skillval, Chance, chancemodi);
} }
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d cannot increase due to maxmum %d", skillid, skillval, maxskill); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Skill %d at value %d cannot increase due to maxmum %d", skillid, skillval, maxskill);
} }
return false; return false;
} }
@ -2262,10 +2262,10 @@ void Client::CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill) {
if(zone->random.Real(0,100) < Chance) { // if they make the roll if(zone->random.Real(0,100) < Chance) { // if they make the roll
IncreaseLanguageSkill(langid); // increase the language skill by 1 IncreaseLanguageSkill(langid); // increase the language skill by 1
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Language %d at value %d successfully gain with %.4f%%chance", langid, LangSkill, Chance); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Language %d at value %d successfully gain with %.4f%%chance", langid, LangSkill, Chance);
} }
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Language %d at value %d failed to gain with %.4f%%chance", langid, LangSkill, Chance); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Skills, "Language %d at value %d failed to gain with %.4f%%chance", langid, LangSkill, Chance);
} }
} }

2
zone/client_mods.cpp
View File

@ -1896,7 +1896,7 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (effectmod > effectmodcap) if (effectmod > effectmodcap)
effectmod = effectmodcap; effectmod = effectmodcap;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "%s::GetInstrumentMod() spell=%d mod=%d modcap=%d\n", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "%s::GetInstrumentMod() spell=%d mod=%d modcap=%d\n",
GetName(), spell_id, effectmod, effectmodcap); GetName(), spell_id, effectmod, effectmodcap);
return effectmod; return effectmod;

44
zone/client_packet.cpp
View File

@ -3573,7 +3573,7 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
default: default:
Message(13, "Unrecognised Barter action."); Message(13, "Unrecognised Barter action.");
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unrecognised Barter Action %i", Action); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unrecognised Barter Action %i", Action);
} }
} }
@ -3636,7 +3636,7 @@ void Client::Handle_OP_BazaarSearch(const EQApplicationPacket *app)
return; return;
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Malformed BazaarSearch_Struct packe, Action %it received, ignoring..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Malformed BazaarSearch_Struct packe, Action %it received, ignoring...");
logger.Log(EQEmuLogSys::Error, "Malformed BazaarSearch_Struct packet received, ignoring...\n"); logger.Log(EQEmuLogSys::Error, "Malformed BazaarSearch_Struct packet received, ignoring...\n");
} }
@ -7196,7 +7196,7 @@ void Client::Handle_OP_GuildCreate(const EQApplicationPacket *app)
uint32 NewGuildID = guild_mgr.CreateGuild(GuildName, CharacterID()); uint32 NewGuildID = guild_mgr.CreateGuild(GuildName, CharacterID());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Creating guild %s with leader %d via UF+ GUI. It was given id %lu.", GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Creating guild %s with leader %d via UF+ GUI. It was given id %lu.", GetName(),
GuildName, CharacterID(), (unsigned long)NewGuildID); GuildName, CharacterID(), (unsigned long)NewGuildID);
if (NewGuildID == GUILD_NONE) if (NewGuildID == GUILD_NONE)
@ -9814,7 +9814,7 @@ void Client::Handle_OP_OpenContainer(const EQApplicationPacket *app)
void Client::Handle_OP_OpenGuildTributeMaster(const EQApplicationPacket *app) void Client::Handle_OP_OpenGuildTributeMaster(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_OpenGuildTributeMaster of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_OpenGuildTributeMaster of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
if (app->size != sizeof(StartTribute_Struct)) if (app->size != sizeof(StartTribute_Struct))
@ -9846,7 +9846,7 @@ void Client::Handle_OP_OpenInventory(const EQApplicationPacket *app)
void Client::Handle_OP_OpenTributeMaster(const EQApplicationPacket *app) void Client::Handle_OP_OpenTributeMaster(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_OpenTributeMaster of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_OpenTributeMaster of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
if (app->size != sizeof(StartTribute_Struct)) if (app->size != sizeof(StartTribute_Struct))
@ -11714,7 +11714,7 @@ void Client::Handle_OP_RezzAnswer(const EQApplicationPacket *app)
const Resurrect_Struct* ra = (const Resurrect_Struct*)app->pBuffer; const Resurrect_Struct* ra = (const Resurrect_Struct*)app->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Received OP_RezzAnswer from client. Pendingrezzexp is %i, action is %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Received OP_RezzAnswer from client. Pendingrezzexp is %i, action is %s",
PendingRezzXP, ra->action ? "ACCEPT" : "DECLINE"); PendingRezzXP, ra->action ? "ACCEPT" : "DECLINE");
_pkt(SPELLS__REZ, app); _pkt(SPELLS__REZ, app);
@ -11782,7 +11782,7 @@ void Client::Handle_OP_SaveOnZoneReq(const EQApplicationPacket *app)
void Client::Handle_OP_SelectTribute(const EQApplicationPacket *app) void Client::Handle_OP_SelectTribute(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_SelectTribute of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_SelectTribute of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
//we should enforce being near a real tribute master to change this //we should enforce being near a real tribute master to change this
@ -13435,7 +13435,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
if (c) if (c)
c->WithCustomer(0); c->WithCustomer(0);
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Null Client Pointer"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Null Client Pointer");
break; break;
} }
@ -13444,7 +13444,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
break; break;
} }
default: { default: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unhandled action code in OP_Trader ShowItems_Struct"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unhandled action code in OP_Trader ShowItems_Struct");
break; break;
} }
} }
@ -13530,7 +13530,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
} }
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_Trader: Unknown TraderStruct code of: %i\n", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_Trader: Unknown TraderStruct code of: %i\n",
ints->Code); ints->Code);
logger.Log(EQEmuLogSys::Error, "Unknown TraderStruct code of: %i\n", ints->Code); logger.Log(EQEmuLogSys::Error, "Unknown TraderStruct code of: %i\n", ints->Code);
@ -13542,7 +13542,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
HandleTraderPriceUpdate(app); HandleTraderPriceUpdate(app);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unknown size for OP_Trader: %i\n", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unknown size for OP_Trader: %i\n", app->size);
logger.Log(EQEmuLogSys::Error, "Unknown size for OP_Trader: %i\n", app->size); logger.Log(EQEmuLogSys::Error, "Unknown size for OP_Trader: %i\n", app->size);
DumpPacket(app); DumpPacket(app);
return; return;
@ -13568,11 +13568,11 @@ void Client::Handle_OP_TraderBuy(const EQApplicationPacket *app)
BuyTraderItem(tbs, Trader, app); BuyTraderItem(tbs, Trader, app);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Null Client Pointer"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Null Client Pointer");
} }
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Struct size mismatch"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderBuy: Struct size mismatch");
} }
return; return;
@ -13646,7 +13646,7 @@ void Client::Handle_OP_TraderShop(const EQApplicationPacket *app)
if (app->size != sizeof(TraderClick_Struct)) { if (app->size != sizeof(TraderClick_Struct)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderShop: Returning due to struct size mismatch"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderShop: Returning due to struct size mismatch");
return; return;
} }
@ -13660,7 +13660,7 @@ void Client::Handle_OP_TraderShop(const EQApplicationPacket *app)
if (Customer) if (Customer)
outtcs->Approval = Customer->WithCustomer(GetID()); outtcs->Approval = Customer->WithCustomer(GetID());
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderShop: entity_list.GetClientByID(tcs->traderid)" logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::Handle_OP_TraderShop: entity_list.GetClientByID(tcs->traderid)"
" returned a nullptr pointer"); " returned a nullptr pointer");
return; return;
} }
@ -13757,7 +13757,7 @@ void Client::Handle_OP_Translocate(const EQApplicationPacket *app)
void Client::Handle_OP_TributeItem(const EQApplicationPacket *app) void Client::Handle_OP_TributeItem(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeItem of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeItem of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
//player donates an item... //player donates an item...
@ -13776,7 +13776,7 @@ void Client::Handle_OP_TributeItem(const EQApplicationPacket *app)
t->tribute_points = TributeItem(t->slot, t->quantity); t->tribute_points = TributeItem(t->slot, t->quantity);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Sending tribute item reply with %d points", t->tribute_points); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Sending tribute item reply with %d points", t->tribute_points);
_pkt(TRIBUTE__OUT, app); _pkt(TRIBUTE__OUT, app);
QueuePacket(app); QueuePacket(app);
@ -13786,7 +13786,7 @@ void Client::Handle_OP_TributeItem(const EQApplicationPacket *app)
void Client::Handle_OP_TributeMoney(const EQApplicationPacket *app) void Client::Handle_OP_TributeMoney(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeMoney of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeMoney of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
//player donates money //player donates money
@ -13805,7 +13805,7 @@ void Client::Handle_OP_TributeMoney(const EQApplicationPacket *app)
t->tribute_points = TributeMoney(t->platinum); t->tribute_points = TributeMoney(t->platinum);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Sending tribute money reply with %d points", t->tribute_points); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Sending tribute money reply with %d points", t->tribute_points);
_pkt(TRIBUTE__OUT, app); _pkt(TRIBUTE__OUT, app);
QueuePacket(app); QueuePacket(app);
@ -13815,7 +13815,7 @@ void Client::Handle_OP_TributeMoney(const EQApplicationPacket *app)
void Client::Handle_OP_TributeNPC(const EQApplicationPacket *app) void Client::Handle_OP_TributeNPC(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeNPC of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeNPC of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
return; return;
@ -13823,7 +13823,7 @@ void Client::Handle_OP_TributeNPC(const EQApplicationPacket *app)
void Client::Handle_OP_TributeToggle(const EQApplicationPacket *app) void Client::Handle_OP_TributeToggle(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeToggle of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeToggle of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
if (app->size != sizeof(uint32)) if (app->size != sizeof(uint32))
@ -13837,7 +13837,7 @@ void Client::Handle_OP_TributeToggle(const EQApplicationPacket *app)
void Client::Handle_OP_TributeUpdate(const EQApplicationPacket *app) void Client::Handle_OP_TributeUpdate(const EQApplicationPacket *app)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeUpdate of length %d", app->size); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tribute, "Received OP_TributeUpdate of length %d", app->size);
_pkt(TRIBUTE__IN, app); _pkt(TRIBUTE__IN, app);
//sent when the client changes their tribute settings... //sent when the client changes their tribute settings...

12
zone/client_process.cpp
View File

@ -1129,7 +1129,7 @@ uint8 Client::WithCustomer(uint16 NewCustomer){
Client* c = entity_list.GetClientByID(CustomerID); Client* c = entity_list.GetClientByID(CustomerID);
if(!c) { if(!c) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Previous customer has gone away."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Previous customer has gone away.");
CustomerID = NewCustomer; CustomerID = NewCustomer;
return 1; return 1;
} }
@ -1141,7 +1141,7 @@ void Client::OPRezzAnswer(uint32 Action, uint32 SpellID, uint16 ZoneID, uint16 I
{ {
if(PendingRezzXP < 0) { if(PendingRezzXP < 0) {
// pendingrezexp is set to -1 if we are not expecting an OP_RezzAnswer // pendingrezexp is set to -1 if we are not expecting an OP_RezzAnswer
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Unexpected OP_RezzAnswer. Ignoring it."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Unexpected OP_RezzAnswer. Ignoring it.");
Message(13, "You have already been resurrected.\n"); Message(13, "You have already been resurrected.\n");
return; return;
} }
@ -1151,7 +1151,7 @@ void Client::OPRezzAnswer(uint32 Action, uint32 SpellID, uint16 ZoneID, uint16 I
// Mark the corpse as rezzed in the database, just in case the corpse has buried, or the zone the // Mark the corpse as rezzed in the database, just in case the corpse has buried, or the zone the
// corpse is in has shutdown since the rez spell was cast. // corpse is in has shutdown since the rez spell was cast.
database.MarkCorpseAsRezzed(PendingRezzDBID); database.MarkCorpseAsRezzed(PendingRezzDBID);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Player %s got a %i Rezz, spellid %i in zone%i, instance id %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Player %s got a %i Rezz, spellid %i in zone%i, instance id %i",
this->name, (uint16)spells[SpellID].base[0], this->name, (uint16)spells[SpellID].base[0],
SpellID, ZoneID, InstanceID); SpellID, ZoneID, InstanceID);
@ -2122,7 +2122,7 @@ void Client::HandleRespawnFromHover(uint32 Option)
{ {
if (PendingRezzXP < 0 || PendingRezzSpellID == 0) if (PendingRezzXP < 0 || PendingRezzSpellID == 0)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Unexpected Rezz from hover request."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Unexpected Rezz from hover request.");
return; return;
} }
SetHP(GetMaxHP() / 5); SetHP(GetMaxHP() / 5);
@ -2155,10 +2155,10 @@ void Client::HandleRespawnFromHover(uint32 Option)
if (corpse && corpse->IsCorpse()) if (corpse && corpse->IsCorpse())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Hover Rez in zone %s for corpse %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Hover Rez in zone %s for corpse %s",
zone->GetShortName(), PendingRezzCorpseName.c_str()); zone->GetShortName(), PendingRezzCorpseName.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Found corpse. Marking corpse as rezzed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Found corpse. Marking corpse as rezzed.");
corpse->IsRezzed(true); corpse->IsRezzed(true);
corpse->CompleteResurrection(); corpse->CompleteResurrection();

14
zone/command.cpp
View File

@ -4546,10 +4546,10 @@ void command_guild(Client *c, const Seperator *sep)
} }
if(guild_id == GUILD_NONE) { if(guild_id == GUILD_NONE) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Removing %s (%d) from guild with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Removing %s (%d) from guild with GM command.", c->GetName(),
sep->arg[2], charid); sep->arg[2], charid);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Putting %s (%d) into guild %s (%d) with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Putting %s (%d) into guild %s (%d) with GM command.", c->GetName(),
sep->arg[2], charid, sep->arg[2], charid,
guild_mgr.GetGuildName(guild_id), guild_id); guild_mgr.GetGuildName(guild_id), guild_id);
} }
@ -4598,7 +4598,7 @@ void command_guild(Client *c, const Seperator *sep)
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Setting %s (%d)'s guild rank to %d with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Setting %s (%d)'s guild rank to %d with GM command.", c->GetName(),
sep->arg[2], charid, rank); sep->arg[2], charid, rank);
if(!guild_mgr.SetGuildRank(charid, rank)) if(!guild_mgr.SetGuildRank(charid, rank))
@ -4640,7 +4640,7 @@ void command_guild(Client *c, const Seperator *sep)
uint32 id = guild_mgr.CreateGuild(sep->argplus[3], leader); uint32 id = guild_mgr.CreateGuild(sep->argplus[3], leader);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Creating guild %s with leader %d with GM command. It was given id %lu.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Creating guild %s with leader %d with GM command. It was given id %lu.", c->GetName(),
sep->argplus[3], leader, (unsigned long)id); sep->argplus[3], leader, (unsigned long)id);
if (id == GUILD_NONE) if (id == GUILD_NONE)
@ -4679,7 +4679,7 @@ void command_guild(Client *c, const Seperator *sep)
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Deleting guild %s (%d) with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Deleting guild %s (%d) with GM command.", c->GetName(),
guild_mgr.GetGuildName(id), id); guild_mgr.GetGuildName(id), id);
if (!guild_mgr.DeleteGuild(id)) if (!guild_mgr.DeleteGuild(id))
@ -4713,7 +4713,7 @@ void command_guild(Client *c, const Seperator *sep)
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Renaming guild %s (%d) to '%s' with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Renaming guild %s (%d) to '%s' with GM command.", c->GetName(),
guild_mgr.GetGuildName(id), id, sep->argplus[3]); guild_mgr.GetGuildName(id), id, sep->argplus[3]);
if (!guild_mgr.RenameGuild(id, sep->argplus[3])) if (!guild_mgr.RenameGuild(id, sep->argplus[3]))
@ -4764,7 +4764,7 @@ void command_guild(Client *c, const Seperator *sep)
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Setting leader of guild %s (%d) to %d with GM command.", c->GetName(), logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "%s: Setting leader of guild %s (%d) to %d with GM command.", c->GetName(),
guild_mgr.GetGuildName(id), id, leader); guild_mgr.GetGuildName(id), id, leader);
if(!guild_mgr.SetGuildLeader(id, leader)) if(!guild_mgr.SetGuildLeader(id, leader))

6
zone/doors.cpp
View File

@ -145,9 +145,9 @@ bool Doors::Process()
void Doors::HandleClick(Client* sender, uint8 trigger) void Doors::HandleClick(Client* sender, uint8 trigger)
{ {
//door debugging info dump //door debugging info dump
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Doors, "%s clicked door %s (dbid %d, eqid %d) at (%.4f,%.4f,%.4f @%.4f)", sender->GetName(), door_name, db_id, door_id, pos_x, pos_y, pos_z, heading); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Doors, "%s clicked door %s (dbid %d, eqid %d) at (%.4f,%.4f,%.4f @%.4f)", sender->GetName(), door_name, db_id, door_id, pos_x, pos_y, pos_z, heading);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Doors, " incline %d, opentype %d, lockpick %d, key %d, nokeyring %d, trigger %d type %d, param %d", incline, opentype, lockpick, keyitem, nokeyring, trigger_door, trigger_type, door_param); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Doors, " incline %d, opentype %d, lockpick %d, key %d, nokeyring %d, trigger %d type %d, param %d", incline, opentype, lockpick, keyitem, nokeyring, trigger_door, trigger_type, door_param);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Doors, " size %d, invert %d, dest: %s (%.4f,%.4f,%.4f @%.4f)", size, invert_state, dest_zone, dest_x, dest_y, dest_z, dest_heading); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Doors, " size %d, invert %d, dest: %s (%.4f,%.4f,%.4f @%.4f)", size, invert_state, dest_zone, dest_x, dest_y, dest_z, dest_heading);
EQApplicationPacket* outapp = new EQApplicationPacket(OP_MoveDoor, sizeof(MoveDoor_Struct)); EQApplicationPacket* outapp = new EQApplicationPacket(OP_MoveDoor, sizeof(MoveDoor_Struct));
MoveDoor_Struct* md = (MoveDoor_Struct*)outapp->pBuffer; MoveDoor_Struct* md = (MoveDoor_Struct*)outapp->pBuffer;

2
zone/entity.cpp
View File

@ -3397,7 +3397,7 @@ void EntityList::ReloadAllClientsTaskState(int TaskID)
// If we have been passed a TaskID, only reload the client state if they have // If we have been passed a TaskID, only reload the client state if they have
// that Task active. // that Task active.
if ((!TaskID) || (TaskID && client->IsTaskActive(TaskID))) { if ((!TaskID) || (TaskID && client->IsTaskActive(TaskID))) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] Reloading Task State For Client %s", client->GetName()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] Reloading Task State For Client %s", client->GetName());
client->RemoveClientTaskState(); client->RemoveClientTaskState();
client->LoadClientTaskState(); client->LoadClientTaskState();
taskmanager->SendActiveTasksToClient(client); taskmanager->SendActiveTasksToClient(client);

4
zone/groups.cpp
View File

@ -768,7 +768,7 @@ void Group::CastGroupSpell(Mob* caster, uint16 spell_id) {
caster->SpellOnTarget(spell_id, members[z]->GetPet()); caster->SpellOnTarget(spell_id, members[z]->GetPet());
#endif #endif
} else } else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group spell: %s is out of range %f at distance %f from %s", members[z]->GetName(), range, distance, caster->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group spell: %s is out of range %f at distance %f from %s", members[z]->GetName(), range, distance, caster->GetName());
} }
} }
@ -807,7 +807,7 @@ void Group::GroupBardPulse(Mob* caster, uint16 spell_id) {
members[z]->GetPet()->BardPulse(spell_id, caster); members[z]->GetPet()->BardPulse(spell_id, caster);
#endif #endif
} else } else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group bard pulse: %s is out of range %f at distance %f from %s", members[z]->GetName(), range, distance, caster->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group bard pulse: %s is out of range %f at distance %f from %s", members[z]->GetName(), range, distance, caster->GetName());
} }
} }
} }

20
zone/guild_mgr.cpp
View File

@ -32,7 +32,7 @@ extern WorldServer worldserver;
extern volatile bool ZoneLoaded; extern volatile bool ZoneLoaded;
void ZoneGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd, bool rank, bool relation) { void ZoneGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd, bool rank, bool relation) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending guild refresh for %d to world, changes: name=%d, motd=%d, rank=d, relation=%d", guild_id, name, motd, rank, relation); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending guild refresh for %d to world, changes: name=%d, motd=%d, rank=d, relation=%d", guild_id, name, motd, rank, relation);
ServerPacket* pack = new ServerPacket(ServerOP_RefreshGuild, sizeof(ServerGuildRefresh_Struct)); ServerPacket* pack = new ServerPacket(ServerOP_RefreshGuild, sizeof(ServerGuildRefresh_Struct));
ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer; ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer;
s->guild_id = guild_id; s->guild_id = guild_id;
@ -46,7 +46,7 @@ void ZoneGuildManager::SendGuildRefresh(uint32 guild_id, bool name, bool motd, b
void ZoneGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, uint32 charid) { void ZoneGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, uint32 charid) {
if(guild_id == 0) { if(guild_id == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Guild lookup for char %d when sending char refresh.", charid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Guild lookup for char %d when sending char refresh.", charid);
CharGuildInfo gci; CharGuildInfo gci;
if(!GetCharInfo(charid, gci)) { if(!GetCharInfo(charid, gci)) {
@ -56,7 +56,7 @@ void ZoneGuildManager::SendCharRefresh(uint32 old_guild_id, uint32 guild_id, uin
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending char refresh for %d from guild %d to world", charid, guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending char refresh for %d from guild %d to world", charid, guild_id);
ServerPacket* pack = new ServerPacket(ServerOP_GuildCharRefresh, sizeof(ServerGuildCharRefresh_Struct)); ServerPacket* pack = new ServerPacket(ServerOP_GuildCharRefresh, sizeof(ServerGuildCharRefresh_Struct));
ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer; ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer;
@ -89,7 +89,7 @@ void ZoneGuildManager::SendRankUpdate(uint32 CharID)
} }
void ZoneGuildManager::SendGuildDelete(uint32 guild_id) { void ZoneGuildManager::SendGuildDelete(uint32 guild_id) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending guild delete for guild %d to world", guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Sending guild delete for guild %d to world", guild_id);
ServerPacket* pack = new ServerPacket(ServerOP_DeleteGuild, sizeof(ServerGuildID_Struct)); ServerPacket* pack = new ServerPacket(ServerOP_DeleteGuild, sizeof(ServerGuildID_Struct));
ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer; ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer;
s->guild_id = guild_id; s->guild_id = guild_id;
@ -266,7 +266,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
} }
ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer; ServerGuildRefresh_Struct *s = (ServerGuildRefresh_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild refresh from world for %d, changes: name=%d, motd=%d, rank=%d, relation=%d", s->guild_id, s->name_change, s->motd_change, s->rank_change, s->relation_change); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild refresh from world for %d, changes: name=%d, motd=%d, rank=%d, relation=%d", s->guild_id, s->name_change, s->motd_change, s->rank_change, s->relation_change);
//reload all the guild details from the database. //reload all the guild details from the database.
RefreshGuild(s->guild_id); RefreshGuild(s->guild_id);
@ -300,7 +300,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
} }
ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer; ServerGuildCharRefresh_Struct *s = (ServerGuildCharRefresh_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild member refresh from world for char %d from guild %d", s->char_id, s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild member refresh from world for char %d from guild %d", s->char_id, s->guild_id);
Client *c = entity_list.GetClientByCharID(s->char_id); Client *c = entity_list.GetClientByCharID(s->char_id);
@ -369,7 +369,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
} }
ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer; ServerGuildID_Struct *s = (ServerGuildID_Struct *) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild delete from world for guild %d", s->guild_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds, "Received guild delete from world for guild %d", s->guild_id);
//clear all the guild tags. //clear all the guild tags.
entity_list.RefreshAllGuildInfo(s->guild_id); entity_list.RefreshAllGuildInfo(s->guild_id);
@ -417,10 +417,10 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
if (!c || !c->IsInAGuild()) if (!c || !c->IsInAGuild())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Invalid Client or not in guild. ID=%i", FromID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Invalid Client or not in guild. ID=%i", FromID);
break; break;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Processing ServerOP_OnlineGuildMembersResponse"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Processing ServerOP_OnlineGuildMembersResponse");
EQApplicationPacket *outapp = new EQApplicationPacket(OP_GuildMemberUpdate, sizeof(GuildMemberUpdate_Struct)); EQApplicationPacket *outapp = new EQApplicationPacket(OP_GuildMemberUpdate, sizeof(GuildMemberUpdate_Struct));
GuildMemberUpdate_Struct *gmus = (GuildMemberUpdate_Struct*)outapp->pBuffer; GuildMemberUpdate_Struct *gmus = (GuildMemberUpdate_Struct*)outapp->pBuffer;
char Name[64]; char Name[64];
@ -433,7 +433,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
VARSTRUCT_DECODE_STRING(Name, Buffer); VARSTRUCT_DECODE_STRING(Name, Buffer);
strn0cpy(gmus->MemberName, Name, sizeof(gmus->MemberName)); strn0cpy(gmus->MemberName, Name, sizeof(gmus->MemberName));
gmus->ZoneID = VARSTRUCT_DECODE_TYPE(uint32, Buffer); gmus->ZoneID = VARSTRUCT_DECODE_TYPE(uint32, Buffer);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Sending OP_GuildMemberUpdate to %i. Name=%s ZoneID=%i",FromID,Name,gmus->ZoneID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Guilds,"Sending OP_GuildMemberUpdate to %i. Name=%s ZoneID=%i",FromID,Name,gmus->ZoneID);
c->QueuePacket(outapp); c->QueuePacket(outapp);
} }
safe_delete(outapp); safe_delete(outapp);

24
zone/inventory.cpp
View File

@ -2479,7 +2479,7 @@ void Client::CreateBandolier(const EQApplicationPacket *app) {
BandolierCreate_Struct *bs = (BandolierCreate_Struct*)app->pBuffer; BandolierCreate_Struct *bs = (BandolierCreate_Struct*)app->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Creating Bandolier Set %i, Set Name: %s", GetName(), bs->number, bs->name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Creating Bandolier Set %i, Set Name: %s", GetName(), bs->number, bs->name);
strcpy(m_pp.bandoliers[bs->number].name, bs->name); strcpy(m_pp.bandoliers[bs->number].name, bs->name);
const ItemInst* InvItem = nullptr; const ItemInst* InvItem = nullptr;
@ -2491,13 +2491,13 @@ void Client::CreateBandolier(const EQApplicationPacket *app) {
InvItem = GetInv()[WeaponSlot]; InvItem = GetInv()[WeaponSlot];
if(InvItem) { if(InvItem) {
BaseItem = InvItem->GetItem(); BaseItem = InvItem->GetItem();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s adding item %s to slot %i", GetName(),BaseItem->Name, WeaponSlot); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s adding item %s to slot %i", GetName(),BaseItem->Name, WeaponSlot);
m_pp.bandoliers[bs->number].items[BandolierSlot].item_id = BaseItem->ID; m_pp.bandoliers[bs->number].items[BandolierSlot].item_id = BaseItem->ID;
m_pp.bandoliers[bs->number].items[BandolierSlot].icon = BaseItem->Icon; m_pp.bandoliers[bs->number].items[BandolierSlot].icon = BaseItem->Icon;
database.SaveCharacterBandolier(this->CharacterID(), bs->number, BandolierSlot, m_pp.bandoliers[bs->number].items[BandolierSlot].item_id, m_pp.bandoliers[bs->number].items[BandolierSlot].icon, bs->name); database.SaveCharacterBandolier(this->CharacterID(), bs->number, BandolierSlot, m_pp.bandoliers[bs->number].items[BandolierSlot].item_id, m_pp.bandoliers[bs->number].items[BandolierSlot].icon, bs->name);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s no item in slot %i", GetName(), WeaponSlot); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s no item in slot %i", GetName(), WeaponSlot);
m_pp.bandoliers[bs->number].items[BandolierSlot].item_id = 0; m_pp.bandoliers[bs->number].items[BandolierSlot].item_id = 0;
m_pp.bandoliers[bs->number].items[BandolierSlot].icon = 0; m_pp.bandoliers[bs->number].items[BandolierSlot].icon = 0;
} }
@ -2506,7 +2506,7 @@ void Client::CreateBandolier(const EQApplicationPacket *app) {
void Client::RemoveBandolier(const EQApplicationPacket *app) { void Client::RemoveBandolier(const EQApplicationPacket *app) {
BandolierDelete_Struct *bds = (BandolierDelete_Struct*)app->pBuffer; BandolierDelete_Struct *bds = (BandolierDelete_Struct*)app->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s removing set", GetName(), bds->number); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s removing set", GetName(), bds->number);
memset(m_pp.bandoliers[bds->number].name, 0, 32); memset(m_pp.bandoliers[bds->number].name, 0, 32);
for(int i = bandolierMainHand; i <= bandolierAmmo; i++) { for(int i = bandolierMainHand; i <= bandolierAmmo; i++) {
m_pp.bandoliers[bds->number].items[i].item_id = 0; m_pp.bandoliers[bds->number].items[i].item_id = 0;
@ -2521,7 +2521,7 @@ void Client::SetBandolier(const EQApplicationPacket *app) {
// any items currently in the weapon slots to inventory. // any items currently in the weapon slots to inventory.
BandolierSet_Struct *bss = (BandolierSet_Struct*)app->pBuffer; BandolierSet_Struct *bss = (BandolierSet_Struct*)app->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s activating set %i", GetName(), bss->number); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s activating set %i", GetName(), bss->number);
int16 slot; int16 slot;
int16 WeaponSlot; int16 WeaponSlot;
ItemInst *BandolierItems[4]; // Temporary holding area for the weapons we pull out of their inventory ItemInst *BandolierItems[4]; // Temporary holding area for the weapons we pull out of their inventory
@ -2585,11 +2585,11 @@ void Client::SetBandolier(const EQApplicationPacket *app) {
else { // The player doesn't have the required weapon with them. else { // The player doesn't have the required weapon with them.
BandolierItems[BandolierSlot] = 0; BandolierItems[BandolierSlot] = 0;
if (slot == INVALID_INDEX) { if (slot == INVALID_INDEX) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Character does not have required bandolier item for slot %i", WeaponSlot); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Character does not have required bandolier item for slot %i", WeaponSlot);
ItemInst *InvItem = m_inv.PopItem(WeaponSlot); ItemInst *InvItem = m_inv.PopItem(WeaponSlot);
if(InvItem) { if(InvItem) {
// If there was an item in that weapon slot, put it in the inventory // If there was an item in that weapon slot, put it in the inventory
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "returning item %s in weapon slot %i to inventory", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "returning item %s in weapon slot %i to inventory",
InvItem->GetItem()->Name, WeaponSlot); InvItem->GetItem()->Name, WeaponSlot);
if(MoveItemToInventory(InvItem)) if(MoveItemToInventory(InvItem))
database.SaveInventory(character_id, 0, WeaponSlot); database.SaveInventory(character_id, 0, WeaponSlot);
@ -2640,7 +2640,7 @@ void Client::SetBandolier(const EQApplicationPacket *app) {
// put it in the player's inventory. // put it in the player's inventory.
ItemInst *InvItem = m_inv.PopItem(WeaponSlot); ItemInst *InvItem = m_inv.PopItem(WeaponSlot);
if(InvItem) { if(InvItem) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Bandolier has no item for slot %i, returning item %s to inventory", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Bandolier has no item for slot %i, returning item %s to inventory",
WeaponSlot, InvItem->GetItem()->Name); WeaponSlot, InvItem->GetItem()->Name);
// If there was an item in that weapon slot, put it in the inventory // If there was an item in that weapon slot, put it in the inventory
if(MoveItemToInventory(InvItem)) if(MoveItemToInventory(InvItem))
@ -2677,7 +2677,7 @@ bool Client::MoveItemToInventory(ItemInst *ItemToReturn, bool UpdateClient) {
if(!ItemToReturn) return false; if(!ItemToReturn) return false;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory,"Char: %s Returning %s to inventory", GetName(), ItemToReturn->GetItem()->Name); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory,"Char: %s Returning %s to inventory", GetName(), ItemToReturn->GetItem()->Name);
uint32 ItemID = ItemToReturn->GetItem()->ID; uint32 ItemID = ItemToReturn->GetItem()->ID;
@ -2761,7 +2761,7 @@ bool Client::MoveItemToInventory(ItemInst *ItemToReturn, bool UpdateClient) {
database.SaveInventory(character_id, m_inv.GetItem(i), i); database.SaveInventory(character_id, m_inv.GetItem(i), i);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Storing in main inventory slot %i", GetName(), i); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Storing in main inventory slot %i", GetName(), i);
return true; return true;
} }
@ -2784,7 +2784,7 @@ bool Client::MoveItemToInventory(ItemInst *ItemToReturn, bool UpdateClient) {
database.SaveInventory(character_id, m_inv.GetItem(BaseSlotID + BagSlot), BaseSlotID + BagSlot); database.SaveInventory(character_id, m_inv.GetItem(BaseSlotID + BagSlot), BaseSlotID + BagSlot);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Storing in bag slot %i", GetName(), BaseSlotID + BagSlot); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s Storing in bag slot %i", GetName(), BaseSlotID + BagSlot);
return true; return true;
} }
@ -2794,7 +2794,7 @@ bool Client::MoveItemToInventory(ItemInst *ItemToReturn, bool UpdateClient) {
// Store on the cursor // Store on the cursor
// //
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s No space, putting on the cursor", GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Inventory, "Char: %s No space, putting on the cursor", GetName());
PushItemOnCursor(*ItemToReturn, UpdateClient); PushItemOnCursor(*ItemToReturn, UpdateClient);

72
zone/net.cpp
View File

@ -148,7 +148,7 @@ int main(int argc, char** argv) {
worldserver.SetLauncherName("NONE"); worldserver.SetLauncherName("NONE");
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading server configuration.."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading server configuration..");
if (!ZoneConfig::LoadConfig()) { if (!ZoneConfig::LoadConfig()) {
logger.Log(EQEmuLogSys::Error, "Loading server configuration failed."); logger.Log(EQEmuLogSys::Error, "Loading server configuration failed.");
return 1; return 1;
@ -156,13 +156,13 @@ int main(int argc, char** argv) {
const ZoneConfig *Config=ZoneConfig::get(); const ZoneConfig *Config=ZoneConfig::get();
if(!load_log_settings(Config->LogSettingsFile.c_str())) if(!load_log_settings(Config->LogSettingsFile.c_str()))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Warning: Unable to read %s", Config->LogSettingsFile.c_str());
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Log settings loaded from %s", Config->LogSettingsFile.c_str());
worldserver.SetPassword(Config->SharedKey.c_str()); worldserver.SetPassword(Config->SharedKey.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Connecting to MySQL..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Connecting to MySQL...");
if (!database.Connect( if (!database.Connect(
Config->DatabaseHost.c_str(), Config->DatabaseHost.c_str(),
Config->DatabaseUsername.c_str(), Config->DatabaseUsername.c_str(),
@ -186,7 +186,7 @@ int main(int argc, char** argv) {
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif #endif
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "CURRENT_VERSION: %s", CURRENT_VERSION); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "CURRENT_VERSION: %s", CURRENT_VERSION);
/* /*
* Setup nice signal handlers * Setup nice signal handlers
@ -208,99 +208,99 @@ int main(int argc, char** argv) {
const char *log_ini_file = "./log.ini"; const char *log_ini_file = "./log.ini";
if(!load_log_settings(log_ini_file)) if(!load_log_settings(log_ini_file))
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Warning: Unable to read %s", log_ini_file); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Warning: Unable to read %s", log_ini_file);
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Log settings loaded from %s", log_ini_file); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Log settings loaded from %s", log_ini_file);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Mapping Incoming Opcodes"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Mapping Incoming Opcodes");
MapOpcodes(); MapOpcodes();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading Variables"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading Variables");
database.LoadVariables(); database.LoadVariables();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading zone names"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading zone names");
database.LoadZoneNames(); database.LoadZoneNames();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading items"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading items");
if (!database.LoadItems()) { if (!database.LoadItems()) {
logger.Log(EQEmuLogSys::Error, "Loading items FAILED!"); logger.Log(EQEmuLogSys::Error, "Loading items FAILED!");
logger.Log(EQEmuLogSys::Error, "Failed. But ignoring error and going on..."); logger.Log(EQEmuLogSys::Error, "Failed. But ignoring error and going on...");
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading npc faction lists"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading npc faction lists");
if (!database.LoadNPCFactionLists()) { if (!database.LoadNPCFactionLists()) {
logger.Log(EQEmuLogSys::Error, "Loading npcs faction lists FAILED!"); logger.Log(EQEmuLogSys::Error, "Loading npcs faction lists FAILED!");
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
return 1; return 1;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading loot tables"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading loot tables");
if (!database.LoadLoot()) { if (!database.LoadLoot()) {
logger.Log(EQEmuLogSys::Error, "Loading loot FAILED!"); logger.Log(EQEmuLogSys::Error, "Loading loot FAILED!");
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
return 1; return 1;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading skill caps"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading skill caps");
if (!database.LoadSkillCaps()) { if (!database.LoadSkillCaps()) {
logger.Log(EQEmuLogSys::Error, "Loading skill caps FAILED!"); logger.Log(EQEmuLogSys::Error, "Loading skill caps FAILED!");
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
return 1; return 1;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading spells"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading spells");
EQEmu::MemoryMappedFile *mmf = nullptr; EQEmu::MemoryMappedFile *mmf = nullptr;
LoadSpells(&mmf); LoadSpells(&mmf);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading base data"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading base data");
if (!database.LoadBaseData()) { if (!database.LoadBaseData()) {
logger.Log(EQEmuLogSys::Error, "Loading base data FAILED!"); logger.Log(EQEmuLogSys::Error, "Loading base data FAILED!");
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
return 1; return 1;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading guilds"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading guilds");
guild_mgr.LoadGuilds(); guild_mgr.LoadGuilds();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading factions"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading factions");
database.LoadFactionData(); database.LoadFactionData();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading titles"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading titles");
title_manager.LoadTitles(); title_manager.LoadTitles();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading AA effects"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading AA effects");
database.LoadAAEffects(); database.LoadAAEffects();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading tributes"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading tributes");
database.LoadTributes(); database.LoadTributes();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading corpse timers"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading corpse timers");
database.GetDecayTimes(npcCorpseDecayTimes); database.GetDecayTimes(npcCorpseDecayTimes);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading commands"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading commands");
int retval=command_init(); int retval=command_init();
if(retval<0) if(retval<0)
logger.Log(EQEmuLogSys::Error, "Command loading FAILED"); logger.Log(EQEmuLogSys::Error, "Command loading FAILED");
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "%d commands loaded", retval); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "%d commands loaded", retval);
//rules: //rules:
{ {
char tmp[64]; char tmp[64];
if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) { if (database.GetVariable("RuleSet", tmp, sizeof(tmp)-1)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading rule set '%s'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading rule set '%s'", tmp);
if(!RuleManager::Instance()->LoadRules(&database, tmp)) { if(!RuleManager::Instance()->LoadRules(&database, tmp)) {
logger.Log(EQEmuLogSys::Error, "Failed to load ruleset '%s', falling back to defaults.", tmp); logger.Log(EQEmuLogSys::Error, "Failed to load ruleset '%s', falling back to defaults.", tmp);
} }
} else { } else {
if(!RuleManager::Instance()->LoadRules(&database, "default")) { if(!RuleManager::Instance()->LoadRules(&database, "default")) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "No rule set configured, using default rules"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "No rule set configured, using default rules");
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loaded default rule set 'default'", tmp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loaded default rule set 'default'", tmp);
} }
} }
} }
if(RuleB(TaskSystem, EnableTaskSystem)) { if(RuleB(TaskSystem, EnableTaskSystem)) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[INIT] Loading Tasks"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[INIT] Loading Tasks");
taskmanager = new TaskManager; taskmanager = new TaskManager;
taskmanager->LoadTasks(); taskmanager->LoadTasks();
} }
@ -317,7 +317,7 @@ int main(int argc, char** argv) {
#endif #endif
//now we have our parser, load the quests //now we have our parser, load the quests
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading quests"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Loading quests");
parse->ReloadQuests(); parse->ReloadQuests();
if (!worldserver.Connect()) { if (!worldserver.Connect()) {
@ -332,7 +332,7 @@ int main(int argc, char** argv) {
#endif #endif
#endif #endif
if (!strlen(zone_name) || !strcmp(zone_name,".")) { if (!strlen(zone_name) || !strcmp(zone_name,".")) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Entering sleep mode"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Entering sleep mode");
} else if (!Zone::Bootup(database.GetZoneID(zone_name), 0, true)) { //todo: go above and fix this to allow cmd line instance } else if (!Zone::Bootup(database.GetZoneID(zone_name), 0, true)) { //todo: go above and fix this to allow cmd line instance
logger.Log(EQEmuLogSys::Error, "Zone Bootup failed :: Zone::Bootup"); logger.Log(EQEmuLogSys::Error, "Zone Bootup failed :: Zone::Bootup");
zone = 0; zone = 0;
@ -365,7 +365,7 @@ int main(int argc, char** argv) {
worldserver.Process(); worldserver.Process();
if (!eqsf.IsOpen() && Config->ZonePort!=0) { if (!eqsf.IsOpen() && Config->ZonePort!=0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Starting EQ Network server on port %d",Config->ZonePort); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Starting EQ Network server on port %d",Config->ZonePort);
// log_sys.CloseZoneLogs(); // log_sys.CloseZoneLogs();
// log_sys.StartZoneLogs(StringFormat("%s_ver-%u_instid-%u_port-%u", zone->GetShortName(), zone->GetInstanceVersion(), zone->GetInstanceID(), ZoneConfig::get()->ZonePort)); // log_sys.StartZoneLogs(StringFormat("%s_ver-%u_instid-%u_port-%u", zone->GetShortName(), zone->GetInstanceVersion(), zone->GetInstanceID(), ZoneConfig::get()->ZonePort));
@ -385,7 +385,7 @@ int main(int argc, char** argv) {
//structures and opcodes for that patch. //structures and opcodes for that patch.
struct in_addr in; struct in_addr in;
in.s_addr = eqss->GetRemoteIP(); in.s_addr = eqss->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d", inet_ntoa(in),ntohs(eqss->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New connection from %s:%d", inet_ntoa(in),ntohs(eqss->GetRemotePort()));
stream_identifier.AddStream(eqss); //takes the stream stream_identifier.AddStream(eqss); //takes the stream
} }
@ -397,7 +397,7 @@ int main(int argc, char** argv) {
//now that we know what patch they are running, start up their client object //now that we know what patch they are running, start up their client object
struct in_addr in; struct in_addr in;
in.s_addr = eqsi->GetRemoteIP(); in.s_addr = eqsi->GetRemoteIP();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New client from %s:%d", inet_ntoa(in), ntohs(eqsi->GetRemotePort())); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::World_Server, "New client from %s:%d", inet_ntoa(in), ntohs(eqsi->GetRemotePort()));
Client* client = new Client(eqsi); Client* client = new Client(eqsi);
entity_list.AddClient(client); entity_list.AddClient(client);
} }
@ -522,13 +522,13 @@ int main(int argc, char** argv) {
command_deinit(); command_deinit();
safe_delete(parse); safe_delete(parse);
CheckEQEMuErrorAndPause(); CheckEQEMuErrorAndPause();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Proper zone shutdown complete."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Proper zone shutdown complete.");
return 0; return 0;
} }
void CatchSignal(int sig_num) { void CatchSignal(int sig_num) {
#ifdef _WINDOWS #ifdef _WINDOWS
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Recieved signal: %i", sig_num); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Recieved signal: %i", sig_num);
#endif #endif
RunLoops = false; RunLoops = false;
} }
@ -539,7 +539,7 @@ void Shutdown()
RunLoops = false; RunLoops = false;
worldserver.Disconnect(); worldserver.Disconnect();
// safe_delete(worldserver); // safe_delete(worldserver);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Shutting down..."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Shutting down...");
} }
uint32 NetConnection::GetIP() uint32 NetConnection::GetIP()

2
zone/questmgr.cpp
View File

@ -2074,7 +2074,7 @@ bool QuestManager::istaskenabled(int taskid) {
void QuestManager::tasksetselector(int tasksetid) { void QuestManager::tasksetselector(int tasksetid) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSetSelector called for task set %i", tasksetid); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSetSelector called for task set %i", tasksetid);
if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && taskmanager) if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && taskmanager)
initiator->TaskSetSelector(owner, tasksetid); initiator->TaskSetSelector(owner, tasksetid);
} }

4
zone/raids.cpp
View File

@ -498,7 +498,7 @@ void Raid::CastGroupSpell(Mob* caster, uint16 spellid, uint32 gid)
#endif #endif
} }
else{ else{
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Raid spell: %s is out of range %f at distance %f from %s", members[x].member->GetName(), range, distance, caster->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Raid spell: %s is out of range %f at distance %f from %s", members[x].member->GetName(), range, distance, caster->GetName());
} }
} }
} }
@ -799,7 +799,7 @@ void Raid::GroupBardPulse(Mob* caster, uint16 spellid, uint32 gid){
members[z].member->GetPet()->BardPulse(spellid, caster); members[z].member->GetPet()->BardPulse(spellid, caster);
#endif #endif
} else } else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group bard pulse: %s is out of range %f at distance %f from %s", members[z].member->GetName(), range, distance, caster->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Group bard pulse: %s is out of range %f at distance %f from %s", members[z].member->GetName(), range, distance, caster->GetName());
} }
} }
} }

130
zone/spawn2.cpp
View File

@ -153,13 +153,13 @@ bool Spawn2::Process() {
if (timer.Check()) { if (timer.Check()) {
timer.Disable(); timer.Disable();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Timer has triggered", spawn2_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Timer has triggered", spawn2_id);
//first check our spawn condition, if this isnt active //first check our spawn condition, if this isnt active
//then we reset the timer and try again next time. //then we reset the timer and try again next time.
if(condition_id != SC_AlwaysEnabled if(condition_id != SC_AlwaysEnabled
&& !zone->spawn_conditions.Check(condition_id, condition_min_value)) { && !zone->spawn_conditions.Check(condition_id, condition_min_value)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: spawning prevented by spawn condition %d", spawn2_id, condition_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: spawning prevented by spawn condition %d", spawn2_id, condition_id);
Reset(); Reset();
return(true); return(true);
} }
@ -170,14 +170,14 @@ bool Spawn2::Process() {
} }
if (sg == nullptr) { if (sg == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Unable to locate spawn group %d. Disabling.", spawn2_id, spawngroup_id_); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Unable to locate spawn group %d. Disabling.", spawn2_id, spawngroup_id_);
return false; return false;
} }
//have the spawn group pick an NPC for us //have the spawn group pick an NPC for us
uint32 npcid = sg->GetNPCType(); uint32 npcid = sg->GetNPCType();
if (npcid == 0) { if (npcid == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d did not yeild an NPC! not spawning.", spawn2_id, spawngroup_id_); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d did not yeild an NPC! not spawning.", spawn2_id, spawngroup_id_);
Reset(); //try again later (why?) Reset(); //try again later (why?)
return(true); return(true);
} }
@ -185,7 +185,7 @@ bool Spawn2::Process() {
//try to find our NPC type. //try to find our NPC type.
const NPCType* tmp = database.GetNPCType(npcid); const NPCType* tmp = database.GetNPCType(npcid);
if (tmp == nullptr) { if (tmp == nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded an invalid NPC type %d", spawn2_id, spawngroup_id_, npcid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded an invalid NPC type %d", spawn2_id, spawngroup_id_, npcid);
Reset(); //try again later Reset(); //try again later
return(true); return(true);
} }
@ -194,7 +194,7 @@ bool Spawn2::Process() {
{ {
if(!entity_list.LimitCheckName(tmp->name)) if(!entity_list.LimitCheckName(tmp->name))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded NPC type %d, which is unique and one already exists.", spawn2_id, spawngroup_id_, npcid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded NPC type %d, which is unique and one already exists.", spawn2_id, spawngroup_id_, npcid);
timer.Start(5000); //try again in five seconds. timer.Start(5000); //try again in five seconds.
return(true); return(true);
} }
@ -202,7 +202,7 @@ bool Spawn2::Process() {
if(tmp->spawn_limit > 0) { if(tmp->spawn_limit > 0) {
if(!entity_list.LimitCheckType(npcid, tmp->spawn_limit)) { if(!entity_list.LimitCheckType(npcid, tmp->spawn_limit)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded NPC type %d, which is over its spawn limit (%d)", spawn2_id, spawngroup_id_, npcid, tmp->spawn_limit); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d yeilded NPC type %d, which is over its spawn limit (%d)", spawn2_id, spawngroup_id_, npcid, tmp->spawn_limit);
timer.Start(5000); //try again in five seconds. timer.Start(5000); //try again in five seconds.
return(true); return(true);
} }
@ -233,10 +233,10 @@ bool Spawn2::Process() {
if(sg->roamdist && sg->roambox[0] && sg->roambox[1] && sg->roambox[2] && sg->roambox[3] && sg->delay && sg->min_delay) if(sg->roamdist && sg->roambox[0] && sg->roambox[1] && sg->roambox[2] && sg->roambox[3] && sg->delay && sg->min_delay)
npc->AI_SetRoambox(sg->roamdist,sg->roambox[0],sg->roambox[1],sg->roambox[2],sg->roambox[3],sg->delay,sg->min_delay); npc->AI_SetRoambox(sg->roamdist,sg->roambox[0],sg->roambox[1],sg->roambox[2],sg->roambox[3],sg->delay,sg->min_delay);
if(zone->InstantGrids()) { if(zone->InstantGrids()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Group %d spawned %s (%d) at (%.3f, %.3f, %.3f).", spawn2_id, spawngroup_id_, npc->GetName(), npcid, x, y, z); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Group %d spawned %s (%d) at (%.3f, %.3f, %.3f).", spawn2_id, spawngroup_id_, npc->GetName(), npcid, x, y, z);
LoadGrid(); LoadGrid();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Group %d spawned %s (%d) at (%.3f, %.3f, %.3f). Grid loading delayed.", spawn2_id, spawngroup_id_, tmp->name, npcid, x, y, z); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Group %d spawned %s (%d) at (%.3f, %.3f, %.3f). Grid loading delayed.", spawn2_id, spawngroup_id_, tmp->name, npcid, x, y, z);
} }
} }
return true; return true;
@ -261,7 +261,7 @@ void Spawn2::LoadGrid() {
//dont set an NPC's grid until its loaded for them. //dont set an NPC's grid until its loaded for them.
npcthis->SetGrid(grid_); npcthis->SetGrid(grid_);
npcthis->AssignWaypoints(grid_); npcthis->AssignWaypoints(grid_);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Loading grid %d for %s", spawn2_id, grid_, npcthis->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Loading grid %d for %s", spawn2_id, grid_, npcthis->GetName());
} }
@ -272,21 +272,21 @@ void Spawn2::LoadGrid() {
void Spawn2::Reset() { void Spawn2::Reset() {
timer.Start(resetTimer()); timer.Start(resetTimer());
npcthis = nullptr; npcthis = nullptr;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop in %d ms", spawn2_id, timer.GetRemainingTime()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop in %d ms", spawn2_id, timer.GetRemainingTime());
} }
void Spawn2::Depop() { void Spawn2::Depop() {
timer.Disable(); timer.Disable();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop disabled", spawn2_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop disabled", spawn2_id);
npcthis = nullptr; npcthis = nullptr;
} }
void Spawn2::Repop(uint32 delay) { void Spawn2::Repop(uint32 delay) {
if (delay == 0) { if (delay == 0) {
timer.Trigger(); timer.Trigger();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop immediately.", spawn2_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset, repop immediately.", spawn2_id);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset for repop, repop in %d ms", spawn2_id, delay); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset for repop, repop in %d ms", spawn2_id, delay);
timer.Start(delay); timer.Start(delay);
} }
npcthis = nullptr; npcthis = nullptr;
@ -328,7 +328,7 @@ void Spawn2::ForceDespawn()
cur = despawnTimer(dtimer); cur = despawnTimer(dtimer);
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d set despawn timer to %d ms.", spawn2_id, spawngroup_id_, cur); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn group %d set despawn timer to %d ms.", spawn2_id, spawngroup_id_, cur);
timer.Start(cur); timer.Start(cur);
} }
@ -349,7 +349,7 @@ void Spawn2::DeathReset(bool realdeath)
if(spawn2_id) if(spawn2_id)
{ {
database.UpdateSpawn2Timeleft(spawn2_id, zone->GetInstanceID(), (cur/1000)); database.UpdateSpawn2Timeleft(spawn2_id, zone->GetInstanceID(), (cur/1000));
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset by death, repop in %d ms", spawn2_id, timer.GetRemainingTime()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Spawn reset by death, repop in %d ms", spawn2_id, timer.GetRemainingTime());
//store it to database too //store it to database too
} }
} }
@ -466,12 +466,12 @@ void Spawn2::SpawnConditionChanged(const SpawnCondition &c, int16 old_value) {
if(GetSpawnCondition() != c.condition_id) if(GetSpawnCondition() != c.condition_id)
return; return;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Notified that our spawn condition %d has changed from %d to %d. Our min value is %d.", spawn2_id, c.condition_id, old_value, c.value, condition_min_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Notified that our spawn condition %d has changed from %d to %d. Our min value is %d.", spawn2_id, c.condition_id, old_value, c.value, condition_min_value);
bool old_state = (old_value >= condition_min_value); bool old_state = (old_value >= condition_min_value);
bool new_state = (c.value >= condition_min_value); bool new_state = (c.value >= condition_min_value);
if(old_state == new_state) { if(old_state == new_state) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our threshold for this condition was not crossed. Doing nothing.", spawn2_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our threshold for this condition was not crossed. Doing nothing.", spawn2_id);
return; //no change return; //no change
} }
@ -479,50 +479,50 @@ void Spawn2::SpawnConditionChanged(const SpawnCondition &c, int16 old_value) {
switch(c.on_change) { switch(c.on_change) {
case SpawnCondition::DoNothing: case SpawnCondition::DoNothing:
//that was easy. //that was easy.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Taking no action on existing spawn.", spawn2_id, new_state?"enabled":"disabled"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Taking no action on existing spawn.", spawn2_id, new_state?"enabled":"disabled");
break; break;
case SpawnCondition::DoDepop: case SpawnCondition::DoDepop:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Depoping our mob.", spawn2_id, new_state?"enabled":"disabled"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Depoping our mob.", spawn2_id, new_state?"enabled":"disabled");
if(npcthis != nullptr) if(npcthis != nullptr)
npcthis->Depop(false); //remove the current mob npcthis->Depop(false); //remove the current mob
Reset(); //reset our spawn timer Reset(); //reset our spawn timer
break; break;
case SpawnCondition::DoRepop: case SpawnCondition::DoRepop:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Forcing a repop.", spawn2_id, new_state?"enabled":"disabled"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Forcing a repop.", spawn2_id, new_state?"enabled":"disabled");
if(npcthis != nullptr) if(npcthis != nullptr)
npcthis->Depop(false); //remove the current mob npcthis->Depop(false); //remove the current mob
Repop(); //repop Repop(); //repop
break; break;
case SpawnCondition::DoRepopIfReady: case SpawnCondition::DoRepopIfReady:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Forcing a repop if repsawn timer is expired.", spawn2_id, new_state?"enabled":"disabled"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Forcing a repop if repsawn timer is expired.", spawn2_id, new_state?"enabled":"disabled");
if(npcthis != nullptr) { if(npcthis != nullptr) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our npcthis is currently not null. The zone thinks it is %s. Forcing a depop.", spawn2_id, npcthis->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our npcthis is currently not null. The zone thinks it is %s. Forcing a depop.", spawn2_id, npcthis->GetName());
npcthis->Depop(false); //remove the current mob npcthis->Depop(false); //remove the current mob
npcthis = nullptr; npcthis = nullptr;
} }
if(new_state) { // only get repawn timer remaining when the SpawnCondition is enabled. if(new_state) { // only get repawn timer remaining when the SpawnCondition is enabled.
timer_remaining = database.GetSpawnTimeLeft(spawn2_id,zone->GetInstanceID()); timer_remaining = database.GetSpawnTimeLeft(spawn2_id,zone->GetInstanceID());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns,"Spawn2 %d: Our condition is now %s. The respawn timer_remaining is %d. Forcing a repop if it is <= 0.", spawn2_id, new_state?"enabled":"disabled", timer_remaining); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns,"Spawn2 %d: Our condition is now %s. The respawn timer_remaining is %d. Forcing a repop if it is <= 0.", spawn2_id, new_state?"enabled":"disabled", timer_remaining);
if(timer_remaining <= 0) if(timer_remaining <= 0)
Repop(); Repop();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns,"Spawn2 %d: Our condition is now %s. Not checking respawn timer.", spawn2_id, new_state?"enabled":"disabled"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns,"Spawn2 %d: Our condition is now %s. Not checking respawn timer.", spawn2_id, new_state?"enabled":"disabled");
} }
break; break;
default: default:
if(c.on_change < SpawnCondition::DoSignalMin) { if(c.on_change < SpawnCondition::DoSignalMin) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Invalid on-change action %d.", spawn2_id, new_state?"enabled":"disabled", c.on_change); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Invalid on-change action %d.", spawn2_id, new_state?"enabled":"disabled", c.on_change);
return; //unknown onchange action return; //unknown onchange action
} }
int signal_id = c.on_change - SpawnCondition::DoSignalMin; int signal_id = c.on_change - SpawnCondition::DoSignalMin;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Signaling our mob with %d.", spawn2_id, new_state?"enabled":"disabled", signal_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn2 %d: Our condition is now %s. Signaling our mob with %d.", spawn2_id, new_state?"enabled":"disabled", signal_id);
if(npcthis != nullptr) if(npcthis != nullptr)
npcthis->SignalNPC(signal_id); npcthis->SignalNPC(signal_id);
} }
} }
void Zone::SpawnConditionChanged(const SpawnCondition &c, int16 old_value) { void Zone::SpawnConditionChanged(const SpawnCondition &c, int16 old_value) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Zone notified that spawn condition %d has changed from %d to %d. Notifying all spawn points.", c.condition_id, old_value, c.value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Zone notified that spawn condition %d has changed from %d to %d. Notifying all spawn points.", c.condition_id, old_value, c.value);
LinkedListIterator<Spawn2*> iterator(spawn2_list); LinkedListIterator<Spawn2*> iterator(spawn2_list);
@ -592,7 +592,7 @@ void SpawnConditionManager::Process() {
EQTime::AddMinutes(cevent.period, &cevent.next); EQTime::AddMinutes(cevent.period, &cevent.next);
std::string t; std::string t;
EQTime::ToString(&cevent.next, t); EQTime::ToString(&cevent.next, t);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Will trigger again in %d EQ minutes at %s.", cevent.id, cevent.period, t.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Will trigger again in %d EQ minutes at %s.", cevent.id, cevent.period, t.c_str());
//save the next event time in the DB //save the next event time in the DB
UpdateDBEvent(cevent); UpdateDBEvent(cevent);
//find the next closest event timer. //find the next closest event timer.
@ -611,7 +611,7 @@ void SpawnConditionManager::ExecEvent(SpawnEvent &event, bool send_update) {
std::map<uint16, SpawnCondition>::iterator condi; std::map<uint16, SpawnCondition>::iterator condi;
condi = spawn_conditions.find(event.condition_id); condi = spawn_conditions.find(event.condition_id);
if(condi == spawn_conditions.end()) { if(condi == spawn_conditions.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Unable to find condition %d to execute on.", event.id, event.condition_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Unable to find condition %d to execute on.", event.id, event.condition_id);
return; //unable to find the spawn condition to operate on return; //unable to find the spawn condition to operate on
} }
@ -619,7 +619,7 @@ void SpawnConditionManager::ExecEvent(SpawnEvent &event, bool send_update) {
zone->zone_time.getEQTimeOfDay(&tod); zone->zone_time.getEQTimeOfDay(&tod);
if(event.strict && (event.next.hour != tod.hour || event.next.day != tod.day || event.next.month != tod.month || event.next.year != tod.year)) if(event.strict && (event.next.hour != tod.hour || event.next.day != tod.day || event.next.month != tod.month || event.next.year != tod.year))
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Unable to execute. Condition is strict, and event time has already passed.", event.id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Unable to execute. Condition is strict, and event time has already passed.", event.id);
return; return;
} }
@ -631,26 +631,26 @@ void SpawnConditionManager::ExecEvent(SpawnEvent &event, bool send_update) {
switch(event.action) { switch(event.action) {
case SpawnEvent::ActionSet: case SpawnEvent::ActionSet:
new_value = event.argument; new_value = event.argument;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Setting condition %d to %d.", event.id, event.condition_id, event.argument); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Setting condition %d to %d.", event.id, event.condition_id, event.argument);
break; break;
case SpawnEvent::ActionAdd: case SpawnEvent::ActionAdd:
new_value += event.argument; new_value += event.argument;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Adding %d to condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Adding %d to condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value);
break; break;
case SpawnEvent::ActionSubtract: case SpawnEvent::ActionSubtract:
new_value -= event.argument; new_value -= event.argument;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Subtracting %d from condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Subtracting %d from condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value);
break; break;
case SpawnEvent::ActionMultiply: case SpawnEvent::ActionMultiply:
new_value *= event.argument; new_value *= event.argument;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Multiplying condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Multiplying condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value);
break; break;
case SpawnEvent::ActionDivide: case SpawnEvent::ActionDivide:
new_value /= event.argument; new_value /= event.argument;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Dividing condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Executing. Dividing condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value);
break; break;
default: default:
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Invalid event action type %d", event.id, event.action); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Event %d: Invalid event action type %d", event.id, event.action);
return; return;
} }
@ -727,7 +727,7 @@ bool SpawnConditionManager::LoadDBEvent(uint32 event_id, SpawnEvent &event, std:
std::string timeAsString; std::string timeAsString;
EQTime::ToString(&event.next, timeAsString); EQTime::ToString(&event.next, timeAsString);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "(LoadDBEvent) Loaded %s spawn event %d on condition %d with period %d, action %d, argument %d, strict %d. Will trigger at %s", event.enabled? "enabled": "disabled", event.id, event.condition_id, event.period, event.action, event.argument, event.strict, timeAsString.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "(LoadDBEvent) Loaded %s spawn event %d on condition %d with period %d, action %d, argument %d, strict %d. Will trigger at %s", event.enabled? "enabled": "disabled", event.id, event.condition_id, event.period, event.action, event.argument, event.strict, timeAsString.c_str());
return true; return true;
} }
@ -755,7 +755,7 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
cond.on_change = (SpawnCondition::OnChange) atoi(row[1]); cond.on_change = (SpawnCondition::OnChange) atoi(row[1]);
spawn_conditions[cond.condition_id] = cond; spawn_conditions[cond.condition_id] = cond;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Loaded spawn condition %d with value %d and on_change %d", cond.condition_id, cond.value, cond.on_change); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Loaded spawn condition %d with value %d and on_change %d", cond.condition_id, cond.value, cond.on_change);
} }
//load values //load values
@ -811,7 +811,7 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
spawn_events.push_back(event); spawn_events.push_back(event);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "(LoadSpawnConditions) Loaded %s spawn event %d on condition %d with period %d, action %d, argument %d, strict %d", event.enabled? "enabled": "disabled", event.id, event.condition_id, event.period, event.action, event.argument, event.strict); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "(LoadSpawnConditions) Loaded %s spawn event %d on condition %d with period %d, action %d, argument %d, strict %d", event.enabled? "enabled": "disabled", event.id, event.condition_id, event.period, event.action, event.argument, event.strict);
} }
//now we need to catch up on events that happened while we were away //now we need to catch up on events that happened while we were away
@ -846,7 +846,7 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
//watch for special case of all 0s, which means to reset next to now //watch for special case of all 0s, which means to reset next to now
if(cevent.next.year == 0 && cevent.next.month == 0 && cevent.next.day == 0 && cevent.next.hour == 0 && cevent.next.minute == 0) { if(cevent.next.year == 0 && cevent.next.month == 0 && cevent.next.day == 0 && cevent.next.hour == 0 && cevent.next.minute == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Initial next trigger time set for spawn event %d", cevent.id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Initial next trigger time set for spawn event %d", cevent.id);
memcpy(&cevent.next, &tod, sizeof(cevent.next)); memcpy(&cevent.next, &tod, sizeof(cevent.next));
//add one period //add one period
EQTime::AddMinutes(cevent.period, &cevent.next); EQTime::AddMinutes(cevent.period, &cevent.next);
@ -857,7 +857,7 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
bool ran = false; bool ran = false;
while(EQTime::IsTimeBefore(&tod, &cevent.next)) { while(EQTime::IsTimeBefore(&tod, &cevent.next)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Catch up triggering on event %d", cevent.id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Catch up triggering on event %d", cevent.id);
//this event has been triggered. //this event has been triggered.
//execute the event //execute the event
if(!cevent.strict || StrictCheck) if(!cevent.strict || StrictCheck)
@ -900,9 +900,9 @@ void SpawnConditionManager::FindNearestEvent() {
} }
} }
if(next_id == -1) if(next_id == -1)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "No spawn events enabled. Disabling next event."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "No spawn events enabled. Disabling next event.");
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Next event determined to be event %d", next_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Next event determined to be event %d", next_id);
} }
void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance_id, uint16 condition_id, int16 new_value, bool world_update) void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance_id, uint16 condition_id, int16 new_value, bool world_update)
@ -914,14 +914,14 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
std::map<uint16, SpawnCondition>::iterator condi; std::map<uint16, SpawnCondition>::iterator condi;
condi = spawn_conditions.find(condition_id); condi = spawn_conditions.find(condition_id);
if(condi == spawn_conditions.end()) { if(condi == spawn_conditions.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d, but we do not have that conditon.", condition_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d, but we do not have that conditon.", condition_id);
return; //unable to find the spawn condition return; //unable to find the spawn condition
} }
SpawnCondition &cond = condi->second; SpawnCondition &cond = condi->second;
if(cond.value == new_value) { if(cond.value == new_value) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d with value %d, which is what we already have.", condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d with value %d, which is what we already have.", condition_id, new_value);
return; return;
} }
@ -930,7 +930,7 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
//set our local value //set our local value
cond.value = new_value; cond.value = new_value;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d with value %d", condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Condition update received from world for %d with value %d", condition_id, new_value);
//now we have to test each spawn point to see if it changed. //now we have to test each spawn point to see if it changed.
zone->SpawnConditionChanged(cond, old_value); zone->SpawnConditionChanged(cond, old_value);
@ -941,14 +941,14 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
std::map<uint16, SpawnCondition>::iterator condi; std::map<uint16, SpawnCondition>::iterator condi;
condi = spawn_conditions.find(condition_id); condi = spawn_conditions.find(condition_id);
if(condi == spawn_conditions.end()) { if(condi == spawn_conditions.end()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d, but we do not have that conditon.", condition_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d, but we do not have that conditon.", condition_id);
return; //unable to find the spawn condition return; //unable to find the spawn condition
} }
SpawnCondition &cond = condi->second; SpawnCondition &cond = condi->second;
if(cond.value == new_value) { if(cond.value == new_value) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d with value %d, which is what we already have.", condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d with value %d, which is what we already have.", condition_id, new_value);
return; return;
} }
@ -959,7 +959,7 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
//save it in the DB too //save it in the DB too
UpdateDBCondition(zone_short, instance_id, condition_id, new_value); UpdateDBCondition(zone_short, instance_id, condition_id, new_value);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d with value %d", condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Local Condition update requested for %d with value %d", condition_id, new_value);
//now we have to test each spawn point to see if it changed. //now we have to test each spawn point to see if it changed.
zone->SpawnConditionChanged(cond, old_value); zone->SpawnConditionChanged(cond, old_value);
@ -969,7 +969,7 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
//this is a remote spawn condition, update the DB and send //this is a remote spawn condition, update the DB and send
//an update packet to the zone if its up //an update packet to the zone if its up
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Remote spawn condition %d set to %d. Updating DB and notifying world.", condition_id, new_value); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Remote spawn condition %d set to %d. Updating DB and notifying world.", condition_id, new_value);
UpdateDBCondition(zone_short, instance_id, condition_id, new_value); UpdateDBCondition(zone_short, instance_id, condition_id, new_value);
@ -989,7 +989,7 @@ void SpawnConditionManager::SetCondition(const char *zone_short, uint32 instance
void SpawnConditionManager::ReloadEvent(uint32 event_id) { void SpawnConditionManager::ReloadEvent(uint32 event_id) {
std::string zone_short_name; std::string zone_short_name;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Requested to reload event %d from the database.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Requested to reload event %d from the database.", event_id);
//first look for the event in our local event list //first look for the event in our local event list
std::vector<SpawnEvent>::iterator cur,end; std::vector<SpawnEvent>::iterator cur,end;
@ -1002,7 +1002,7 @@ void SpawnConditionManager::ReloadEvent(uint32 event_id) {
//load the event into the old event slot //load the event into the old event slot
if(!LoadDBEvent(event_id, cevent, zone_short_name)) { if(!LoadDBEvent(event_id, cevent, zone_short_name)) {
//unable to find the event in the database... //unable to find the event in the database...
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Failed to reload event %d from the database.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Failed to reload event %d from the database.", event_id);
return; return;
} }
//sync up our nearest event //sync up our nearest event
@ -1015,7 +1015,7 @@ void SpawnConditionManager::ReloadEvent(uint32 event_id) {
SpawnEvent e; SpawnEvent e;
if(!LoadDBEvent(event_id, e, zone_short_name)) { if(!LoadDBEvent(event_id, e, zone_short_name)) {
//unable to find the event in the database... //unable to find the event in the database...
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Failed to reload event %d from the database.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Failed to reload event %d from the database.", event_id);
return; return;
} }
@ -1032,7 +1032,7 @@ void SpawnConditionManager::ReloadEvent(uint32 event_id) {
void SpawnConditionManager::ToggleEvent(uint32 event_id, bool enabled, bool strict, bool reset_base) { void SpawnConditionManager::ToggleEvent(uint32 event_id, bool enabled, bool strict, bool reset_base) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Request to %s spawn event %d %sresetting trigger time", enabled?"enable":"disable", event_id, reset_base?"":"without "); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Request to %s spawn event %d %sresetting trigger time", enabled?"enable":"disable", event_id, reset_base?"":"without ");
//first look for the event in our local event list //first look for the event in our local event list
std::vector<SpawnEvent>::iterator cur,end; std::vector<SpawnEvent>::iterator cur,end;
@ -1047,13 +1047,13 @@ void SpawnConditionManager::ToggleEvent(uint32 event_id, bool enabled, bool stri
cevent.enabled = enabled; cevent.enabled = enabled;
cevent.strict = strict; cevent.strict = strict;
if(reset_base) { if(reset_base) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone. State set. Trigger time reset (period %d).", event_id, cevent.period); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone. State set. Trigger time reset (period %d).", event_id, cevent.period);
//start with the time now //start with the time now
zone->zone_time.getEQTimeOfDay(&cevent.next); zone->zone_time.getEQTimeOfDay(&cevent.next);
//advance the next time by our period //advance the next time by our period
EQTime::AddMinutes(cevent.period, &cevent.next); EQTime::AddMinutes(cevent.period, &cevent.next);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone. State changed.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone. State changed.", event_id);
} }
//save the event in the DB //save the event in the DB
@ -1062,7 +1062,7 @@ void SpawnConditionManager::ToggleEvent(uint32 event_id, bool enabled, bool stri
//sync up our nearest event //sync up our nearest event
FindNearestEvent(); FindNearestEvent();
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone but no change was needed.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d located in this zone but no change was needed.", event_id);
} }
//even if we dont change anything, we still found it //even if we dont change anything, we still found it
return; return;
@ -1081,24 +1081,24 @@ void SpawnConditionManager::ToggleEvent(uint32 event_id, bool enabled, bool stri
SpawnEvent e; SpawnEvent e;
std::string zone_short_name; std::string zone_short_name;
if(!LoadDBEvent(event_id, e, zone_short_name)) { if(!LoadDBEvent(event_id, e, zone_short_name)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to find spawn event %d in the database.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to find spawn event %d in the database.", event_id);
//unable to find the event in the database... //unable to find the event in the database...
return; return;
} }
if(e.enabled == enabled && !reset_base) { if(e.enabled == enabled && !reset_base) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is not located in this zone but no change was needed.", event_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is not located in this zone but no change was needed.", event_id);
return; //no changes. return; //no changes.
} }
e.enabled = enabled; e.enabled = enabled;
if(reset_base) { if(reset_base) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is in zone %s. State set. Trigger time reset (period %d). Notifying world.", event_id, zone_short_name.c_str(), e.period); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is in zone %s. State set. Trigger time reset (period %d). Notifying world.", event_id, zone_short_name.c_str(), e.period);
//start with the time now //start with the time now
zone->zone_time.getEQTimeOfDay(&e.next); zone->zone_time.getEQTimeOfDay(&e.next);
//advance the next time by our period //advance the next time by our period
EQTime::AddMinutes(e.period, &e.next); EQTime::AddMinutes(e.period, &e.next);
} else { } else {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is in zone %s. State changed. Notifying world.", event_id, zone_short_name.c_str(), e.period); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Spawn event %d is in zone %s. State changed. Notifying world.", event_id, zone_short_name.c_str(), e.period);
} }
//save the event in the DB //save the event in the DB
UpdateDBEvent(e); UpdateDBEvent(e);
@ -1123,7 +1123,7 @@ int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instanc
condi = spawn_conditions.find(condition_id); condi = spawn_conditions.find(condition_id);
if(condi == spawn_conditions.end()) if(condi == spawn_conditions.end())
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to find local condition %d in Get request.", condition_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to find local condition %d in Get request.", condition_id);
return(0); //unable to find the spawn condition return(0); //unable to find the spawn condition
} }
@ -1138,12 +1138,12 @@ int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instanc
zone_short, instance_id, condition_id); zone_short, instance_id, condition_id);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to query remote condition %d from zone %s in Get request.", condition_id, zone_short); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to query remote condition %d from zone %s in Get request.", condition_id, zone_short);
return 0; //dunno a better thing to do... return 0; //dunno a better thing to do...
} }
if (results.RowCount() == 0) { if (results.RowCount() == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to load remote condition %d from zone %s in Get request.", condition_id, zone_short); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spawns, "Unable to load remote condition %d from zone %s in Get request.", condition_id, zone_short);
return 0; //dunno a better thing to do... return 0; //dunno a better thing to do...
} }

2
zone/spells.cpp
View File

@ -3832,7 +3832,7 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect, bool use_r
void Corpse::CastRezz(uint16 spellid, Mob* Caster) void Corpse::CastRezz(uint16 spellid, Mob* Caster)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Corpse::CastRezz spellid %i, Rezzed() is %i, rezzexp is %i", spellid,IsRezzed(),rez_experience); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Corpse::CastRezz spellid %i, Rezzed() is %i, rezzexp is %i", spellid,IsRezzed(),rez_experience);
if(IsRezzed()){ if(IsRezzed()){
if(Caster && Caster->IsClient()) if(Caster && Caster->IsClient())

184
zone/tasks.cpp
View File

@ -83,7 +83,7 @@ bool TaskManager::LoadTaskSets() {
int taskID = atoi(row[1]); int taskID = atoi(row[1]);
TaskSets[taskSet].push_back(taskID); TaskSets[taskSet].push_back(taskID);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Adding TaskID %4i to TaskSet %4i", taskID, taskSet); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Adding TaskID %4i to TaskSet %4i", taskID, taskSet);
} }
return true; return true;
@ -91,7 +91,7 @@ bool TaskManager::LoadTaskSets() {
bool TaskManager::LoadSingleTask(int TaskID) { bool TaskManager::LoadSingleTask(int TaskID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskManager::LoadSingleTask(%i)", TaskID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskManager::LoadSingleTask(%i)", TaskID);
if((TaskID <= 0) || (TaskID >= MAXTASKS)) return false; if((TaskID <= 0) || (TaskID >= MAXTASKS)) return false;
@ -115,21 +115,21 @@ bool TaskManager::LoadSingleTask(int TaskID) {
void TaskManager::ReloadGoalLists() { void TaskManager::ReloadGoalLists() {
if(!GoalListManager.LoadLists()) if(!GoalListManager.LoadLists())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadLists failed"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadLists failed");
} }
bool TaskManager::LoadTasks(int singleTask) { bool TaskManager::LoadTasks(int singleTask) {
// If TaskID !=0, then just load the task specified. // If TaskID !=0, then just load the task specified.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskManager::LoadTasks Called"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskManager::LoadTasks Called");
std::string query; std::string query;
if(singleTask == 0) { if(singleTask == 0) {
if(!GoalListManager.LoadLists()) if(!GoalListManager.LoadLists())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadLists failed"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadLists failed");
if(!LoadTaskSets()) if(!LoadTaskSets())
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadTaskSets failed"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::LoadTasks LoadTaskSets failed");
query = StringFormat("SELECT `id`, `duration`, `title`, `description`, `reward`, " query = StringFormat("SELECT `id`, `duration`, `title`, `description`, `reward`, "
"`rewardid`, `cashreward`, `xpreward`, `rewardmethod`, " "`rewardid`, `cashreward`, `xpreward`, `rewardmethod`, "
@ -179,11 +179,11 @@ bool TaskManager::LoadTasks(int singleTask) {
Tasks[taskID]->SequenceMode = ActivitiesSequential; Tasks[taskID]->SequenceMode = ActivitiesSequential;
Tasks[taskID]->LastStep = 0; Tasks[taskID]->LastStep = 0;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskID: %5i, Duration: %8i, StartZone: %3i Reward: %s MinLevel %i MaxLevel %i Repeatable: %s", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskID: %5i, Duration: %8i, StartZone: %3i Reward: %s MinLevel %i MaxLevel %i Repeatable: %s",
taskID, Tasks[taskID]->Duration, Tasks[taskID]->StartZone, Tasks[taskID]->Reward, taskID, Tasks[taskID]->Duration, Tasks[taskID]->StartZone, Tasks[taskID]->Reward,
Tasks[taskID]->MinLevel, Tasks[taskID]->MaxLevel, Tasks[taskID]->MinLevel, Tasks[taskID]->MaxLevel,
Tasks[taskID]->Repeatable ? "Yes" : "No"); Tasks[taskID]->Repeatable ? "Yes" : "No");
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Title: %s", Tasks[taskID]->Title); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Title: %s", Tasks[taskID]->Title);
} }
@ -273,7 +273,7 @@ bool TaskManager::LoadTasks(int singleTask) {
Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].ZoneID = atoi(row[11]); Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].ZoneID = atoi(row[11]);
Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Optional = atoi(row[12]); Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Optional = atoi(row[12]);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Activity Slot %2i: ID %i for Task %5i. Type: %3i, GoalID: %8i, " logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Activity Slot %2i: ID %i for Task %5i. Type: %3i, GoalID: %8i, "
"GoalMethod: %i, GoalCount: %3i, ZoneID:%3i", "GoalMethod: %i, GoalCount: %3i, ZoneID:%3i",
Tasks[taskID]->ActivityCount, activityID, taskID, Tasks[taskID]->ActivityCount, activityID, taskID,
Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Type, Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Type,
@ -282,9 +282,9 @@ bool TaskManager::LoadTasks(int singleTask) {
Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalCount, Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalCount,
Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].ZoneID); Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].ZoneID);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text1: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text1); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text1: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text1);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text2: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text2); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text2: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text2);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text3: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text3); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Text3: %s", Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Text3);
Tasks[taskID]->ActivityCount++; Tasks[taskID]->ActivityCount++;
} }
@ -306,7 +306,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
int characterID = c->CharacterID(); int characterID = c->CharacterID();
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::SaveClientState for character ID %d", characterID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tasks,"TaskManager::SaveClientState for character ID %d", characterID);
if(state->ActiveTaskCount > 0) { if(state->ActiveTaskCount > 0) {
for(int task=0; task<MAXACTIVETASKS; task++) { for(int task=0; task<MAXACTIVETASKS; task++) {
@ -316,7 +316,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
if(state->ActiveTasks[task].Updated) { if(state->ActiveTasks[task].Updated) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientState for character ID %d, Updating TaskIndex %i TaskID %i", characterID, task, taskID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientState for character ID %d, Updating TaskIndex %i TaskID %i", characterID, task, taskID);
std::string query = StringFormat("REPLACE INTO character_tasks (charid, taskid, slot, acceptedtime) " std::string query = StringFormat("REPLACE INTO character_tasks (charid, taskid, slot, acceptedtime) "
"VALUES (%i, %i, %i, %i)", "VALUES (%i, %i, %i, %i)",
@ -338,7 +338,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
if(!state->ActiveTasks[task].Activity[activityIndex].Updated) if(!state->ActiveTasks[task].Activity[activityIndex].Updated)
continue; continue;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientSate for character ID %d, Updating Activity %i, %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientSate for character ID %d, Updating Activity %i, %i",
characterID, task, activityIndex); characterID, task, activityIndex);
if(updatedActivityCount==0) if(updatedActivityCount==0)
@ -358,7 +358,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
if(updatedActivityCount == 0) if(updatedActivityCount == 0)
continue; continue;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] Executing query %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] Executing query %s", query.c_str());
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) { if(!results.Success()) {
@ -383,7 +383,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
for(unsigned int i=state->LastCompletedTaskLoaded; i<state->CompletedTasks.size(); i++) { for(unsigned int i=state->LastCompletedTaskLoaded; i<state->CompletedTasks.size(); i++) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientState Saving Completed Task at slot %i", i); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTSAVE] TaskManager::SaveClientState Saving Completed Task at slot %i", i);
int taskID = state->CompletedTasks[i].TaskID; int taskID = state->CompletedTasks[i].TaskID;
if((taskID <= 0) || (taskID >= MAXTASKS) || (Tasks[taskID] == nullptr)) if((taskID <= 0) || (taskID >= MAXTASKS) || (Tasks[taskID] == nullptr))
@ -459,7 +459,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
state->ActiveTaskCount = 0; state->ActiveTaskCount = 0;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState for character ID %d", characterID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState for character ID %d", characterID);
std::string query = StringFormat("SELECT `taskid`, `slot`, `acceptedtime` " std::string query = StringFormat("SELECT `taskid`, `slot`, `acceptedtime` "
"FROM `character_tasks` " "FROM `character_tasks` "
@ -501,11 +501,11 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
++state->ActiveTaskCount; ++state->ActiveTaskCount;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, Accepted Time: %8X", characterID, taskID, acceptedtime); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, Accepted Time: %8X", characterID, taskID, acceptedtime);
} }
// Load Activities // Load Activities
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] LoadClientState. Loading activities for character ID %d", characterID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] LoadClientState. Loading activities for character ID %d", characterID);
query = StringFormat("SELECT `taskid`, `activityid`, `donecount`, `completed` " query = StringFormat("SELECT `taskid`, `activityid`, `donecount`, `completed` "
"FROM `character_activities` " "FROM `character_activities` "
@ -555,7 +555,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
state->ActiveTasks[activeTaskIndex].Activity[activityID].Updated = false; state->ActiveTasks[activeTaskIndex].Activity[activityID].Updated = false;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, ActivityID: %i, DoneCount: %i, Completed: %i", characterID, taskID, activityID, doneCount, completed); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, ActivityID: %i, DoneCount: %i, Completed: %i", characterID, taskID, activityID, doneCount, completed);
} }
@ -639,7 +639,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
int taskID = atoi(row[0]); int taskID = atoi(row[0]);
state->EnabledTasks.push_back(taskID); state->EnabledTasks.push_back(taskID);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] Adding TaskID %i to enabled tasks", taskID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] Adding TaskID %i to enabled tasks", taskID);
} }
// Check that there is an entry in the client task state for every activity in each task // Check that there is an entry in the client task state for every activity in each task
@ -676,7 +676,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
if(state->ActiveTasks[i].TaskID != TASKSLOTEMPTY) if(state->ActiveTasks[i].TaskID != TASKSLOTEMPTY)
state->UnlockActivities(characterID, i); state->UnlockActivities(characterID, i);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] LoadClientState for Character ID %d DONE!", characterID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[CLIENTLOAD] LoadClientState for Character ID %d DONE!", characterID);
return true; return true;
} }
@ -710,9 +710,9 @@ void ClientTaskState::EnableTask(int characterID, int taskCount, int *tasks) {
} }
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] New enabled task list "); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] New enabled task list ");
for(unsigned int i=0; i<EnabledTasks.size(); i++) for(unsigned int i=0; i<EnabledTasks.size(); i++)
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] %i", EnabledTasks[i]); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] %i", EnabledTasks[i]);
if(tasksEnabled.size() == 0 ) if(tasksEnabled.size() == 0 )
return; return;
@ -722,7 +722,7 @@ void ClientTaskState::EnableTask(int characterID, int taskCount, int *tasks) {
queryStream << ( i ? ", " : "" ) << StringFormat("(%i, %i)", characterID, tasksEnabled[i]); queryStream << ( i ? ", " : "" ) << StringFormat("(%i, %i)", characterID, tasksEnabled[i]);
std::string query = queryStream.str(); std::string query = queryStream.str();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Executing query %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Executing query %s", query.c_str());
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.Log(EQEmuLogSys::Error, "[TASKS]Error in ClientTaskState::EnableTask %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.Log(EQEmuLogSys::Error, "[TASKS]Error in ClientTaskState::EnableTask %s %s", query.c_str(), results.ErrorMessage().c_str());
@ -757,9 +757,9 @@ void ClientTaskState::DisableTask(int charID, int taskCount, int *taskList) {
} }
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] New enabled task list "); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] New enabled task list ");
for(unsigned int i=0; i<EnabledTasks.size(); i++) for(unsigned int i=0; i<EnabledTasks.size(); i++)
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] %i", EnabledTasks[i]); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] %i", EnabledTasks[i]);
if(tasksDisabled.size() == 0) if(tasksDisabled.size() == 0)
return; return;
@ -771,7 +771,7 @@ void ClientTaskState::DisableTask(int charID, int taskCount, int *taskList) {
queryStream << ")"; queryStream << ")";
std::string query = queryStream.str(); std::string query = queryStream.str();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Executing query %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Executing query %s", query.c_str());
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
if(!results.Success()) if(!results.Success())
logger.Log(EQEmuLogSys::Error, "[TASKS]Error in ClientTaskState::DisableTask %s %s", query.c_str(), results.ErrorMessage().c_str()); logger.Log(EQEmuLogSys::Error, "[TASKS]Error in ClientTaskState::DisableTask %s %s", query.c_str(), results.ErrorMessage().c_str());
@ -908,7 +908,7 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i
int TaskListIndex = 0; int TaskListIndex = 0;
int PlayerLevel = c->GetLevel(); int PlayerLevel = c->GetLevel();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSetSelector called for taskset %i. EnableTaskSize is %i", TaskSetID, logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSetSelector called for taskset %i. EnableTaskSize is %i", TaskSetID,
state->EnabledTasks.size()); state->EnabledTasks.size());
if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return; if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return;
@ -918,7 +918,7 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i
if(TaskSets[TaskSetID][0] == 0) { if(TaskSets[TaskSetID][0] == 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSets[%i][0] == 0. All Tasks in Set enabled.", TaskSetID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSets[%i][0] == 0. All Tasks in Set enabled.", TaskSetID);
std::vector<int>::iterator Iterator = TaskSets[TaskSetID].begin(); std::vector<int>::iterator Iterator = TaskSets[TaskSetID].begin();
while((Iterator != TaskSets[TaskSetID].end()) && (TaskListIndex < MAXCHOOSERENTRIES)) { while((Iterator != TaskSets[TaskSetID].end()) && (TaskListIndex < MAXCHOOSERENTRIES)) {
@ -941,7 +941,7 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i
while((EnabledTaskIndex < state->EnabledTasks.size()) && (TaskSetIndex < TaskSets[TaskSetID].size()) && while((EnabledTaskIndex < state->EnabledTasks.size()) && (TaskSetIndex < TaskSets[TaskSetID].size()) &&
(TaskListIndex < MAXCHOOSERENTRIES)) { (TaskListIndex < MAXCHOOSERENTRIES)) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Comparing EnabledTasks[%i] (%i) with TaskSets[%i][%i] (%i)", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Comparing EnabledTasks[%i] (%i) with TaskSets[%i][%i] (%i)",
EnabledTaskIndex, state->EnabledTasks[EnabledTaskIndex], TaskSetID, TaskSetIndex, EnabledTaskIndex, state->EnabledTasks[EnabledTaskIndex], TaskSetID, TaskSetIndex,
TaskSets[TaskSetID][TaskSetIndex]); TaskSets[TaskSetID][TaskSetIndex]);
@ -981,7 +981,7 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task
return; return;
} }
// Titanium OpCode: 0x5e7c // Titanium OpCode: 0x5e7c
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount);
char *Ptr; char *Ptr;
int PlayerLevel = c->GetLevel(); int PlayerLevel = c->GetLevel();
@ -1106,7 +1106,7 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task
void TaskManager::SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *TaskList) { void TaskManager::SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *TaskList) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount);
int PlayerLevel = c->GetLevel(); int PlayerLevel = c->GetLevel();
@ -1275,7 +1275,7 @@ int ClientTaskState::GetActiveTaskID(int index) {
static void DeleteCompletedTaskFromDatabase(int charID, int taskID) { static void DeleteCompletedTaskFromDatabase(int charID, int taskID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] DeleteCompletedTasksFromDatabase. CharID = %i, TaskID = %i", charID, taskID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] DeleteCompletedTasksFromDatabase. CharID = %i, TaskID = %i", charID, taskID);
const std::string query = StringFormat("DELETE FROM completed_tasks WHERE charid=%i AND taskid = %i", charID, taskID); const std::string query = StringFormat("DELETE FROM completed_tasks WHERE charid=%i AND taskid = %i", charID, taskID);
auto results = database.QueryDatabase(query); auto results = database.QueryDatabase(query);
@ -1284,7 +1284,7 @@ static void DeleteCompletedTaskFromDatabase(int charID, int taskID) {
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Delete query %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Delete query %s", query.c_str());
} }
bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) { bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
@ -1298,7 +1298,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
// On loading the client state, all activities that are not completed, are // On loading the client state, all activities that are not completed, are
// marked as hidden. For Sequential (non-stepped) mode, we mark the first // marked as hidden. For Sequential (non-stepped) mode, we mark the first
// activity as active if not complete. // activity as active if not complete.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CharID: %i Task: %i Sequence mode is %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CharID: %i Task: %i Sequence mode is %i",
CharID, ActiveTasks[TaskIndex].TaskID, Task->SequenceMode); CharID, ActiveTasks[TaskIndex].TaskID, Task->SequenceMode);
if(Task->SequenceMode == ActivitiesSequential) { if(Task->SequenceMode == ActivitiesSequential) {
@ -1320,7 +1320,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
} }
if(AllActivitiesComplete && RuleB(TaskSystem, RecordCompletedTasks)) { if(AllActivitiesComplete && RuleB(TaskSystem, RecordCompletedTasks)) {
if(RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { if(RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] KeepOneRecord enabled"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] KeepOneRecord enabled");
std::vector<CompletedTaskInformation>::iterator Iterator = CompletedTasks.begin(); std::vector<CompletedTaskInformation>::iterator Iterator = CompletedTasks.begin();
int ErasedElements = 0; int ErasedElements = 0;
while(Iterator != CompletedTasks.end()) { while(Iterator != CompletedTasks.end()) {
@ -1332,7 +1332,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
else else
++Iterator; ++Iterator;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements);
if(ErasedElements) { if(ErasedElements) {
LastCompletedTaskLoaded -= ErasedElements; LastCompletedTaskLoaded -= ErasedElements;
DeleteCompletedTaskFromDatabase(CharID, ActiveTasks[TaskIndex].TaskID); DeleteCompletedTaskFromDatabase(CharID, ActiveTasks[TaskIndex].TaskID);
@ -1349,7 +1349,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
CompletedTasks.push_back(cti); CompletedTasks.push_back(cti);
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Returning sequential task, AllActivitiesComplete is %i", AllActivitiesComplete); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Returning sequential task, AllActivitiesComplete is %i", AllActivitiesComplete);
return AllActivitiesComplete; return AllActivitiesComplete;
} }
@ -1358,7 +1358,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
bool CurrentStepComplete = true; bool CurrentStepComplete = true;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Current Step is %i, Last Step is %i", ActiveTasks[TaskIndex].CurrentStep, Task->LastStep); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Current Step is %i, Last Step is %i", ActiveTasks[TaskIndex].CurrentStep, Task->LastStep);
// If CurrentStep is -1, this is the first call to this method since loading the // If CurrentStep is -1, this is the first call to this method since loading the
// client state. Unlock all activities with a step number of 0 // client state. Unlock all activities with a step number of 0
if(ActiveTasks[TaskIndex].CurrentStep == -1) { if(ActiveTasks[TaskIndex].CurrentStep == -1) {
@ -1393,7 +1393,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
// If we are only keeping one completed record per task, and the player has done // If we are only keeping one completed record per task, and the player has done
// the same task again, erase the previous completed entry for this task. // the same task again, erase the previous completed entry for this task.
if(RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { if(RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] KeepOneRecord enabled"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] KeepOneRecord enabled");
std::vector<CompletedTaskInformation>::iterator Iterator = CompletedTasks.begin(); std::vector<CompletedTaskInformation>::iterator Iterator = CompletedTasks.begin();
int ErasedElements = 0; int ErasedElements = 0;
while(Iterator != CompletedTasks.end()) { while(Iterator != CompletedTasks.end()) {
@ -1405,7 +1405,7 @@ bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
else else
++Iterator; ++Iterator;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements);
if(ErasedElements) { if(ErasedElements) {
LastCompletedTaskLoaded -= ErasedElements; LastCompletedTaskLoaded -= ErasedElements;
DeleteCompletedTaskFromDatabase(CharID, ActiveTasks[TaskIndex].TaskID); DeleteCompletedTaskFromDatabase(CharID, ActiveTasks[TaskIndex].TaskID);
@ -1455,7 +1455,7 @@ bool ClientTaskState::UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeI
int Ret = false; int Ret = false;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasks for NPCTypeID: %d", NPCTypeID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasks for NPCTypeID: %d", NPCTypeID);
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
@ -1477,7 +1477,7 @@ bool ClientTaskState::UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeI
if(Task->Activity[j].Type != ActivityType) continue; if(Task->Activity[j].Type != ActivityType) continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Task: %i, Activity %i, Activity type %i for NPC %i failed zone check", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Task: %i, Activity %i, Activity type %i for NPC %i failed zone check",
c->GetName(), ActiveTasks[i].TaskID, j, ActivityType, NPCTypeID); c->GetName(), ActiveTasks[i].TaskID, j, ActivityType, NPCTypeID);
continue; continue;
} }
@ -1498,7 +1498,7 @@ bool ClientTaskState::UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeI
continue; continue;
} }
// We found an active task to kill this type of NPC, so increment the done count // We found an active task to kill this type of NPC, so increment the done count
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Calling increment done count ByNPC"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Calling increment done count ByNPC");
IncrementDoneCount(c, Task, i, j); IncrementDoneCount(c, Task, i, j);
Ret = true; Ret = true;
} }
@ -1577,7 +1577,7 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForItem(%d,%d)", Type, ItemID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForItem(%d,%d)", Type, ItemID);
if(ActiveTaskCount == 0) return; if(ActiveTaskCount == 0) return;
@ -1597,7 +1597,7 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI
if(Task->Activity[j].Type != (int)Type) continue; if(Task->Activity[j].Type != (int)Type) continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Activity type %i for Item %i failed zone check", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Activity type %i for Item %i failed zone check",
c->GetName(), Type, ItemID); c->GetName(), Type, ItemID);
continue; continue;
} }
@ -1618,7 +1618,7 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI
continue; continue;
} }
// We found an active task related to this item, so increment the done count // We found an active task related to this item, so increment the done count
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Calling increment done count ForItem"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Calling increment done count ForItem");
IncrementDoneCount(c, Task, i, j, Count); IncrementDoneCount(c, Task, i, j, Count);
} }
} }
@ -1630,7 +1630,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) {
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnExplore(%i)", ExploreID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnExplore(%i)", ExploreID);
if(ActiveTaskCount == 0) return; if(ActiveTaskCount == 0) return;
for(int i=0; i<MAXACTIVETASKS; i++) { for(int i=0; i<MAXACTIVETASKS; i++) {
@ -1648,7 +1648,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) {
// We are only interested in explore activities // We are only interested in explore activities
if(Task->Activity[j].Type != ActivityExplore) continue; if(Task->Activity[j].Type != ActivityExplore) continue;
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Explore exploreid %i failed zone check", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Explore exploreid %i failed zone check",
c->GetName(), ExploreID); c->GetName(), ExploreID);
continue; continue;
} }
@ -1670,7 +1670,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) {
} }
// We found an active task to explore this area, so set done count to goal count // We found an active task to explore this area, so set done count to goal count
// (Only a goal count of 1 makes sense for explore activities?) // (Only a goal count of 1 makes sense for explore activities?)
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on explore"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on explore");
IncrementDoneCount(c, Task, i, j, IncrementDoneCount(c, Task, i, j,
Task->Activity[j].GoalCount - ActiveTasks[i].Activity[j].DoneCount); Task->Activity[j].GoalCount - ActiveTasks[i].Activity[j].DoneCount);
@ -1684,7 +1684,7 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, uint32 *Items, int Cash, i
bool Ret = false; bool Ret = false;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForOnDeliver(%d)", NPCTypeID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForOnDeliver(%d)", NPCTypeID);
if(ActiveTaskCount == 0) return false; if(ActiveTaskCount == 0) return false;
@ -1705,7 +1705,7 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, uint32 *Items, int Cash, i
(Task->Activity[j].Type != ActivityGiveCash)) continue; (Task->Activity[j].Type != ActivityGiveCash)) continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Deliver activity failed zone check (current zone %i, need zone %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Deliver activity failed zone check (current zone %i, need zone %i",
c->GetName(), zone->GetZoneID(), Task->Activity[j].ZoneID); c->GetName(), zone->GetZoneID(), Task->Activity[j].ZoneID);
continue; continue;
} }
@ -1714,7 +1714,7 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, uint32 *Items, int Cash, i
// Is the activity related to these items ? // Is the activity related to these items ?
// //
if((Task->Activity[j].Type == ActivityGiveCash) && Cash) { if((Task->Activity[j].Type == ActivityGiveCash) && Cash) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on GiveCash"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on GiveCash");
IncrementDoneCount(c, Task, i, j, Cash); IncrementDoneCount(c, Task, i, j, Cash);
Ret = true; Ret = true;
} }
@ -1738,7 +1738,7 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, uint32 *Items, int Cash, i
continue; continue;
} }
// We found an active task related to this item, so increment the done count // We found an active task related to this item, so increment the done count
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on GiveItem"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on GiveItem");
IncrementDoneCount(c, Task, i, j, 1); IncrementDoneCount(c, Task, i, j, 1);
Ret = true; Ret = true;
} }
@ -1753,7 +1753,7 @@ void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID) {
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnTouch(%i)", ZoneID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnTouch(%i)", ZoneID);
if(ActiveTaskCount == 0) return; if(ActiveTaskCount == 0) return;
for(int i=0; i<MAXACTIVETASKS; i++) { for(int i=0; i<MAXACTIVETASKS; i++) {
@ -1772,13 +1772,13 @@ void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID) {
if(Task->Activity[j].Type != ActivityTouch) continue; if(Task->Activity[j].Type != ActivityTouch) continue;
if(Task->Activity[j].GoalMethod != METHODSINGLEID) continue; if(Task->Activity[j].GoalMethod != METHODSINGLEID) continue;
if(Task->Activity[j].ZoneID != ZoneID) { if(Task->Activity[j].ZoneID != ZoneID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Touch activity failed zone check", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Char: %s Touch activity failed zone check",
c->GetName()); c->GetName());
continue; continue;
} }
// We found an active task to zone into this zone, so set done count to goal count // We found an active task to zone into this zone, so set done count to goal count
// (Only a goal count of 1 makes sense for touch activities?) // (Only a goal count of 1 makes sense for touch activities?)
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on Touch"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment on Touch");
IncrementDoneCount(c, Task, i, j, IncrementDoneCount(c, Task, i, j,
Task->Activity[j].GoalCount - ActiveTasks[i].Activity[j].DoneCount); Task->Activity[j].GoalCount - ActiveTasks[i].Activity[j].DoneCount);
} }
@ -1788,7 +1788,7 @@ void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID) {
} }
void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int TaskIndex, int ActivityID, int Count, bool ignore_quest_update) { void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int TaskIndex, int ActivityID, int Count, bool ignore_quest_update) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] IncrementDoneCount"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] IncrementDoneCount");
ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount += Count; ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount += Count;
@ -1805,7 +1805,7 @@ void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int T
ActiveTasks[TaskIndex].Activity[ActivityID].Updated=true; ActiveTasks[TaskIndex].Activity[ActivityID].Updated=true;
// Have we reached the goal count for this activity ? // Have we reached the goal count for this activity ?
if(ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount >= Task->Activity[ActivityID].GoalCount) { if(ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount >= Task->Activity[ActivityID].GoalCount) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Done (%i) = Goal (%i) for Activity %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Done (%i) = Goal (%i) for Activity %i",
ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount, ActiveTasks[TaskIndex].Activity[ActivityID].DoneCount,
Task->Activity[ActivityID].GoalCount, Task->Activity[ActivityID].GoalCount,
ActivityID); ActivityID);
@ -1814,7 +1814,7 @@ void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int T
ActiveTasks[TaskIndex].Activity[ActivityID].State = ActivityCompleted; ActiveTasks[TaskIndex].Activity[ActivityID].State = ActivityCompleted;
// Unlock subsequent activities for this task // Unlock subsequent activities for this task
bool TaskComplete = UnlockActivities(c->CharacterID(), TaskIndex); bool TaskComplete = UnlockActivities(c->CharacterID(), TaskIndex);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskCompleted is %i", TaskComplete); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskCompleted is %i", TaskComplete);
// and by the 'Task Stage Completed' message // and by the 'Task Stage Completed' message
c->SendTaskActivityComplete(ActiveTasks[TaskIndex].TaskID, ActivityID, TaskIndex); c->SendTaskActivityComplete(ActiveTasks[TaskIndex].TaskID, ActivityID, TaskIndex);
// Send the updated task/activity list to the client // Send the updated task/activity list to the client
@ -1991,7 +1991,7 @@ bool ClientTaskState::IsTaskActive(int TaskID) {
void ClientTaskState::FailTask(Client *c, int TaskID) { void ClientTaskState::FailTask(Client *c, int TaskID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] FailTask %i, ActiveTaskCount is %i", TaskID, ActiveTaskCount); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] FailTask %i, ActiveTaskCount is %i", TaskID, ActiveTaskCount);
if(ActiveTaskCount == 0) return; if(ActiveTaskCount == 0) return;
for(int i=0; i<MAXACTIVETASKS; i++) { for(int i=0; i<MAXACTIVETASKS; i++) {
@ -2009,7 +2009,7 @@ void ClientTaskState::FailTask(Client *c, int TaskID) {
bool ClientTaskState::IsTaskActivityActive(int TaskID, int ActivityID) { bool ClientTaskState::IsTaskActivityActive(int TaskID, int ActivityID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i).", TaskID, ActivityID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i).", TaskID, ActivityID);
// Quick sanity check // Quick sanity check
if(ActivityID<0) return false; if(ActivityID<0) return false;
if(ActiveTaskCount == 0) return false; if(ActiveTaskCount == 0) return false;
@ -2034,7 +2034,7 @@ bool ClientTaskState::IsTaskActivityActive(int TaskID, int ActivityID) {
// The ActivityID is out of range // The ActivityID is out of range
if(ActivityID >= Task->ActivityCount) return false; if(ActivityID >= Task->ActivityCount) return false;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i). State is %i ", TaskID, ActivityID, logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i). State is %i ", TaskID, ActivityID,
ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State); ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State);
@ -2045,7 +2045,7 @@ bool ClientTaskState::IsTaskActivityActive(int TaskID, int ActivityID) {
void ClientTaskState::UpdateTaskActivity(Client *c, int TaskID, int ActivityID, int Count, bool ignore_quest_update /*= false*/) void ClientTaskState::UpdateTaskActivity(Client *c, int TaskID, int ActivityID, int Count, bool ignore_quest_update /*= false*/)
{ {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState UpdateTaskActivity(%i, %i, %i).", TaskID, ActivityID, Count); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState UpdateTaskActivity(%i, %i, %i).", TaskID, ActivityID, Count);
// Quick sanity check // Quick sanity check
if((ActivityID<0) || (ActiveTaskCount==0)) return; if((ActivityID<0) || (ActiveTaskCount==0)) return;
@ -2072,14 +2072,14 @@ void ClientTaskState::UpdateTaskActivity(Client *c, int TaskID, int ActivityID,
// The Activity is not currently active // The Activity is not currently active
if(ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State != ActivityActive) return; if(ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State != ActivityActive) return;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment done count on UpdateTaskActivity"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Increment done count on UpdateTaskActivity");
IncrementDoneCount(c, Task, ActiveTaskIndex, ActivityID, Count, ignore_quest_update); IncrementDoneCount(c, Task, ActiveTaskIndex, ActivityID, Count, ignore_quest_update);
} }
void ClientTaskState::ResetTaskActivity(Client *c, int TaskID, int ActivityID) { void ClientTaskState::ResetTaskActivity(Client *c, int TaskID, int ActivityID) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState UpdateTaskActivity(%i, %i, 0).", TaskID, ActivityID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState UpdateTaskActivity(%i, %i, 0).", TaskID, ActivityID);
// Quick sanity check // Quick sanity check
if((ActivityID<0) || (ActiveTaskCount==0)) return; if((ActivityID<0) || (ActiveTaskCount==0)) return;
@ -2107,7 +2107,7 @@ void ClientTaskState::ResetTaskActivity(Client *c, int TaskID, int ActivityID) {
// The Activity is not currently active // The Activity is not currently active
if(ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State != ActivityActive) return; if(ActiveTasks[ActiveTaskIndex].Activity[ActivityID].State != ActivityActive) return;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ResetTaskActivityCount"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ResetTaskActivityCount");
ActiveTasks[ActiveTaskIndex].Activity[ActivityID].DoneCount = 0; ActiveTasks[ActiveTaskIndex].Activity[ActivityID].DoneCount = 0;
@ -2173,7 +2173,7 @@ int ClientTaskState::IsTaskCompleted(int TaskID) {
if(!(RuleB(TaskSystem, RecordCompletedTasks))) return -1; if(!(RuleB(TaskSystem, RecordCompletedTasks))) return -1;
for(unsigned int i=0; i<CompletedTasks.size(); i++) { for(unsigned int i=0; i<CompletedTasks.size(); i++) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Comparing completed task %i with %i", CompletedTasks[i].TaskID, TaskID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Comparing completed task %i with %i", CompletedTasks[i].TaskID, TaskID);
if(CompletedTasks[i].TaskID == TaskID) return 1; if(CompletedTasks[i].TaskID == TaskID) return 1;
} }
@ -2275,7 +2275,7 @@ void Client::SendTaskComplete(int TaskIndex) {
void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Task History Requested for Completed Task Index %i", TaskIndex); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Task History Requested for Completed Task Index %i", TaskIndex);
// We only sent the most recent 50 completed tasks, so we need to offset the Index the client sent to us. // We only sent the most recent 50 completed tasks, so we need to offset the Index the client sent to us.
@ -2406,7 +2406,7 @@ void Client::SendTaskFailed(int TaskID, int TaskIndex) {
//tac->unknown5 = 0x00000001; //tac->unknown5 = 0x00000001;
tac->unknown5 = 0; // 0 for task complete or failed. tac->unknown5 = 0; // 0 for task complete or failed.
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskFailed"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskFailed");
_pkt(TASKS__PACKETS, outapp); _pkt(TASKS__PACKETS, outapp);
QueuePacket(outapp); QueuePacket(outapp);
@ -2428,7 +2428,7 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *State)
if(State->CompletedTasks.size() > 50) if(State->CompletedTasks.size() > 50)
FirstTaskToSend = State->CompletedTasks.size() - 50; FirstTaskToSend = State->CompletedTasks.size() - 50;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Completed Task Count: %i, First Task to send is %i, Last is %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Completed Task Count: %i, First Task to send is %i, Last is %i",
State->CompletedTasks.size(), FirstTaskToSend, LastTaskToSend); State->CompletedTasks.size(), FirstTaskToSend, LastTaskToSend);
/* /*
for(iterator=State->CompletedTasks.begin(); iterator!=State->CompletedTasks.end(); iterator++) { for(iterator=State->CompletedTasks.begin(); iterator!=State->CompletedTasks.end(); iterator++) {
@ -2689,12 +2689,12 @@ void TaskManager::SendActiveTasksToClient(Client *c, bool TaskComplete) {
int StartTime = c->GetTaskStartTime(TaskIndex); int StartTime = c->GetTaskStartTime(TaskIndex);
SendActiveTaskDescription(c, TaskID, TaskIndex, StartTime, Tasks[TaskID]->Duration, false); SendActiveTaskDescription(c, TaskID, TaskIndex, StartTime, Tasks[TaskID]->Duration, false);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] SendActiveTasksToClient: Task %i, Activities: %i", TaskID, GetActivityCount(TaskID)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] SendActiveTasksToClient: Task %i, Activities: %i", TaskID, GetActivityCount(TaskID));
int Sequence = 0; int Sequence = 0;
for(int Activity=0; Activity<GetActivityCount(TaskID); Activity++) { for(int Activity=0; Activity<GetActivityCount(TaskID); Activity++) {
if(c->GetTaskActivityState(TaskIndex, Activity) != ActivityHidden) { if(c->GetTaskActivityState(TaskIndex, Activity) != ActivityHidden) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Long: %i, %i, %i Complete=%i", TaskID, Activity, TaskIndex, TaskComplete); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Long: %i, %i, %i Complete=%i", TaskID, Activity, TaskIndex, TaskComplete);
if(Activity==GetActivityCount(TaskID)-1) if(Activity==GetActivityCount(TaskID)-1)
SendTaskActivityLong(c, TaskID, Activity, TaskIndex, SendTaskActivityLong(c, TaskID, Activity, TaskIndex,
Tasks[TaskID]->Activity[Activity].Optional, Tasks[TaskID]->Activity[Activity].Optional,
@ -2704,7 +2704,7 @@ void TaskManager::SendActiveTasksToClient(Client *c, bool TaskComplete) {
Tasks[TaskID]->Activity[Activity].Optional, 0); Tasks[TaskID]->Activity[Activity].Optional, 0);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Short: %i, %i, %i", TaskID, Activity, TaskIndex); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Short: %i, %i, %i", TaskID, Activity, TaskIndex);
SendTaskActivityShort(c, TaskID, Activity, TaskIndex); SendTaskActivityShort(c, TaskID, Activity, TaskIndex);
} }
Sequence++; Sequence++;
@ -2725,13 +2725,13 @@ void TaskManager::SendSingleActiveTaskToClient(Client *c, int TaskIndex, bool Ta
int StartTime = c->GetTaskStartTime(TaskIndex); int StartTime = c->GetTaskStartTime(TaskIndex);
SendActiveTaskDescription(c, TaskID, TaskIndex, StartTime, Tasks[TaskID]->Duration, BringUpTaskJournal); SendActiveTaskDescription(c, TaskID, TaskIndex, StartTime, Tasks[TaskID]->Duration, BringUpTaskJournal);
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] SendSingleActiveTasksToClient: Task %i, Activities: %i", TaskID, GetActivityCount(TaskID)); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] SendSingleActiveTasksToClient: Task %i, Activities: %i", TaskID, GetActivityCount(TaskID));
int Sequence = 0; int Sequence = 0;
for(int Activity=0; Activity<GetActivityCount(TaskID); Activity++) { for(int Activity=0; Activity<GetActivityCount(TaskID); Activity++) {
if(c->GetTaskActivityState(TaskIndex, Activity) != ActivityHidden) { if(c->GetTaskActivityState(TaskIndex, Activity) != ActivityHidden) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Long: %i, %i, %i Complete=%i", TaskID, Activity, TaskIndex, TaskComplete); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Long: %i, %i, %i Complete=%i", TaskID, Activity, TaskIndex, TaskComplete);
if(Activity==GetActivityCount(TaskID)-1) if(Activity==GetActivityCount(TaskID)-1)
SendTaskActivityLong(c, TaskID, Activity, TaskIndex, SendTaskActivityLong(c, TaskID, Activity, TaskIndex,
Tasks[TaskID]->Activity[Activity].Optional, TaskComplete); Tasks[TaskID]->Activity[Activity].Optional, TaskComplete);
@ -2740,7 +2740,7 @@ void TaskManager::SendSingleActiveTaskToClient(Client *c, int TaskIndex, bool Ta
Tasks[TaskID]->Activity[Activity].Optional, 0); Tasks[TaskID]->Activity[Activity].Optional, 0);
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Short: %i, %i, %i", TaskID, Activity, TaskIndex); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] Short: %i, %i, %i", TaskID, Activity, TaskIndex);
SendTaskActivityShort(c, TaskID, Activity, TaskIndex); SendTaskActivityShort(c, TaskID, Activity, TaskIndex);
} }
Sequence++; Sequence++;
@ -2919,7 +2919,7 @@ void ClientTaskState::CancelTask(Client *c, int SequenceNumber, bool RemoveFromD
cts->SequenceNumber = SequenceNumber; cts->SequenceNumber = SequenceNumber;
cts->unknown4 = 0x00000002; cts->unknown4 = 0x00000002;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask");
_pkt(TASKS__PACKETS, outapp); _pkt(TASKS__PACKETS, outapp);
c->QueuePacket(outapp); c->QueuePacket(outapp);
@ -2932,7 +2932,7 @@ void ClientTaskState::CancelTask(Client *c, int SequenceNumber, bool RemoveFromD
void ClientTaskState::RemoveTask(Client *c, int sequenceNumber) { void ClientTaskState::RemoveTask(Client *c, int sequenceNumber) {
int characterID = c->CharacterID(); int characterID = c->CharacterID();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState Cancel Task %i ", sequenceNumber); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState Cancel Task %i ", sequenceNumber);
std::string query = StringFormat("DELETE FROM character_activities WHERE charid=%i AND taskid = %i", std::string query = StringFormat("DELETE FROM character_activities WHERE charid=%i AND taskid = %i",
characterID, ActiveTasks[sequenceNumber].TaskID); characterID, ActiveTasks[sequenceNumber].TaskID);
@ -2941,7 +2941,7 @@ void ClientTaskState::RemoveTask(Client *c, int sequenceNumber) {
logger.Log(EQEmuLogSys::Error, "[TASKS] Error in CientTaskState::CancelTask %s", results.ErrorMessage().c_str()); logger.Log(EQEmuLogSys::Error, "[TASKS] Error in CientTaskState::CancelTask %s", results.ErrorMessage().c_str());
return; return;
} }
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask: %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask: %s", query.c_str());
query = StringFormat("DELETE FROM character_tasks WHERE charid=%i AND taskid = %i", query = StringFormat("DELETE FROM character_tasks WHERE charid=%i AND taskid = %i",
characterID, ActiveTasks[sequenceNumber].TaskID); characterID, ActiveTasks[sequenceNumber].TaskID);
@ -2949,7 +2949,7 @@ void ClientTaskState::RemoveTask(Client *c, int sequenceNumber) {
if(!results.Success()) if(!results.Success())
logger.Log(EQEmuLogSys::Error, "[TASKS] Error in CientTaskState::CancelTask %s", results.ErrorMessage().c_str()); logger.Log(EQEmuLogSys::Error, "[TASKS] Error in CientTaskState::CancelTask %s", results.ErrorMessage().c_str());
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask: %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] CancelTask: %s", query.c_str());
ActiveTasks[sequenceNumber].TaskID = TASKSLOTEMPTY; ActiveTasks[sequenceNumber].TaskID = TASKSLOTEMPTY;
ActiveTaskCount--; ActiveTaskCount--;
@ -2990,7 +2990,7 @@ void ClientTaskState::AcceptNewTask(Client *c, int TaskID, int NPCID) {
// //
int FreeSlot = -1; int FreeSlot = -1;
for(int i=0; i<MAXACTIVETASKS; i++) { for(int i=0; i<MAXACTIVETASKS; i++) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState Looking for free slot in slot %i, found TaskID of %i", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] ClientTaskState Looking for free slot in slot %i, found TaskID of %i",
i, ActiveTasks[i].TaskID); i, ActiveTasks[i].TaskID);
if(ActiveTasks[i].TaskID == 0) { if(ActiveTasks[i].TaskID == 0) {
FreeSlot = i; FreeSlot = i;
@ -3045,11 +3045,11 @@ void ClientTaskState::ProcessTaskProximities(Client *c, float X, float Y, float
if((LastX==X) && (LastY==Y) && (LastZ==Z)) return; if((LastX==X) && (LastY==Y) && (LastZ==Z)) return;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Checking proximities for Position %8.3f, %8.3f, %8.3f\n", X, Y, Z); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Checking proximities for Position %8.3f, %8.3f, %8.3f\n", X, Y, Z);
int ExploreID = taskmanager->ProximityManager.CheckProximities(X, Y, Z); int ExploreID = taskmanager->ProximityManager.CheckProximities(X, Y, Z);
if(ExploreID>0) { if(ExploreID>0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Position %8.3f, %8.3f, %8.3f is within proximity %i\n", X, Y, Z, ExploreID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Position %8.3f, %8.3f, %8.3f is within proximity %i\n", X, Y, Z, ExploreID);
UpdateTasksOnExplore(c, ExploreID); UpdateTasksOnExplore(c, ExploreID);
} }
} }
@ -3073,7 +3073,7 @@ TaskGoalListManager::~TaskGoalListManager() {
bool TaskGoalListManager::LoadLists() { bool TaskGoalListManager::LoadLists() {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskGoalListManager::LoadLists Called"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskGoalListManager::LoadLists Called");
for(int i=0; i< NumberOfLists; i++) for(int i=0; i< NumberOfLists; i++)
safe_delete_array(TaskGoalLists[i].GoalItemEntries); safe_delete_array(TaskGoalLists[i].GoalItemEntries);
@ -3093,7 +3093,7 @@ bool TaskGoalListManager::LoadLists() {
} }
NumberOfLists = results.RowCount(); NumberOfLists = results.RowCount();
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Database returned a count of %i lists", NumberOfLists); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Database returned a count of %i lists", NumberOfLists);
TaskGoalLists = new TaskGoalList_Struct[NumberOfLists]; TaskGoalLists = new TaskGoalList_Struct[NumberOfLists];
@ -3207,7 +3207,7 @@ std::vector<int> TaskGoalListManager::GetListContents(int ListID) {
bool TaskGoalListManager::IsInList(int ListID, int Entry) { bool TaskGoalListManager::IsInList(int ListID, int Entry) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskGoalListManager::IsInList(%i, %i)", ListID, Entry); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskGoalListManager::IsInList(%i, %i)", ListID, Entry);
int ListIndex = GetListByID(ListID); int ListIndex = GetListByID(ListID);
@ -3227,7 +3227,7 @@ bool TaskGoalListManager::IsInList(int ListID, int Entry) {
else if(Entry < TaskGoalLists[ListIndex].GoalItemEntries[MiddleEntry]) else if(Entry < TaskGoalLists[ListIndex].GoalItemEntries[MiddleEntry])
LastEntry = MiddleEntry - 1; LastEntry = MiddleEntry - 1;
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskGoalListManager::IsInList(%i, %i) returning true", ListIndex, Entry); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[UPDATE] TaskGoalListManager::IsInList(%i, %i) returning true", ListIndex, Entry);
return true; return true;
} }
@ -3250,7 +3250,7 @@ TaskProximityManager::~TaskProximityManager() {
bool TaskProximityManager::LoadProximities(int zoneID) { bool TaskProximityManager::LoadProximities(int zoneID) {
TaskProximity proximity; TaskProximity proximity;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskProximityManager::LoadProximities Called for zone %i", zoneID); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] TaskProximityManager::LoadProximities Called for zone %i", zoneID);
TaskProximities.clear(); TaskProximities.clear();
std::string query = StringFormat("SELECT `exploreid`, `minx`, `maxx`, " std::string query = StringFormat("SELECT `exploreid`, `minx`, `maxx`, "
@ -3285,7 +3285,7 @@ int TaskProximityManager::CheckProximities(float X, float Y, float Z) {
TaskProximity* P = &TaskProximities[i]; TaskProximity* P = &TaskProximities[i];
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Checking %8.3f, %8.3f, %8.3f against %8.3f, %8.3f, %8.3f, %8.3f, %8.3f, %8.3f", logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[PROXIMITY] Checking %8.3f, %8.3f, %8.3f against %8.3f, %8.3f, %8.3f, %8.3f, %8.3f, %8.3f",
X, Y, Z, P->MinX, P->MaxX, P->MinY, P->MaxY, P->MinZ, P->MaxZ); X, Y, Z, P->MinX, P->MaxX, P->MinY, P->MaxY, P->MinZ, P->MaxZ);
if(X < P->MinX || X > P->MaxX || Y < P->MinY || Y > P->MaxY || if(X < P->MinX || X > P->MaxX || Y < P->MinY || Y > P->MaxY ||

16
zone/tradeskills.cpp
View File

@ -901,7 +901,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
//handle caps //handle caps
if(spec->nofail) { if(spec->nofail) {
chance = 100; //cannot fail. chance = 100; //cannot fail.
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...This combine cannot fail."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...This combine cannot fail.");
} else if(over_trivial >= 0) { } else if(over_trivial >= 0) {
// At reaching trivial the chance goes to 95% going up an additional // At reaching trivial the chance goes to 95% going up an additional
// percent for every 40 skillpoints above the trivial. // percent for every 40 skillpoints above the trivial.
@ -921,8 +921,8 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
chance = 95; chance = 95;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Current skill: %d , Trivial: %d , Success chance: %f percent", user_skill , spec->trivial , chance); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Current skill: %d , Trivial: %d , Success chance: %f percent", user_skill , spec->trivial , chance);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Bonusstat: %d , INT: %d , WIS: %d , DEX: %d , STR: %d", bonusstat , GetINT() , GetWIS() , GetDEX() , GetSTR()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Bonusstat: %d , INT: %d , WIS: %d , DEX: %d , STR: %d", bonusstat , GetINT() , GetWIS() , GetDEX() , GetSTR());
float res = zone->random.Real(0, 99); float res = zone->random.Real(0, 99);
int aa_chance = 0; int aa_chance = 0;
@ -1066,7 +1066,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
Message_StringID(4, TRADESKILL_SUCCEED, spec->name.c_str()); Message_StringID(4, TRADESKILL_SUCCEED, spec->name.c_str());
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "Tradeskill success"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "Tradeskill success");
itr = spec->onsuccess.begin(); itr = spec->onsuccess.begin();
while(itr != spec->onsuccess.end() && !spec->quest) { while(itr != spec->onsuccess.end() && !spec->quest) {
@ -1098,7 +1098,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
Message_StringID(MT_Emote,TRADESKILL_FAILED); Message_StringID(MT_Emote,TRADESKILL_FAILED);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "Tradeskill failed"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "Tradeskill failed");
if (this->GetGroup()) if (this->GetGroup())
{ {
entity_list.MessageGroup(this,true,MT_Skills,"%s was unsuccessful in %s tradeskill attempt.",GetName(),this->GetGender() == 0 ? "his" : this->GetGender() == 1 ? "her" : "its"); entity_list.MessageGroup(this,true,MT_Skills,"%s was unsuccessful in %s tradeskill attempt.",GetName(),this->GetGender() == 0 ? "his" : this->GetGender() == 1 ? "her" : "its");
@ -1177,9 +1177,9 @@ void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float
NotifyNewTitlesAvailable(); NotifyNewTitlesAvailable();
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...skillup_modifier: %f , success_modifier: %d , stat modifier: %d", skillup_modifier , success_modifier , stat_modifier); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...skillup_modifier: %f , success_modifier: %d , stat modifier: %d", skillup_modifier , success_modifier , stat_modifier);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Stage1 chance was: %f percent", chance_stage1); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Stage1 chance was: %f percent", chance_stage1);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Stage2 chance was: %f percent. 0 percent means stage1 failed", chance_stage2); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Tradeskills, "...Stage2 chance was: %f percent. 0 percent means stage1 failed", chance_stage2);
} }
bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id, bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id,

56
zone/trading.cpp
View File

@ -126,7 +126,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
inst2->SetCharges(stack_size + inst2->GetCharges()); inst2->SetCharges(stack_size + inst2->GetCharges());
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "%s added partial item '%s' stack (qty: %i) to trade slot %i", owner->GetName(), inst->GetItem()->Name, stack_size, trade_slot_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "%s added partial item '%s' stack (qty: %i) to trade slot %i", owner->GetName(), inst->GetItem()->Name, stack_size, trade_slot_id);
if (_stack_size > 0) if (_stack_size > 0)
inst->SetCharges(_stack_size); inst->SetCharges(_stack_size);
@ -143,7 +143,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
SendItemData(inst, trade_slot_id); SendItemData(inst, trade_slot_id);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "%s added item '%s' to trade slot %i", owner->GetName(), inst->GetItem()->Name, trade_slot_id); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "%s added item '%s' to trade slot %i", owner->GetName(), inst->GetItem()->Name, trade_slot_id);
client->PutItemInInventory(trade_slot_id, *inst); client->PutItemInInventory(trade_slot_id, *inst);
client->DeleteItemInInventory(MainCursor); client->DeleteItemInInventory(MainCursor);
@ -1160,7 +1160,7 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
const Item_Struct* item = database.GetItem(ItemID); const Item_Struct* item = database.GetItem(ItemID);
if(!item){ if(!item){
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bogus item deleted in Client::SendTraderItem!\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bogus item deleted in Client::SendTraderItem!\n");
return; return;
} }
@ -1219,10 +1219,10 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
safe_delete(inst); safe_delete(inst);
} }
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::BulkSendTraderInventory nullptr inst pointer"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::BulkSendTraderInventory nullptr inst pointer");
} }
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::BulkSendTraderInventory nullptr item pointer or item is NODROP %8X",item); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::BulkSendTraderInventory nullptr item pointer or item is NODROP %8X",item);
} }
safe_delete(TraderItems); safe_delete(TraderItems);
} }
@ -1245,7 +1245,7 @@ ItemInst* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
} }
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::FindTraderItemBySerialNumber Couldn't find item! Serial No. was %i", SerialNumber); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Client::FindTraderItemBySerialNumber Couldn't find item! Serial No. was %i", SerialNumber);
return nullptr; return nullptr;
} }
@ -1302,7 +1302,7 @@ uint16 Client::FindTraderItem(int32 SerialNumber, uint16 Quantity){
} }
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Could NOT find a match for Item: %i with a quantity of: %i on Trader: %s\n", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Could NOT find a match for Item: %i with a quantity of: %i on Trader: %s\n",
SerialNumber , Quantity, this->GetName()); SerialNumber , Quantity, this->GetName());
return 0; return 0;
@ -1311,7 +1311,7 @@ uint16 Client::FindTraderItem(int32 SerialNumber, uint16 Quantity){
void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Customer,uint16 TraderSlot, int SerialNumber) { void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Customer,uint16 TraderSlot, int SerialNumber) {
if(!Customer) return; if(!Customer) return;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "NukeTraderItem(Slot %i, Charges %i, Quantity %i", Slot, Charges, Quantity); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "NukeTraderItem(Slot %i, Charges %i, Quantity %i", Slot, Charges, Quantity);
if(Quantity < Charges) { if(Quantity < Charges) {
Customer->SendSingleTraderItem(this->CharacterID(), SerialNumber); Customer->SendSingleTraderItem(this->CharacterID(), SerialNumber);
m_inv.DeleteItem(Slot, Quantity); m_inv.DeleteItem(Slot, Quantity);
@ -1395,7 +1395,7 @@ void Client::FindAndNukeTraderItem(int32 SerialNumber, uint16 Quantity, Client*
if(!Stackable) if(!Stackable)
Quantity = (Charges > 0) ? Charges : 1; Quantity = (Charges > 0) ? Charges : 1;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "FindAndNuke %s, Charges %i, Quantity %i", item->GetItem()->Name, Charges, Quantity); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "FindAndNuke %s, Charges %i, Quantity %i", item->GetItem()->Name, Charges, Quantity);
} }
if(item && (Charges <= Quantity || (Charges <= 0 && Quantity==1) || !Stackable)){ if(item && (Charges <= Quantity || (Charges <= 0 && Quantity==1) || !Stackable)){
this->DeleteItemInInventory(SlotID, Quantity); this->DeleteItemInInventory(SlotID, Quantity);
@ -1431,7 +1431,7 @@ void Client::FindAndNukeTraderItem(int32 SerialNumber, uint16 Quantity, Client*
} }
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Could NOT find a match for Item: %i with a quantity of: %i on Trader: %s\n",SerialNumber, logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Could NOT find a match for Item: %i with a quantity of: %i on Trader: %s\n",SerialNumber,
Quantity,this->GetName()); Quantity,this->GetName());
} }
@ -1510,13 +1510,13 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs,Client* Trader,const EQApplicat
const ItemInst* BuyItem = Trader->FindTraderItemBySerialNumber(tbs->ItemID); const ItemInst* BuyItem = Trader->FindTraderItemBySerialNumber(tbs->ItemID);
if(!BuyItem) { if(!BuyItem) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find item on trader."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find item on trader.");
TradeRequestFailed(app); TradeRequestFailed(app);
safe_delete(outapp); safe_delete(outapp);
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Buyitem: Name: %s, IsStackable: %i, Requested Quantity: %i, Charges on Item %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Buyitem: Name: %s, IsStackable: %i, Requested Quantity: %i, Charges on Item %i",
BuyItem->GetItem()->Name, BuyItem->IsStackable(), tbs->Quantity, BuyItem->GetCharges()); BuyItem->GetItem()->Name, BuyItem->IsStackable(), tbs->Quantity, BuyItem->GetCharges());
// If the item is not stackable, then we can only be buying one of them. // If the item is not stackable, then we can only be buying one of them.
if(!BuyItem->IsStackable()) if(!BuyItem->IsStackable())
@ -1534,7 +1534,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs,Client* Trader,const EQApplicat
outtbs->Quantity = tbs->Quantity; outtbs->Quantity = tbs->Quantity;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Actual quantity that will be traded is %i", outtbs->Quantity); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Actual quantity that will be traded is %i", outtbs->Quantity);
if((tbs->Price * outtbs->Quantity) <= 0) { if((tbs->Price * outtbs->Quantity) <= 0) {
Message(13, "Internal error. Aborting trade. Please report this to the ServerOP. Error code is 1"); Message(13, "Internal error. Aborting trade. Please report this to the ServerOP. Error code is 1");
@ -1840,7 +1840,7 @@ void Client::SendBazaarResults(uint32 TraderID, uint32 Class_, uint32 Race, uint
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "SRCH: %s", query.c_str()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "SRCH: %s", query.c_str());
int Size = 0; int Size = 0;
uint32 ID = 0; uint32 ID = 0;
@ -1887,7 +1887,7 @@ void Client::SendBazaarResults(uint32 TraderID, uint32 Class_, uint32 Race, uint
VARSTRUCT_ENCODE_TYPE(uint32, bufptr, ID); VARSTRUCT_ENCODE_TYPE(uint32, bufptr, ID);
} }
else{ else{
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find trader: %i\n",atoi(row[1])); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find trader: %i\n",atoi(row[1]));
VARSTRUCT_ENCODE_TYPE(uint32, bufptr, 0); VARSTRUCT_ENCODE_TYPE(uint32, bufptr, 0);
} }
Cost = atoi(row[5]); Cost = atoi(row[5]);
@ -1981,7 +1981,7 @@ static void UpdateTraderCustomerItemsAdded(uint32 CustomerID, TraderCharges_Stru
if(inst->IsStackable()) if(inst->IsStackable())
inst->SetMerchantCount(gis->Charges[i]); inst->SetMerchantCount(gis->Charges[i]);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price update for %s, Serial No. %i with %i charges", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price update for %s, Serial No. %i with %i charges",
item->Name, gis->SerialNumber[i], gis->Charges[i]); item->Name, gis->SerialNumber[i], gis->Charges[i]);
Customer->SendItemPacket(30, inst, ItemPacketMerchant); // MainCursor? Customer->SendItemPacket(30, inst, ItemPacketMerchant); // MainCursor?
@ -2018,7 +2018,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
if(gis->ItemID[i] == ItemID) { if(gis->ItemID[i] == ItemID) {
tdis->ItemID = gis->SerialNumber[i]; tdis->ItemID = gis->SerialNumber[i];
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Telling customer to remove item %i with %i charges and S/N %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Telling customer to remove item %i with %i charges and S/N %i",
ItemID, Charges, gis->SerialNumber[i]); ItemID, Charges, gis->SerialNumber[i]);
_pkt(TRADING__PACKETS, outapp); _pkt(TRADING__PACKETS, outapp);
@ -2031,7 +2031,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
return; return;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price updates to customer %s", Customer->GetName()); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price updates to customer %s", Customer->GetName());
ItemInst* inst = database.CreateItem(item); ItemInst* inst = database.CreateItem(item);
@ -2057,7 +2057,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
inst->SetMerchantSlot(gis->SerialNumber[i]); inst->SetMerchantSlot(gis->SerialNumber[i]);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price update for %s, Serial No. %i with %i charges", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Sending price update for %s, Serial No. %i with %i charges",
item->Name, gis->SerialNumber[i], gis->Charges[i]); item->Name, gis->SerialNumber[i], gis->Charges[i]);
Customer->SendItemPacket(30, inst, ItemPacketMerchant); // MainCursor?? Customer->SendItemPacket(30, inst, ItemPacketMerchant); // MainCursor??
@ -2073,7 +2073,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
// //
TraderPriceUpdate_Struct* tpus = (TraderPriceUpdate_Struct*)app->pBuffer; TraderPriceUpdate_Struct* tpus = (TraderPriceUpdate_Struct*)app->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Received Price Update for %s, Item Serial No. %i, New Price %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Received Price Update for %s, Item Serial No. %i, New Price %i",
GetName(), tpus->SerialNumber, tpus->NewPrice); GetName(), tpus->SerialNumber, tpus->NewPrice);
// Pull the items this Trader currently has for sale from the trader table. // Pull the items this Trader currently has for sale from the trader table.
@ -2101,7 +2101,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
if((gis->ItemID[i] > 0) && (gis->SerialNumber[i] == tpus->SerialNumber)) { if((gis->ItemID[i] > 0) && (gis->SerialNumber[i] == tpus->SerialNumber)) {
// We found the item that the Trader wants to change the price of (or add back up for sale). // We found the item that the Trader wants to change the price of (or add back up for sale).
// //
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ItemID is %i, Charges is %i", gis->ItemID[i], gis->Charges[i]); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ItemID is %i, Charges is %i", gis->ItemID[i], gis->Charges[i]);
IDOfItemToUpdate = gis->ItemID[i]; IDOfItemToUpdate = gis->ItemID[i];
@ -2127,7 +2127,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
return ; return ;
} }
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find item to update price for. Rechecking trader satchels"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to find item to update price for. Rechecking trader satchels");
// Find what is in their Trader Satchels // Find what is in their Trader Satchels
GetItems_Struct* newgis=GetTraderItems(); GetItems_Struct* newgis=GetTraderItems();
@ -2140,7 +2140,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
if((newgis->Items[i] > 0) && (newgis->SerialNumber[i] == tpus->SerialNumber)) { if((newgis->Items[i] > 0) && (newgis->SerialNumber[i] == tpus->SerialNumber)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Found new Item to Add, ItemID is %i, Charges is %i", newgis->Items[i], logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Found new Item to Add, ItemID is %i, Charges is %i", newgis->Items[i],
newgis->Charges[i]); newgis->Charges[i]);
IDOfItemToAdd = newgis->Items[i]; IDOfItemToAdd = newgis->Items[i];
@ -2158,7 +2158,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
if(!IDOfItemToAdd || !item) { if(!IDOfItemToAdd || !item) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Item not found in Trader Satchels either."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Item not found in Trader Satchels either.");
tpus->SubAction = BazaarPriceChange_Fail; tpus->SubAction = BazaarPriceChange_Fail;
QueuePacket(app); QueuePacket(app);
Trader_EndTrader(); Trader_EndTrader();
@ -2203,7 +2203,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
gis->SerialNumber[i] = newgis->SerialNumber[i]; gis->SerialNumber[i] = newgis->SerialNumber[i];
gis->ItemCost[i] = tpus->NewPrice; gis->ItemCost[i] = tpus->NewPrice;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Adding new item for %s. ItemID %i, SerialNumber %i, Charges %i, Price: %i, Slot %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Adding new item for %s. ItemID %i, SerialNumber %i, Charges %i, Price: %i, Slot %i",
GetName(), newgis->Items[i], newgis->SerialNumber[i], newgis->Charges[i], GetName(), newgis->Items[i], newgis->SerialNumber[i], newgis->Charges[i],
tpus->NewPrice, i); tpus->NewPrice, i);
} }
@ -2249,7 +2249,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
QueuePacket(app); QueuePacket(app);
if(OldPrice == tpus->NewPrice) { if(OldPrice == tpus->NewPrice) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "The new price is the same as the old one."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "The new price is the same as the old one.");
safe_delete(gis); safe_delete(gis);
return; return;
} }
@ -2855,11 +2855,11 @@ void Client::UpdateBuyLine(const EQApplicationPacket *app) {
bool LoreConflict = CheckLoreConflict(item); bool LoreConflict = CheckLoreConflict(item);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "UpdateBuyLine: Char: %s BuySlot: %i ItemID %i %s Quantity %i Toggle: %i Price %i ItemCount %i LoreConflict %i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "UpdateBuyLine: Char: %s BuySlot: %i ItemID %i %s Quantity %i Toggle: %i Price %i ItemCount %i LoreConflict %i",
GetName(), BuySlot, ItemID, item->Name, Quantity, ToggleOnOff, Price, ItemCount, LoreConflict); GetName(), BuySlot, ItemID, item->Name, Quantity, ToggleOnOff, Price, ItemCount, LoreConflict);
if((item->NoDrop != 0) && !LoreConflict && (Quantity > 0) && HasMoney(Quantity * Price) && ToggleOnOff && (ItemCount == 0)) { if((item->NoDrop != 0) && !LoreConflict && (Quantity > 0) && HasMoney(Quantity * Price) && ToggleOnOff && (ItemCount == 0)) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Adding to database"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Adding to database");
database.AddBuyLine(CharacterID(), BuySlot, ItemID, ItemName, Quantity, Price); database.AddBuyLine(CharacterID(), BuySlot, ItemID, ItemName, Quantity, Price);
QueuePacket(app); QueuePacket(app);
} }

34
zone/worldserver.cpp
View File

@ -140,7 +140,7 @@ void WorldServer::Process() {
ServerPacket *pack = 0; ServerPacket *pack = 0;
while((pack = tcpc.PopPacket())) { while((pack = tcpc.PopPacket())) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Got 0x%04x from world:", pack->opcode); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "Got 0x%04x from world:", pack->opcode);
_hex(ZONE__WORLD_TRACE,pack->pBuffer,pack->size); _hex(ZONE__WORLD_TRACE,pack->pBuffer,pack->size);
switch(pack->opcode) { switch(pack->opcode) {
case 0: { case 0: {
@ -155,12 +155,12 @@ void WorldServer::Process() {
if (pack->size != sizeof(ServerConnectInfo)) if (pack->size != sizeof(ServerConnectInfo))
break; break;
ServerConnectInfo* sci = (ServerConnectInfo*) pack->pBuffer; ServerConnectInfo* sci = (ServerConnectInfo*) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "World assigned Port: %d for this zone.", sci->port); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "World assigned Port: %d for this zone.", sci->port);
ZoneConfig::SetZonePort(sci->port); ZoneConfig::SetZonePort(sci->port);
break; break;
} }
case ServerOP_ZAAuthFailed: { case ServerOP_ZAAuthFailed: {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "World server responded 'Not Authorized', disabling reconnect"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Zone_Server, "World server responded 'Not Authorized', disabling reconnect");
pTryReconnect = false; pTryReconnect = false;
Disconnect(); Disconnect();
break; break;
@ -678,7 +678,7 @@ void WorldServer::Process() {
//pendingrezexp is the amount of XP on the corpse. Setting it to a value >= 0 //pendingrezexp is the amount of XP on the corpse. Setting it to a value >= 0
//also serves to inform Client::OPRezzAnswer to expect a packet. //also serves to inform Client::OPRezzAnswer to expect a packet.
client->SetPendingRezzData(srs->exp, srs->dbid, srs->rez.spellid, srs->rez.corpse_name); client->SetPendingRezzData(srs->exp, srs->dbid, srs->rez.spellid, srs->rez.corpse_name);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "OP_RezzRequest in zone %s for %s, spellid:%i", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "OP_RezzRequest in zone %s for %s, spellid:%i",
zone->GetShortName(), client->GetName(), srs->rez.spellid); zone->GetShortName(), client->GetName(), srs->rez.spellid);
EQApplicationPacket* outapp = new EQApplicationPacket(OP_RezzRequest, EQApplicationPacket* outapp = new EQApplicationPacket(OP_RezzRequest,
sizeof(Resurrect_Struct)); sizeof(Resurrect_Struct));
@ -694,10 +694,10 @@ void WorldServer::Process() {
// to the zone that the corpse is in. // to the zone that the corpse is in.
Corpse* corpse = entity_list.GetCorpseByName(srs->rez.corpse_name); Corpse* corpse = entity_list.GetCorpseByName(srs->rez.corpse_name);
if (corpse && corpse->IsCorpse()) { if (corpse && corpse->IsCorpse()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "OP_RezzComplete received in zone %s for corpse %s", logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "OP_RezzComplete received in zone %s for corpse %s",
zone->GetShortName(), srs->rez.corpse_name); zone->GetShortName(), srs->rez.corpse_name);
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Found corpse. Marking corpse as rezzed."); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Found corpse. Marking corpse as rezzed.");
// I don't know why Rezzed is not set to true in CompleteRezz(). // I don't know why Rezzed is not set to true in CompleteRezz().
corpse->IsRezzed(true); corpse->IsRezzed(true);
corpse->CompleteResurrection(); corpse->CompleteResurrection();
@ -748,7 +748,7 @@ void WorldServer::Process() {
} }
case ServerOP_SyncWorldTime: { case ServerOP_SyncWorldTime: {
if(zone!=0) { if(zone!=0) {
logger.LogDebugType(EQEmuLogSys::Moderate, EQEmuLogSys::Zone_Server, __FUNCTION__ "Received Message SyncWorldTime"); logger.DebugCategory(EQEmuLogSys::Moderate, EQEmuLogSys::Zone_Server, __FUNCTION__ "Received Message SyncWorldTime");
eqTimeOfDay* newtime = (eqTimeOfDay*) pack->pBuffer; eqTimeOfDay* newtime = (eqTimeOfDay*) pack->pBuffer;
zone->zone_time.setEQTimeOfDay(newtime->start_eqtime, newtime->start_realtime); zone->zone_time.setEQTimeOfDay(newtime->start_eqtime, newtime->start_realtime);
EQApplicationPacket* outapp = new EQApplicationPacket(OP_TimeOfDay, sizeof(TimeOfDay_Struct)); EQApplicationPacket* outapp = new EQApplicationPacket(OP_TimeOfDay, sizeof(TimeOfDay_Struct));
@ -1974,7 +1974,7 @@ bool WorldServer::SendVoiceMacro(Client* From, uint32 Type, char* Target, uint32
bool WorldServer::RezzPlayer(EQApplicationPacket* rpack, uint32 rezzexp, uint32 dbid, uint16 opcode) bool WorldServer::RezzPlayer(EQApplicationPacket* rpack, uint32 rezzexp, uint32 dbid, uint16 opcode)
{ {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "WorldServer::RezzPlayer rezzexp is %i (0 is normal for RezzComplete", rezzexp); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "WorldServer::RezzPlayer rezzexp is %i (0 is normal for RezzComplete", rezzexp);
ServerPacket* pack = new ServerPacket(ServerOP_RezzPlayer, sizeof(RezzPlayer_Struct)); ServerPacket* pack = new ServerPacket(ServerOP_RezzPlayer, sizeof(RezzPlayer_Struct));
RezzPlayer_Struct* sem = (RezzPlayer_Struct*) pack->pBuffer; RezzPlayer_Struct* sem = (RezzPlayer_Struct*) pack->pBuffer;
sem->rezzopcode = opcode; sem->rezzopcode = opcode;
@ -1983,9 +1983,9 @@ bool WorldServer::RezzPlayer(EQApplicationPacket* rpack, uint32 rezzexp, uint32
sem->dbid = dbid; sem->dbid = dbid;
bool ret = SendPacket(pack); bool ret = SendPacket(pack);
if (ret) if (ret)
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Sending player rezz packet to world spellid:%i", sem->rez.spellid); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "Sending player rezz packet to world spellid:%i", sem->rez.spellid);
else else
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "NOT Sending player rezz packet to world"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Spells, "NOT Sending player rezz packet to world");
safe_delete(pack); safe_delete(pack);
return ret; return ret;
@ -2005,14 +2005,14 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack)
{ {
ReloadTasks_Struct* rts = (ReloadTasks_Struct*) pack->pBuffer; ReloadTasks_Struct* rts = (ReloadTasks_Struct*) pack->pBuffer;
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Zone received ServerOP_ReloadTasks from World, Command %i", rts->Command); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Zone received ServerOP_ReloadTasks from World, Command %i", rts->Command);
switch(rts->Command) { switch(rts->Command) {
case RELOADTASKS: case RELOADTASKS:
entity_list.SaveAllClientsTaskState(); entity_list.SaveAllClientsTaskState();
if(rts->Parameter == 0) { if(rts->Parameter == 0) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload ALL tasks"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload ALL tasks");
safe_delete(taskmanager); safe_delete(taskmanager);
taskmanager = new TaskManager; taskmanager = new TaskManager;
taskmanager->LoadTasks(); taskmanager->LoadTasks();
@ -2021,7 +2021,7 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack)
entity_list.ReloadAllClientsTaskState(); entity_list.ReloadAllClientsTaskState();
} }
else { else {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload only task %i", rts->Parameter); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload only task %i", rts->Parameter);
taskmanager->LoadTasks(rts->Parameter); taskmanager->LoadTasks(rts->Parameter);
entity_list.ReloadAllClientsTaskState(rts->Parameter); entity_list.ReloadAllClientsTaskState(rts->Parameter);
} }
@ -2030,23 +2030,23 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack)
case RELOADTASKPROXIMITIES: case RELOADTASKPROXIMITIES:
if(zone) { if(zone) {
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task proximities"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task proximities");
taskmanager->LoadProximities(zone->GetZoneID()); taskmanager->LoadProximities(zone->GetZoneID());
} }
break; break;
case RELOADTASKGOALLISTS: case RELOADTASKGOALLISTS:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task goal lists"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task goal lists");
taskmanager->ReloadGoalLists(); taskmanager->ReloadGoalLists();
break; break;
case RELOADTASKSETS: case RELOADTASKSETS:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task sets"); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Reload task sets");
taskmanager->LoadTaskSets(); taskmanager->LoadTaskSets();
break; break;
default: default:
logger.LogDebugType(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Unhandled ServerOP_ReloadTasks command %i", rts->Command); logger.DebugCategory(EQEmuLogSys::General, EQEmuLogSys::Tasks, "[GLOBALLOAD] Unhandled ServerOP_ReloadTasks command %i", rts->Command);
} }

20
zone/zonedb.cpp
View File

@ -523,14 +523,14 @@ Trader_Struct* ZoneDatabase::LoadTraderItem(uint32 char_id)
std::string query = StringFormat("SELECT * FROM trader WHERE char_id = %i ORDER BY slot_id LIMIT 80", char_id); std::string query = StringFormat("SELECT * FROM trader WHERE char_id = %i ORDER BY slot_id LIMIT 80", char_id);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Failed to load trader information!\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Failed to load trader information!\n");
return loadti; return loadti;
} }
loadti->Code = BazaarTrader_ShowItems; loadti->Code = BazaarTrader_ShowItems;
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
if (atoi(row[5]) >= 80 || atoi(row[4]) < 0) { if (atoi(row[5]) >= 80 || atoi(row[4]) < 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad Slot number when trying to load trader information!\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad Slot number when trying to load trader information!\n");
continue; continue;
} }
@ -548,13 +548,13 @@ TraderCharges_Struct* ZoneDatabase::LoadTraderItemWithCharges(uint32 char_id)
std::string query = StringFormat("SELECT * FROM trader WHERE char_id=%i ORDER BY slot_id LIMIT 80", char_id); std::string query = StringFormat("SELECT * FROM trader WHERE char_id=%i ORDER BY slot_id LIMIT 80", char_id);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);
if (!results.Success()) { if (!results.Success()) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Failed to load trader information!\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Failed to load trader information!\n");
return loadti; return loadti;
} }
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
if (atoi(row[5]) >= 80 || atoi(row[5]) < 0) { if (atoi(row[5]) >= 80 || atoi(row[5]) < 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad Slot number when trying to load trader information!\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad Slot number when trying to load trader information!\n");
continue; continue;
} }
@ -574,7 +574,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
return nullptr; return nullptr;
if (results.RowCount() == 0) { if (results.RowCount() == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad result from query\n"); fflush(stdout); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Bad result from query\n"); fflush(stdout);
return nullptr; return nullptr;
} }
@ -587,7 +587,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
const Item_Struct *item = database.GetItem(ItemID); const Item_Struct *item = database.GetItem(ItemID);
if(!item) { if(!item) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to create item\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to create item\n");
fflush(stdout); fflush(stdout);
return nullptr; return nullptr;
} }
@ -597,7 +597,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
ItemInst* inst = database.CreateItem(item); ItemInst* inst = database.CreateItem(item);
if(!inst) { if(!inst) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to create item instance\n"); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Unable to create item instance\n");
fflush(stdout); fflush(stdout);
return nullptr; return nullptr;
} }
@ -624,7 +624,7 @@ void ZoneDatabase::SaveTraderItem(uint32 CharID, uint32 ItemID, uint32 SerialNum
} }
void ZoneDatabase::UpdateTraderItemCharges(int CharID, uint32 SerialNumber, int32 Charges) { void ZoneDatabase::UpdateTraderItemCharges(int CharID, uint32 SerialNumber, int32 Charges) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ZoneDatabase::UpdateTraderItemCharges(%i, %i, %i)", CharID, SerialNumber, Charges); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ZoneDatabase::UpdateTraderItemCharges(%i, %i, %i)", CharID, SerialNumber, Charges);
std::string query = StringFormat("UPDATE trader SET charges = %i WHERE char_id = %i AND serialnumber = %i", std::string query = StringFormat("UPDATE trader SET charges = %i WHERE char_id = %i AND serialnumber = %i",
Charges, CharID, SerialNumber); Charges, CharID, SerialNumber);
@ -637,7 +637,7 @@ void ZoneDatabase::UpdateTraderItemCharges(int CharID, uint32 SerialNumber, int3
void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charges, uint32 NewPrice) { void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charges, uint32 NewPrice) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ZoneDatabase::UpdateTraderPrice(%i, %i, %i, %i)", CharID, ItemID, Charges, NewPrice); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "ZoneDatabase::UpdateTraderPrice(%i, %i, %i, %i)", CharID, ItemID, Charges, NewPrice);
const Item_Struct *item = database.GetItem(ItemID); const Item_Struct *item = database.GetItem(ItemID);
@ -645,7 +645,7 @@ void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charg
return; return;
if(NewPrice == 0) { if(NewPrice == 0) {
logger.LogDebugType(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Removing Trader items from the DB for CharID %i, ItemID %i", CharID, ItemID); logger.DebugCategory(EQEmuLogSys::Detail, EQEmuLogSys::Trading, "Removing Trader items from the DB for CharID %i, ItemID %i", CharID, ItemID);
std::string query = StringFormat("DELETE FROM trader WHERE char_id = %i AND item_id = %i",CharID, ItemID); std::string query = StringFormat("DELETE FROM trader WHERE char_id = %i AND item_id = %i",CharID, ItemID);
auto results = QueryDatabase(query); auto results = QueryDatabase(query);