void SpellShell::action(const uint8_t* data, size_t, uint8_t)
{
const actionStruct* a = (const actionStruct*)data;
if (a->type != 0xe7) // only things to do if action is a spell
return;
const Item* s;
QString targetName;
if (a->target &&
((s = m_spawnShell->findID(tSpawn, a->target))))
targetName = s->name();
SpellItem *item = findSpell(a->spell, a->target, targetName);
if (item || (a->target == m_player->id()))
{
int duration = 0;
const Spell* spell = m_spells->spell(a->spell);
if (spell)
duration = spell->calcDuration(a->level) * 6;
QString casterName;
if (a->source &&
((s = m_spawnShell->findID(tSpawn, a->source))))
casterName = s->name();
if (item)
{
#ifdef DIAG_SPELLSHELL
seqDebug("action - found - source=%d (lvl: %d) cast id=%d on target=%d causing %d damage",
a->source, a->level, a->spell, a->target, a->damage);
#endif // DIAG_SPELLSHELL
item->update(a->spell, spell, duration,
a->source, casterName, a->target, targetName);
emit changeSpell(item);
}
else
{
// otherwise check for spells cast on us
#ifdef DIAG_SPELLSHELL
seqDebug("action - new - source=%d (lvl: %d) cast id=%d on target=%d causing %d damage",
a->source, a->level, a->spell, a->target, a->damage);
#endif // DIAG_SPELLSHELL
// only way to get here is if there wasn't an existing spell, so...
item = new SpellItem();
item->update(a->spell, spell, duration,
a->source, casterName, a->target, targetName);
m_spellList.append(item);
if ((m_spellList.count() > 0) && (!m_timer->isActive()))
m_timer->start(1000 *
pSEQPrefs->getPrefInt("SpellTimer", "SpellList", 6));
emit addSpell(item);
}
}
}
void CombatWindow::addMobRecord(int iTargetID, int iSourceID, int iDamage, QString tName, QString sName)
{
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addMobRecord starting...");
#endif
int iTimeNow = mTime();
int iPlayerID = m_player->id();
int iMobID;
QString mobName;
if(iPlayerID == iTargetID)
{
iMobID = iSourceID;
mobName = sName;
}
else if(iPlayerID == iSourceID)
{
iMobID = iTargetID;
mobName = tName;
}
else
{
//invalid record
return;
}
bool bFoundRecord = false;
CombatMobRecord *pRecord;
for(pRecord = m_combat_mob_list.first(); pRecord != 0; pRecord = m_combat_mob_list.next())
{
if(pRecord->getID() == iMobID)
{
bFoundRecord = true;
break;
}
}
if(!bFoundRecord)
{
pRecord = new CombatMobRecord(iMobID, iTimeNow, m_player);
pRecord->setName(mobName);
m_combat_mob_list.append(pRecord);
}
pRecord->setTime(time(0));
pRecord->addHit(iTargetID, iSourceID, iDamage);
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addMobRecord finished...");
#endif
}
void FilteredSpawnModel::setCategory(const Category* category)
{
m_currentCategory = category;
if (category != NULL)
seqDebug("[fsm] changed category: %s", (const char*)category->name());
else
seqDebug("[fsm] changed category: <none>");
invalidateFilter();
}
////////////////////////////////////////////////////
// decrypt/uncompress packet
uint8_t* EQPacketStream::decodeOpCode(uint8_t *data, size_t *len,
uint16_t& opCode)
{
bool s_encrypt = opCode & FLAG_CRYPTO;
bool compressed = opCode & FLAG_COMP;
if (s_encrypt)
{
if (!m_validKey)
return NULL;
#ifdef PACKET_DECODE_DIAG
seqDebug("decoding 0x%04x with 0x%08llx on stream %s", opCode, m_decodeKey, EQStreamStr[m_streamid]);
#endif
int64_t offset = (m_decodeKey % 5) + 5;
*((int64_t *)(data+offset)) ^= m_decodeKey;
m_decodeKey ^= *((int64_t *)(data+offset));
m_decodeKey += *len;
}
if (compressed)
{
static uint8_t decompressed[200000];
size_t dcomplen = 199998;
uint32_t retval;
retval = uncompress(decompressed, (uLongf*)&dcomplen, data, (*len));
if (retval != 0)
{
if (s_encrypt)
{
seqWarn("Lost sync, relog or zone to reset");
m_validKey = false;
}
seqWarn("uncompress failed on 0x%04x: %d - %s\nno further attempts will be made until zone on stream %s.",
opCode, retval, zError(retval), EQStreamStr[m_streamid]);
return NULL;
}
#ifdef PACKET_DECODE_DIAG
seqDebug ("clean uncompress of 0x%04fx on stream %s: %s", opCode, zError (retval), EQStreamStr[m_streamid]);
#endif
opCode &= ~FLAG_COMP;
if (s_encrypt)
opCode &= ~FLAG_CRYPTO;
data = decompressed;
*len = dcomplen;
}
return data;
}
void CombatWindow::addOffenseRecord(int iType, int iDamage, int iSpell)
{
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addOffenseRecord starting...");
#endif
bool bFoundRecord = false;
CombatOffenseRecord *pRecord;
for(pRecord = m_combat_offense_list.first(); pRecord != 0; pRecord = m_combat_offense_list.next())
{
// Belith -- Lets match spells up as well
if(pRecord->getType() == iType && pRecord->getType() != 231)
{
bFoundRecord = true;
break;
}
if(pRecord->getType() == iType && pRecord->getType() == 231
&& pRecord->getSpell() == iSpell)
{
bFoundRecord = true;
break;
}
}
if(!bFoundRecord)
{
// Belith -- Again lets skip buffs, etc
if ((iDamage > 0 && iType == 231) || iType != 231) {
pRecord = new CombatOffenseRecord(iType, m_player, iSpell);
m_combat_offense_list.append(pRecord);
}
}
if(iDamage > 0)
{
pRecord->addHit(iDamage);
}
else if (iType != 231)
{
pRecord->addMiss(iDamage);
}
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addOffenseRecord finished...");
#endif
}
////////////////////////////////////////////////////
// handle a new packet on the stream
void EQPacketStream::handlePacket(EQUDPIPPacketFormat& packet)
{
emit numPacket(++m_packetCount, (int)m_streamid);
// Only accept packets if we've been initialized unless they are
// initialization packets!
if (packet.getNetOpCode() != OP_SessionRequest &&
packet.getNetOpCode() != OP_SessionResponse &&
! m_sessionKey)
{
#if (defined(PACKET_PROCESS_DIAG) && (PACKET_PROCESS_DIAG > 1)) || (defined(PACKET_SESSION_DIAG) && PACKET_SESSION_DIAG > 1)
seqDebug("discarding packet %s:%d ==>%s:%d netopcode=%04x size=%d. Session not initialized. Need to zone to start picking up packets. Session tracking %s.",
(const char*)packet.getIPv4SourceA(), packet.getSourcePort(),
(const char*)packet.getIPv4DestA(), packet.getDestPort(),
packet.getNetOpCode(), packet.payloadLength(),
(m_session_tracking_enabled == 2 ? "locked on" :
(m_session_tracking_enabled == 1 ? "enabled" : "disabled")));
#endif
return;
}
// Decode the packet first
if (! packet.decode(m_maxLength))
{
seqWarn("Packet decode failed for stream %s (%d), op %04x, flags %02x packet dropped.",
EQStreamStr[m_streamid], m_streamid, packet.getNetOpCode(),
packet.getFlags());
return;
}
#ifdef PACKET_DECODE_DIAG
else if (packet.hasFlags())
{
seqDebug("Successful decode for stream %s (%d), op %04x, flags %02x.",
EQStreamStr[m_streamid], m_streamid, packet.getNetOpCode(),
packet.getFlags());
}
#endif
// Raw packet
emit rawPacket(packet.rawPayload(), packet.rawPayloadLength(), m_dir,
packet.getNetOpCode());
processPacket(packet, false); // false = isn't subpacket
// if the cache isn't empty, then process it.
if (!m_cache.empty())
processCache();
}
void FilteredSpawnModel::clearFilters()
{
seqDebug("[fsm] cleared categories");
m_currentCategory = NULL;
invalidateFilter();
}
//slot for loading buffs when main char struct is loaded
void SpellShell::buffLoad(const spellBuff* c)
{
#ifdef DIAG_SPELLSHELL
seqDebug("Loading buff - id=%d.",c->spellid);
#endif // DIAG_SPELLSHELL
const Spell* spell = m_spells->spell(c->spellid);
int duration = c->duration * 6;
SpellItem *item = findSpell(c->spellid, m_player->id(), m_player->name());
if (item)
{ // exists
item->update(c->spellid, spell, duration,
0, "Buff", m_player->id(), m_player->name());
emit changeSpell(item);
}
else
{ // new spell
item = new SpellItem();
item->update(c->spellid, spell, duration,
0, "Buff", m_player->id(), m_player->name());
m_spellList.append(item);
if ((m_spellList.count() > 0) && (!m_timer->isActive()))
m_timer->start(1000 *
pSEQPrefs->getPrefInt("SpellTimer", "SpellList", 6));
emit addSpell(item);
}
}
void SpawnShell::zoneEntry(const uint8_t* data)
{
const spawnStruct* spawn = (const spawnStruct*)data;
#ifdef SPAWNSHELL_DIAG
seqDebug("SpawnShell::zoneEntry(spawnStruct *(name='%s'))", spawn->name);
#endif
// Zone Entry. This is a semi-filled in spawnStruct that we
// see for ourself when entering a zone. We also get sent this
// when shrouding and when respawning from corpse hover mode. Auras
// also get sent this sometimes.
if (spawn->NPC == 0)
{
// Align the player instance with these values
m_player->update(spawn);
emit changeItem(m_player, tSpawnChangedALL);
}
else
{
// Auras.
newSpawn(data);
}
}
////////////////////////////////////////////////////
// handle a new packet on the stream
void EQPacketStream::handlePacket(EQUDPIPPacketFormat& packet)
{
emit numPacket(++m_packetCount, (int)m_streamid);
// Only accept packets if we've been initialized unless they are
// initialization packets!
if (packet.getNetOpCode() != OP_SessionRequest &&
packet.getNetOpCode() != OP_SessionResponse &&
! m_sessionKey)
{
#if (defined(PACKET_PROCESS_DIAG) && (PACKET_PROCESS_DIAG > 1)) || defined(PACKET_SESSION_DIAG)
seqDebug("discarding packet %s:%d ==>%s:%d netopcode=%04x size=%d. Session not initialized. Need to zone to start picking up packets. Session tracking %s.",
(const char*)packet.getIPv4SourceA(), packet.getSourcePort(),
(const char*)packet.getIPv4DestA(), packet.getDestPort(),
packet.getNetOpCode(), packet.payloadLength(),
(m_session_tracking_enabled == 2 ? "locked on" :
(m_session_tracking_enabled == 1 ? "enabled" : "disabled")));
#endif
return;
}
emit rawPacket(packet.payload(), packet.payloadLength(), m_dir,
packet.getNetOpCode());
processPacket(packet, false); // false = isn't subpacket
// if the cache isn't empty, then process it.
if (!m_cache.empty())
processCache();
}
void FilterItem::init(const QString& regexString, bool caseSensitive,
uint8_t minLevel, uint8_t maxLevel)
{
m_minLevel = minLevel;
m_maxLevel = maxLevel;
#ifdef DEBUG_FILTER
seqDebug("regexString=%s minLevel=%d maxLevel=%d",
(const char*)regexString, minLevel, maxLevel);
#endif
m_regexp.setWildcard(false);
m_regexp.setCaseSensitive(caseSensitive);
// For the pattern, save off the original. This is what will be saved
// during save operations. But the actual regexp we filter with will
// mark the # in spawn names as optional to aid in filter writing.
m_regexpOriginalPattern = QString(regexString.ascii());
QString fixedFilterPattern = regexString;
fixedFilterPattern.replace("Name:", "Name:#?", false);
m_regexp.setPattern(fixedFilterPattern);
if (!m_regexp.isValid())
{
seqWarn("Filter Error: '%s' - %s",
(const char*)m_regexp.pattern(),
(const char*)m_regexp.errorString());
}
}
void SpawnShell::newDoorSpawn(const doorStruct& d, size_t len, uint8_t dir)
{
#ifdef SPAWNSHELL_DIAG
seqDebug("SpawnShell::newDoorSpawn(doorStruct*)");
#endif
Item* item = m_doors.find(d.doorId);
if (item != NULL)
{
Door* door = (Door*)item;
door->update(&d);
if (!showeq_params->fast_machine)
item->setDistanceToPlayer(m_player->calcDist2DInt(*item));
else
item->setDistanceToPlayer(m_player->calcDist(*item));
updateFilterFlags(door);
item->updateLastChanged();
emit changeItem(door, tSpawnChangedALL);
}
else
{
item = (Item*)new Door(&d);
if (!showeq_params->fast_machine)
item->setDistanceToPlayer(m_player->calcDist2DInt(*item));
else
item->setDistanceToPlayer(m_player->calcDist(*item));
updateFilterFlags(item);
m_doors.insert(d.doorId, item);
emit addItem(item);
}
}
void CombatDefenseRecord::addMiss(int iMissReason)
{
m_iTotalAttacks++;
switch (iMissReason)
{
case COMBAT_MISS:
m_iMisses++;
break;
case COMBAT_BLOCK:
m_iBlocks++;
break;
case COMBAT_PARRY:
m_iParries++;
break;
case COMBAT_RIPOSTE:
m_iRipostes++;
break;
case COMBAT_DODGE:
m_iDodges++;
break;
default:
#ifdef DEBUGCOMBAT
seqDebug("CombatDefenseRecord::addMiss:WARNING: invalid miss reason");
#endif
break;
}
}
void CombatWindow::initUI()
{
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::initUI: starting...");
#endif
m_tab = new QTabWidget();
m_offenseTab = initOffenseWidget();
m_tab->addTab(m_offenseTab, "&Offense");
m_defenseTab = initDefenseWidget();
m_tab->addTab(m_defenseTab, "&Defense");
m_mobTab = initMobWidget();
m_tab->addTab(m_mobTab, "&Mobs");
//m_menuBar = new QMenuBar(this);
//m_clearMenu = new Q3PopupMenu(this);
//m_clearMenu->insertItem("Clear Offense Stats", this, SLOT(clearOffense()));
//m_clearMenu->insertItem("Clear Mob Stats", this, SLOT(clearMob()));
//m_menuBar->insertItem("&Clear", m_clearMenu);
//QPushButton* m_clearButton = new QPushButton("Clear");
//connect(m_clearButton, SIGNAL(clicked()), this, SLOT(clearOffense()));
//connect(m_clearButton, SIGNAL(clicked()), this, SLOT(clearMob()));
//QVBoxLayout* mainLayout = new QVBoxLayout();
//mainLayout->addWidget(m_tab);
//mainLayout->addWidget(m_clearButton);
updateOffense();
updateDefense();
updateMob();
//QWidget* layoutWidget = new QWidget();
//layoutWidget->setLayout(mainLayout);
//setWidget(layoutWidget);
setWidget(m_tab);
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::initUI: finished...");
#endif
}
////////////////////////////////////////////////////
// setCache
// adds current packet to specified cache
void EQPacketStream::setCache(uint16_t serverArqSeq, EQProtocolPacket& packet)
{
// check if the entry already exists in the cache
EQPacketMap::iterator it = m_cache.find(serverArqSeq);
if (it == m_cache.end())
{
// entry doesn't exist, so insert an entry into the cache
#ifdef PACKET_PROCESS_DIAG
seqDebug("SEQ: Insert arq (%04x) stream %d into cache", serverArqSeq, m_streamid);
#endif
m_cache.insert(EQPacketMap::value_type(serverArqSeq,
new EQProtocolPacket(packet, true)));
emit cacheSize(m_cache.size(), (int)m_streamid);
}
else
{
// replacing an existing entry, make sure the new data is valid
#ifdef APPLY_CRC_CHECK
if (! packet.hasCRC() || calculateCRC(packet) == packet.crc())
#endif
{
#ifdef PACKET_PROCESS_DIAG
seqDebug("SEQ: Update arq (%04x) stream %d in cache", serverArqSeq, m_streamid);
#endif
// Free the old packet at this place and replace with the new one.
delete it->second;
it->second = new EQProtocolPacket(packet, true);
}
#if defined(PACKET_PROCESS_DIAG) && defined(APPLY_CRC_CHECK)
else
seqDebug("SEQ: Not Updating arq (%04x) stream %d into cache, CRC error!",
serverArqSeq, m_streamid);
#endif
}
#ifdef PACKET_CACHE_DIAG
if (m_cache.size() > m_maxCacheCount)
m_maxCacheCount = m_cache.size();
#endif // PACKET_CACHE_DIAG
}
////////////////////////////////////////////////////
// setCache
// adds current packet to specified cache
void EQPacketStream::setCache(uint16_t serverArqSeq, EQPacketFormat& packet)
{
// check if the entry already exists in the cache
EQPacketMap::iterator it = m_cache.find(serverArqSeq);
if (it == m_cache.end())
{
// entry doesn't exist, so insert an entry into the cache
#ifdef PACKET_PROCESS_DIAG
seqDebug("SEQ: Insert arq (%04x) stream %d into cache", serverArqSeq, m_streamid);
#endif
m_cache.insert(EQPacketMap::value_type(serverArqSeq, new EQPacketFormat(packet, true)));
emit cacheSize(m_cache.size(), (int)m_streamid);
}
else
{
// replacing an existing entry, make sure the new data is valid
if (packet.isValid())
{
#ifdef PACKET_PROCESS_DIAG
seqDebug("SEQ: Update arq (%04x) stream %d in cache", serverArqSeq, m_streamid);
#endif
*it->second = packet;
}
#ifdef PACKET_PROCESS_DIAG
else
seqDebug("SEQ: Not Updating arq (%04x) stream %d into cache, CRC error!",
serverArqSeq, m_streamid);
#endif
}
#ifdef PACKET_CACHE_DIAG
if (m_cache.size() > m_maxCacheCount)
m_maxCacheCount = m_cache.size();
#endif // PACKET_CACHE_DIAG
}
bool EQPacketDispatch::connect(const QObject* receiver, const char* member)
{
#ifdef PACKET_DISPATCH_DIAG
seqDebug("Connecting '%s:%s' to '%s:%s' objects %s.",
className(), name(), receiver->className(), receiver->name(),
(const char*)member);
#endif
return QObject::connect((QObject*)this,
SIGNAL(signal(const uint8_t*, size_t, uint8_t)),
receiver, member);
}
void SpellShell::selfStartSpellCast(const uint8_t* data)
{
const startCastStruct *c = (const startCastStruct *)data;
#ifdef DIAG_SPELLSHELL
seqDebug("selfStartSpellCast - id=%d (slot=%d, inv=%d) on spawnid=%d",
c->spellId, c->slot, c->inventorySlot, c->targetId);
#endif // DIAG_SPELLSHELL
// get the target
const Item* s;
QString targetName;
int duration = 0;
const Spell* spell = m_spells->spell(c->spellId);
SpellItem *item;
if (spell)
duration = spell->calcDuration(m_player->level()) * 6;
if (!spell || spell->targetType() != 6)
{
if (c->targetId &&
((s = m_spawnShell->findID(tSpawn, c->targetId))))
targetName = s->name();
item = findSpell(c->spellId, c->targetId, targetName);
}
else
{
targetName = m_player->name();
item = findSpell(c->spellId);
}
if (item)
{ // exists
item->update(c->spellId, spell, duration,
m_player->id(), m_player->name(),
c->targetId, targetName);
emit changeSpell(item);
}
else
{ // new spell
item = new SpellItem();
item->update(c->spellId, spell, duration,
m_player->id(), m_player->name(),
c->targetId, targetName);
m_spellList.append(item);
if ((m_spellList.count() > 0) && (!m_timer->isActive()))
m_timer->start(1000 *
pSEQPrefs->getPrefInt("SpellTimer", "SpellList", 6));
emit addSpell(item);
m_lastPlayerSpell = item;
}
}
void GuildShell::guildMemberUpdate(const uint8_t* data, size_t len)
{
const GuildMemberUpdate* gmu = (const GuildMemberUpdate*)data;
QString memberName = QString::fromUtf8(gmu->name);
// find the member
GuildMember* member = m_members[memberName];
// update the guild members information
if (member)
{
member->update(gmu);
emit updated(member);
#ifdef GUILDSHELL_DIAG
QDateTime dt;
dt.setTime_t(member->lastOn());
seqDebug("%s is now in zone %s (lastOn: %s).",
(const char*)member->name(),
(const char*)m_zoneMgr->zoneNameFromID(member->zoneId()),
(const char*)dt.toString());
#endif // GUILDSHELL_DIAG
}
else
{
#ifdef GUILDSHELL_DIAG
seqDebug("GuildShell::guildMemberUpdate(): Failed to find '%s'(%d)!",
(const char*)memberName, memberName.length());
#if GUILDSHELL_DIAG > 1
seqDebug("%d in members dict.", m_members.count());
GuildMemberDictIterator it(m_members); // See QDictIterator
for( ; it.current(); ++it )
seqDebug("'%s'(%d): '%s'(%d)",
(const char*)it.currentKey(), it.currentKey().length(),
(const char*)it.current()->name(), it.current()->name().length());
#endif // GUILDSHELL_DIAG > 1
#endif // GUILDSHELL_DIAG
}
}
////////////////////////////////////////////////////
// cache reset
void EQPacketStream::resetCache()
{
// first delete all the entries
EQPacketMap::iterator it = m_cache.begin();
EQProtocolPacket* packet;
#ifdef PACKET_CACHE_DIAG
seqDebug("Clearing Cache[%s]: Count: %d", EQStreamStr[m_streamid], m_cache.size());
#endif
while (it != m_cache.end())
{
packet = it->second;
delete packet;
it++;
}
// now clear the cache
#ifdef PACKET_CACHE_DIAG
seqDebug("Resetting sequence cache[%s]", EQStreamStr[m_streamid]);
#endif
m_cache.clear();
emit cacheSize(0, m_streamid);
}
void CombatWindow::addCombatRecord(int iTargetID, int iSourceID, int iType, int iSpell, int iDamage, QString tName, QString sName)
{
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addCombatRecord starting...");
seqDebug("target=%d, source=%d, type=%d, spell=%d, damage=%d",
iTargetID, iSourceID, iType, iSpell, iDamage);
#endif
int iPlayerID = m_player->id();
// The one case we won't handle (for now) is where the Target
// and Source are the same.
if(iTargetID == iPlayerID && iSourceID != iPlayerID)
{
addDefenseRecord(iDamage);
updateDefense();
addMobRecord(iTargetID, iSourceID, iDamage, tName, sName);
updateMob();
}
else if(iSourceID == iPlayerID && iTargetID != iPlayerID)
{
addOffenseRecord(iType, iDamage, iSpell);
updateOffense();
// Belith -- Lets not add buffs, etc
if ((iType == 231 && iDamage > 0) || iType != 231) {
addMobRecord(iTargetID, iSourceID, iDamage, tName, sName);
updateMob();
}
if(iDamage > 0)
updateDPS(iDamage);
}
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::addCombatRecord finished...");
#endif
}
void CombatWindow::initUI()
{
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::initUI: starting...");
#endif
QVBoxLayout* layout = new QVBoxLayout(boxLayout());
m_menu_bar = new QMenuBar(this);
layout->addWidget(m_menu_bar);
m_tab = new QTabWidget(this);
layout->addWidget(m_tab);
m_widget_offense = initOffenseWidget();
m_tab->addTab(m_widget_offense, "&Offense");
m_widget_defense = initDefenseWidget();
m_tab->addTab(m_widget_defense, "&Defense");
m_widget_mob = initMobWidget();
m_tab->addTab(m_widget_mob, "&Mobs");
m_clear_menu = new QPopupMenu(this);
m_clear_menu->insertItem("Clear Offense Stats", this, SLOT(clearOffense()));
m_clear_menu->insertItem("Clear Mob Stats", this, SLOT(clearMob()));
m_menu_bar->insertItem("&Clear", m_clear_menu);
updateOffense();
updateDefense();
updateMob();
#ifdef DEBUGCOMBAT
seqDebug("CombatWindow::initUI: finished...");
#endif
}
/////////////////////////////////////////////////
// Process a session key change
void EQPacketStream::receiveSessionKey(uint32_t sessionId,
EQStreamID streamid, uint32_t sessionKey)
{
if (streamid != m_streamid && m_sessionId == sessionId)
{
// Key is for us
m_sessionKey = sessionKey;
#ifdef PACKET_SESSION_DIAG
seqDebug("EQPacket: Received key %u for session %u on stream %s (%d) from stream %s (%d)",
m_sessionKey, m_sessionId, EQStreamStr[m_streamid], m_streamid,
EQStreamStr[streamid], streamid);
#endif
}
}
void SpellShell::buff(const uint8_t* data, size_t, uint8_t dir)
{
// we only care about the server
if (dir == DIR_Client)
return;
const buffStruct* b = (const buffStruct*)data;
// if this is the second server packet then ignore it
if (b->spellid == 0xffffffff)
return;
#ifdef DIAG_SPELLSHELL
seqDebug("Changing buff - id=%d from spawn=%d", b->spellid, b->spawnid);
#endif // DIAG_SPELLSHELL
const Spell* spell = m_spells->spell(b->spellid);
// find the spell item
SpellItem* item;
const Item* s;
QString targetName;
if (!spell || spell->targetType() != 6)
{
if (b->spawnid &&
((s = m_spawnShell->findID(tSpawn, b->spawnid))))
targetName = s->name();
item = findSpell(b->spellid, b->spawnid, targetName);
}
else
item = findSpell(b->spellid);
if (!item)
return;
if (b->changetype == 0x01) // removing buff
deleteSpell(item);
else if (b->changetype == 0x02)
{
// right now we only know how to find the updated duration
item->setDuration(b->duration * 6);
emit changeSpell(item);
}
}
void GuildMember::update(const GuildMemberUpdate* gmu)
{
m_zoneId = gmu->zoneId;
m_zoneInstance = gmu->zoneInstance;
m_lastOn = gmu->lastOn;
#ifdef GUILDSHELL_DIAG
QDateTime dt;
QString dateFormat("ddd MMM dd hh:mm:ss yyyy");
dt.setTime_t(m_lastOn);
QString zone;
zone = QString::number(m_zoneId);
if (zoneInstance())
zone += ":" + QString::number(m_zoneInstance);
seqDebug("GuildShell: updated zone for member (member: %s, zone: %s, last on: %s", (const char*) m_name, (const char*) zone, (const char*) dt.toString(dateFormat));
#endif
}
void SpawnShell::removeGroundItem(const uint8_t* data, size_t, uint8_t dir)
{
#ifdef SPAWNSHELL_DIAG
seqDebug("SpawnShell::removeGroundItem(remDropStruct *)");
#endif
// if zoning, then don't do anything
if (m_zoneMgr->isZoning())
return;
if (dir != DIR_Server)
return;
const remDropStruct *d = (const remDropStruct *)data;
if (d)
deleteItem(tDrop, d->dropId);
}
void SpawnShell::deleteItem(spawnItemType type, int id)
{
#ifdef SPAWNSHELL_DIAG
seqDebug("SpawnShell::deleteItem()");
#endif
ItemMap& theMap = getMap(type);
Item* item = theMap.find(id);
if (item != NULL)
{
emit delItem(item);
theMap.remove(id);
// send notifcation of new spawn count
emit numSpawns(m_spawns.count());
}
}
///////////////////////////////////////////
//EQPacket::dispatchWorldChatData
// note this dispatch gets just the payload
void EQPacket::dispatchWorldChatData (size_t len, uint8_t *data,
uint8_t dir)
{
#ifdef DEBUG_PACKET
debug ("dispatchWorldChatData()");
#endif /* DEBUG_PACKET */
if (len < 10)
return;
uint16_t opCode = eqntohuint16(data);
switch (opCode)
{
default:
seqDebug("%04x - %d (%s)", opCode, len,
((dir == DIR_Server) ?
"WorldChatServer --> Client" : "Client --> WorldChatServer"));
}
}
//
// addFilter
//
// Add a filter to the list
//
bool
Filter::addFilter(const QString& filterPattern)
{
FilterItem* re;
// no duplicates allowed
if (findFilter(filterPattern))
return false;
re = new FilterItem(filterPattern, m_caseSensitive);
// append it to the end of the list
m_filterItems.append(re);
#ifdef DEBUG_FILTER
seqDebug("Added Filter '%s'", (const char*)filterPattern);
#endif
return re->valid();
} // end addFilter
// same-name slots, connecting to Packet signals
void SpawnShell::newGroundItem(const uint8_t* data, size_t, uint8_t dir)
{
const makeDropStruct *d = (const makeDropStruct *)data;
#ifdef SPAWNSHELL_DIAG
seqDebug("SpawnShell::newGroundItem(makeDropStruct *)");
#endif
// if zoning, then don't do anything
if (m_zoneMgr->isZoning())
return;
if (dir != DIR_Server)
return;
if (!d)
return;
QString name;
Drop* item = (Drop*)m_drops.find(d->dropId);
if (item != NULL)
{
item->update(d, name);
if (!showeq_params->fast_machine)
item->setDistanceToPlayer(m_player->calcDist2DInt(*item));
else
item->setDistanceToPlayer(m_player->calcDist(*item));
updateFilterFlags(item);
item->updateLastChanged();
emit changeItem(item, tSpawnChangedALL);
}
else
{
item = new Drop(d, name);
if (!showeq_params->fast_machine)
item->setDistanceToPlayer(m_player->calcDist2DInt(*item));
else
item->setDistanceToPlayer(m_player->calcDist(*item));
updateFilterFlags(item);
m_drops.insert(d->dropId, item);
emit addItem(item);
}
}
