WorldPacket Quest::BuildQueryData(LocaleConstant loc) const
{
WorldPackets::Quest::QueryQuestInfoResponse response;
std::string locQuestTitle = GetTitle();
std::string locQuestDetails = GetDetails();
std::string locQuestObjectives = GetObjectives();
std::string locQuestAreaDescription = GetAreaDescription();
std::string locQuestCompletedText = GetCompletedText();
std::string locQuestObjectiveText[QUEST_OBJECTIVES_COUNT];
for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
locQuestObjectiveText[i] = ObjectiveText[i];
if (QuestLocale const* localeData = sObjectMgr->GetQuestLocale(GetQuestId()))
{
ObjectMgr::GetLocaleString(localeData->Title, loc, locQuestTitle);
ObjectMgr::GetLocaleString(localeData->Details, loc, locQuestDetails);
ObjectMgr::GetLocaleString(localeData->Objectives, loc, locQuestObjectives);
ObjectMgr::GetLocaleString(localeData->AreaDescription, loc, locQuestAreaDescription);
ObjectMgr::GetLocaleString(localeData->CompletedText, loc, locQuestCompletedText);
for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
ObjectMgr::GetLocaleString(localeData->ObjectiveText[i], loc, locQuestObjectiveText[i]);
}
response.Info.QuestID = GetQuestId();
response.Info.QuestMethod = GetQuestMethod();
response.Info.QuestLevel = GetQuestLevel();
response.Info.QuestMinLevel = GetMinLevel();
response.Info.QuestSortID = GetZoneOrSort();
response.Info.QuestType = GetType();
response.Info.SuggestedGroupNum = GetSuggestedPlayers();
response.Info.RequiredFactionId[0] = GetRepObjectiveFaction();
response.Info.RequiredFactionValue[0] = GetRepObjectiveValue();
response.Info.RequiredFactionId[1] = GetRepObjectiveFaction2();
response.Info.RequiredFactionValue[1] = GetRepObjectiveValue2();
response.Info.RewardNextQuest = GetNextQuestInChain();
response.Info.RewardXPDifficulty = GetXPId();
response.Info.RewardMoney = GetRewOrReqMoney();
response.Info.RewardBonusMoney = GetRewMoneyMaxLevel();
response.Info.RewardDisplaySpell = GetRewSpell();
response.Info.RewardSpell = GetRewSpellCast();
response.Info.RewardHonor = GetRewHonorAddition();
response.Info.RewardKillHonor = GetRewHonorMultiplier();
response.Info.StartItem = GetSrcItemId();
response.Info.Flags = GetFlags();
response.Info.RewardTitleId = GetCharTitleId();
response.Info.RequiredPlayerKills = GetPlayersSlain();
response.Info.RewardTalents = GetBonusTalents();
response.Info.RewardArenaPoints = GetRewArenaPoints();
for (uint8 i = 0; i < QUEST_REWARDS_COUNT; ++i)
{
response.Info.RewardItems[i] = RewardItemId[i];
response.Info.RewardAmount[i] = RewardItemIdCount[i];
}
for (uint8 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
{
response.Info.UnfilteredChoiceItems[i].ItemID = RewardChoiceItemId[i];
response.Info.UnfilteredChoiceItems[i].Quantity = RewardChoiceItemCount[i];
}
for (uint8 i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // reward factions ids
response.Info.RewardFactionID[i] = RewardFactionId[i];
for (uint8 i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // columnid+1 QuestFactionReward.dbc?
response.Info.RewardFactionValue[i] = RewardFactionValueId[i];
for (uint8 i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // unk (0)
response.Info.RewardFactionValueOverride[i] = RewardFactionValueIdOverride[i];
response.Info.POIContinent = GetPOIContinent();
response.Info.POIx = GetPOIx();
response.Info.POIy = GetPOIy();
response.Info.POIPriority = GetPointOpt();
if (sWorld->getBoolConfig(CONFIG_UI_QUESTLEVELS_IN_DIALOGS))
Quest::AddQuestLevelToTitle(locQuestTitle, GetQuestLevel());
response.Info.Title = locQuestTitle;
response.Info.Objectives = locQuestObjectives;
response.Info.Details = locQuestDetails;
response.Info.AreaDescription = locQuestAreaDescription;
response.Info.CompletedText = locQuestCompletedText;
for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
{
response.Info.RequiredNpcOrGo[i] = RequiredNpcOrGo[i];
response.Info.RequiredNpcOrGoCount[i] = RequiredNpcOrGoCount[i];
response.Info.ItemDrop[i] = ItemDrop[i];
}
for (uint8 i = 0; i < QUEST_ITEM_OBJECTIVES_COUNT; ++i)
{
response.Info.RequiredItemId[i] = RequiredItemId[i];
response.Info.RequiredItemCount[i] = RequiredItemCount[i];
}
for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
response.Info.ObjectiveText[i] = locQuestObjectiveText[i];
return *response.Write();
}
void Quest::InitializeQueryData()
{
queryData.Initialize(SMSG_QUEST_QUERY_RESPONSE, 1);
queryData << uint32(GetQuestId()); // quest id
queryData << uint32(GetQuestMethod()); // Accepted values: 0, 1 or 2. 0 == IsAutoComplete() (skip objectives/details)
queryData << uint32(GetQuestLevel()); // may be -1, static data, in other cases must be used dynamic level: Player::GetQuestLevel (0 is not known, but assuming this is no longer valid for quest intended for client)
queryData << uint32(GetMinLevel()); // min level
queryData << uint32(GetZoneOrSort()); // zone or sort to display in quest log
queryData << uint32(GetType()); // quest type
queryData << uint32(GetSuggestedPlayers()); // suggested players count
queryData << uint32(GetRepObjectiveFaction()); // shown in quest log as part of quest objective
queryData << uint32(GetRepObjectiveValue()); // shown in quest log as part of quest objective
queryData << uint32(GetRepObjectiveFaction2()); // shown in quest log as part of quest objective OPPOSITE faction
queryData << uint32(GetRepObjectiveValue2()); // shown in quest log as part of quest objective OPPOSITE faction
queryData << uint32(GetNextQuestInChain()); // client will request this quest from NPC, if not 0
queryData << uint32(GetXPId()); // used for calculating rewarded experience
if (HasFlag(QUEST_FLAGS_HIDDEN_REWARDS))
queryData << uint32(0); // Hide money rewarded
else
queryData << uint32(GetRewOrReqMoney()); // reward money (below max lvl)
queryData << uint32(GetRewMoneyMaxLevel()); // used in XP calculation at client
queryData << uint32(GetRewSpell()); // reward spell, this spell will display (icon) (casted if RewSpellCast == 0)
queryData << int32(GetRewSpellCast()); // casted spell
// rewarded honor points
queryData << uint32(GetRewHonorAddition());
queryData << float(GetRewHonorMultiplier());
queryData << uint32(GetSrcItemId()); // source item id
queryData << uint32(GetFlags() & 0xFFFF); // quest flags
queryData << uint32(GetCharTitleId()); // CharTitleId, new 2.4.0, player gets this title (id from CharTitles)
queryData << uint32(GetPlayersSlain()); // players slain
queryData << uint32(GetBonusTalents()); // bonus talents
queryData << uint32(GetRewArenaPoints()); // bonus arena points
queryData << uint32(0); // review rep show mask
if (HasFlag(QUEST_FLAGS_HIDDEN_REWARDS))
{
for (uint32 i = 0; i < QUEST_REWARDS_COUNT; ++i)
queryData << uint32(0) << uint32(0);
for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
queryData << uint32(0) << uint32(0);
}
else
{
for (uint32 i = 0; i < QUEST_REWARDS_COUNT; ++i)
{
queryData << uint32(RewardItemId[i]);
queryData << uint32(RewardItemIdCount[i]);
}
for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
{
queryData << uint32(RewardChoiceItemId[i]);
queryData << uint32(RewardChoiceItemCount[i]);
}
}
for (uint32 i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // reward factions ids
queryData << uint32(RewardFactionId[i]);
for (uint32 i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // columnid+1 QuestFactionReward.dbc?
queryData << int32(RewardFactionValueId[i]);
for (int i = 0; i < QUEST_REPUTATIONS_COUNT; ++i) // unk (0)
queryData << int32(RewardFactionValueIdOverride[i]);
queryData << GetPointMapId();
queryData << GetPointX();
queryData << GetPointY();
queryData << GetPointOpt();
queryData << GetTitle();
queryData << GetObjectives();
queryData << GetDetails();
queryData << GetEndText();
queryData << GetCompletedText(); // display in quest objectives window once all objectives are completed
for (uint32 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
{
if (RequiredNpcOrGo[i] < 0)
queryData << uint32((RequiredNpcOrGo[i] * (-1)) | 0x80000000); // client expects gameobject template id in form (id|0x80000000)
else
queryData << uint32(RequiredNpcOrGo[i]);
queryData << uint32(RequiredNpcOrGoCount[i]);
queryData << uint32(RequiredSourceItemId[i]);
queryData << uint32(0); // req source count?
}
for (uint32 i = 0; i < QUEST_ITEM_OBJECTIVES_COUNT; ++i)
{
queryData << uint32(RequiredItemId[i]);
queryData << uint32(RequiredItemCount[i]);
}
for (uint32 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
queryData << ObjectiveText[i];
}
void BattleGround::Update(uint32 diff)
{
if (!GetPlayersSize())
{
// BG is empty
// if there are no players invited, delete BG
// this will delete arena or bg object, where any player entered
// [[ but if you use battleground object again (more battles possible to be played on 1 instance)
// then this condition should be removed and code:
// if (!GetInvitedCount(HORDE) && !GetInvitedCount(ALLIANCE))
// this->AddToFreeBGObjectsQueue(); // not yet implemented
// should be used instead of current
// ]]
// BattleGround Template instance cannot be updated, because it would be deleted
if (!GetInvitedCount(HORDE) && !GetInvitedCount(ALLIANCE))
delete this;
return;
}
// remove offline players from bg after 5 minutes
if (!m_OfflineQueue.empty())
{
BattleGroundPlayerMap::iterator itr = m_Players.find(*(m_OfflineQueue.begin()));
if (itr != m_Players.end())
{
if (itr->second.OfflineRemoveTime <= sWorld.GetGameTime())
{
RemovePlayerAtLeave(itr->first, true, true);// remove player from BG
m_OfflineQueue.pop_front(); // remove from offline queue
// do not use itr for anything, because it is erased in RemovePlayerAtLeave()
}
}
}
/*********************************************************/
/*** BATTLEGROUND BALLANCE SYSTEM ***/
/*********************************************************/
// if less then minimum players are in on one side, then start premature finish timer
if (GetStatus() == STATUS_IN_PROGRESS && sBattleGroundMgr.GetPrematureFinishTime() && (GetPlayersCountByTeam(ALLIANCE) < GetMinPlayersPerTeam() || GetPlayersCountByTeam(HORDE) < GetMinPlayersPerTeam()))
{
if (!m_PrematureCountDown)
{
m_PrematureCountDown = true;
m_PrematureCountDownTimer = sBattleGroundMgr.GetPrematureFinishTime();
}
else if (m_PrematureCountDownTimer < diff)
{
// time's up!
Team winner = TEAM_NONE;
if (GetPlayersCountByTeam(ALLIANCE) >= GetMinPlayersPerTeam())
winner = ALLIANCE;
else if (GetPlayersCountByTeam(HORDE) >= GetMinPlayersPerTeam())
winner = HORDE;
EndBattleGround(winner);
m_PrematureCountDown = false;
}
else if (!sBattleGroundMgr.isTesting())
{
uint32 newtime = m_PrematureCountDownTimer - diff;
// announce every minute
if (newtime > (MINUTE * IN_MILLISECONDS))
{
if (newtime / (MINUTE * IN_MILLISECONDS) != m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS))
PSendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING, CHAT_MSG_SYSTEM, NULL, (uint32)(m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS)));
}
else
{
// announce every 15 seconds
if (newtime / (15 * IN_MILLISECONDS) != m_PrematureCountDownTimer / (15 * IN_MILLISECONDS))
PSendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING_SECS, CHAT_MSG_SYSTEM, NULL, (uint32)(m_PrematureCountDownTimer / IN_MILLISECONDS));
}
m_PrematureCountDownTimer = newtime;
}
}
else if (m_PrematureCountDown)
m_PrematureCountDown = false;
/*********************************************************/
/*** BATTLEGROUND STARTING SYSTEM ***/
/*********************************************************/
if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())
{
ModifyStartDelayTime(diff);
if (!(m_Events & BG_STARTING_EVENT_1))
{
m_Events |= BG_STARTING_EVENT_1;
StartingEventCloseDoors();
SetStartDelayTime(m_StartDelayTimes[BG_STARTING_EVENT_FIRST]);
// first start warning - 2 or 1 minute, only if defined
if (m_StartMessageIds[BG_STARTING_EVENT_FIRST])
SendMessageToAll(m_StartMessageIds[BG_STARTING_EVENT_FIRST], CHAT_MSG_BG_SYSTEM_NEUTRAL);
}
// After 1 minute or 30 seconds, warning is signalled
else if (GetStartDelayTime() <= m_StartDelayTimes[BG_STARTING_EVENT_SECOND] && !(m_Events & BG_STARTING_EVENT_2))
{
m_Events |= BG_STARTING_EVENT_2;
SendMessageToAll(m_StartMessageIds[BG_STARTING_EVENT_SECOND], CHAT_MSG_BG_SYSTEM_NEUTRAL);
}
// After 30 or 15 seconds, warning is signalled
else if (GetStartDelayTime() <= m_StartDelayTimes[BG_STARTING_EVENT_THIRD] && !(m_Events & BG_STARTING_EVENT_3))
{
m_Events |= BG_STARTING_EVENT_3;
SendMessageToAll(m_StartMessageIds[BG_STARTING_EVENT_THIRD], CHAT_MSG_BG_SYSTEM_NEUTRAL);
}
// delay expired (atfer 2 or 1 minute)
else if (GetStartDelayTime() <= 0 && !(m_Events & BG_STARTING_EVENT_4))
{
m_Events |= BG_STARTING_EVENT_4;
StartingEventOpenDoors();
SendMessageToAll(m_StartMessageIds[BG_STARTING_EVENT_FOURTH], CHAT_MSG_BG_SYSTEM_NEUTRAL);
SetStatus(STATUS_IN_PROGRESS);
SetStartDelayTime(m_StartDelayTimes[BG_STARTING_EVENT_FOURTH]);
{
PlaySoundToAll(SOUND_BG_START);
// Announce BG starting
if (sWorld.getConfig(CONFIG_BOOL_BATTLEGROUND_QUEUE_ANNOUNCER_START))
{
sWorld.SendWorldText(LANG_BG_STARTED_ANNOUNCE_WORLD, GetName(), GetMinLevel(), GetMaxLevel());
}
}
}
}
/*********************************************************/
/*** BATTLEGROUND ENDING SYSTEM ***/
/*********************************************************/
if (GetStatus() == STATUS_WAIT_LEAVE)
{
// remove all players from battleground after 2 minutes
m_EndTime -= diff;
if (m_EndTime <= 0)
{
m_EndTime = 0;
BattleGroundPlayerMap::iterator itr, next;
for (itr = m_Players.begin(); itr != m_Players.end(); itr = next)
{
next = itr;
++next;
// itr is erased here!
RemovePlayerAtLeave(itr->first, true, true);// remove player from BG
// do not change any battleground's private variables
}
}
}
// update start time
m_StartTime += diff;
}
//o--------------------------------------------------------------
//| CalcSpellEffectValue_formula; Yeahlight, Nov 16, 2008
//o--------------------------------------------------------------
//| Adapted from EQEMU 7.0
//o--------------------------------------------------------------
int Mob::CalcSpellEffectValue_formula(int formula, int base, int max, int caster_level, Spell* spell, int ticsremaining)
{
/*
neotokyo: i need those formulas checked!!!!
0 = base
1 - 99 = base + level * formulaID
100 = base
101 = base + level / 2
102 = base + level
103 = base + level * 2
104 = base + level * 3
105 = base + level * 4
106 ? base + level * 5
107 ? min + level / 2
108 = min + level / 3
109 = min + level / 4
110 = min + level / 5
119 ? min + level / 8
121 ? min + level / 4
122 = splurt
123 ?
203 = stacking issues ? max
205 = stacking issues ? 105
0x77 = min + level / 8
*/
int result = 0, updownsign = 1, ubase = base;
if(ubase < 0)
ubase = 0 - ubase;
// solar: this updown thing might look messed up but if you look at the
// spells it actually looks like some have a positive base and max where
// the max is actually less than the base, hence they grow downward
/*
This seems to mainly catch spells where both base and max are negative.
Strangely, damage spells have a negative base and positive max, but
snare has both of them negative, yet their range should work the same:
(meaning they both start at a negative value and the value gets lower)
*/
if (max < base && max != 0)
{
// values are calculated down
updownsign = -1;
}
else
{
// values are calculated up
updownsign = 1;
}
//mlog(SPELLS__EFFECT_VALUES, "CSEV: spell %d, formula %d, base %d, max %d, lvl %d. Up/Down %d", spell_id, formula, base, max, caster_level, updownsign);
switch(formula)
{
case 60: //used in stun spells..?
case 70:
result = ubase/100; break;
case 0:
case 100: // solar: confirmed 2/6/04
result = ubase; break;
case 101: // solar: confirmed 2/6/04
result = updownsign * (ubase + (caster_level / 2)); break;
case 102: // solar: confirmed 2/6/04
result = updownsign * (ubase + caster_level); break;
case 103: // solar: confirmed 2/6/04
result = updownsign * (ubase + (caster_level * 2)); break;
case 104: // solar: confirmed 2/6/04
result = updownsign * (ubase + (caster_level * 3)); break;
case 105: // solar: confirmed 2/6/04
result = updownsign * (ubase + (caster_level * 4)); break;
case 107:
//Used on Reckless Strength, I think it should decay over time
result = updownsign * (ubase + (caster_level / 2)); break;
case 108:
result = updownsign * (ubase + (caster_level / 3)); break;
case 109: // solar: confirmed 2/6/04
result = updownsign * (ubase + (caster_level / 4)); break;
case 110: // solar: confirmed 2/6/04
//is there a reason we dont use updownsign here???
result = ubase + (caster_level / 5); break;
case 111:
result = updownsign * (ubase + 6 * (caster_level - GetMinLevel(spell))); break;
case 112:
result = updownsign * (ubase + 8 * (caster_level - GetMinLevel(spell))); break;
case 113:
result = updownsign * (ubase + 10 * (caster_level - GetMinLevel(spell))); break;
case 114:
result = updownsign * (ubase + 15 * (caster_level - GetMinLevel(spell))); break;
//these formula were updated according to lucy 10/16/04
case 115: // solar: this is only in symbol of transal
result = ubase + 6 * (caster_level - GetMinLevel(spell)); break;
case 116: // solar: this is only in symbol of ryltan
result = ubase + 8 * (caster_level - GetMinLevel(spell)); break;
case 117: // solar: this is only in symbol of pinzarn
result = ubase + 12 * (caster_level - GetMinLevel(spell)); break;
case 118: // solar: used in naltron and a few others
result = ubase + 20 * (caster_level - GetMinLevel(spell)); break;
case 119: // solar: confirmed 2/6/04
result = ubase + (caster_level / 8); break;
case 121: // solar: corrected 2/6/04
result = ubase + (caster_level / 3); break;
case 122: {
int ticdif = spell->Get().buffduration - (ticsremaining-1);
if(ticdif < 0)
ticdif = 0;
result = -(11 + 11*ticdif);
break;
}
case 123: // solar: added 2/6/04
result = MakeRandomInt(ubase, abs(max));
break;
//these are used in stacking effects... formula unknown
case 201:
case 203:
result = max;
break;
default:
if (formula < 100)
result = ubase + (caster_level * formula);
//else
// LogFile->write(EQEMuLog::Debug, "Unknown spell effect value forumula %d", formula);
}
int oresult = result;
// now check result against the allowed maximum
if (max != 0)
{
if (updownsign == 1)
{
if (result > max)
result = max;
}
else
{
if (result < max)
result = max;
}
}
// if base is less than zero, then the result need to be negative too
if (base < 0 && result > 0)
result *= -1;
//mlog(SPELLS__EFFECT_VALUES, "Result: %d (orig %d), cap %d %s", result, oresult, max, (base < 0 && result > 0)?"Inverted due to negative base":"");
return result;
}
