public bool CanUseEssences()
{
PlayerConditionRecord condition = CliDB.PlayerConditionStorage.LookupByKey(PlayerConst.PlayerConditionIdUnlockedAzeriteEssences);
if (condition != null)
{
return(ConditionManager.IsPlayerMeetingCondition(GetOwner(), condition));
}
return(false);
}
public int GetCompleteNodeRoute(TaxiNodesRecord from, TaxiNodesRecord to, Player player, List <uint> shortestPath)
{
/*
* Information about node algorithm from client
* Since client does not give information about *ALL* nodes you have to pass by when going from sourceNodeID to destinationNodeID, we need to use Dijkstra algorithm.
* Examining several paths I discovered the following algorithm:
* If destinationNodeID has is the next destination, connected directly to sourceNodeID, then, client just pick up this route regardless of distance
* else we use dijkstra to find the shortest path.
* When early landing is requested, according to behavior on retail, you can never end in a node you did not discovered before
*/
// Find if we have a direct path
uint pathId, goldCost;
Global.ObjectMgr.GetTaxiPath(from.Id, to.Id, out pathId, out goldCost);
if (pathId != 0)
{
shortestPath.Add(from.Id);
shortestPath.Add(to.Id);
}
else
{
shortestPath.Clear();
// We want to use Dijkstra on this graph
DijkstraShortestPath g = new DijkstraShortestPath(m_graph, (int)GetVertexIDFromNodeID(from));
var path = g.PathTo((int)GetVertexIDFromNodeID(to));
// found a path to the goal
shortestPath.Add(from.Id);
foreach (var edge in path)
{
//todo test me No clue about this....
var To = m_nodesByVertex[(int)edge.To];
TaxiNodeFlags requireFlag = (player.GetTeam() == Team.Alliance) ? TaxiNodeFlags.Alliance : TaxiNodeFlags.Horde;
if (!To.Flags.HasAnyFlag(requireFlag))
{
continue;
}
PlayerConditionRecord condition = CliDB.PlayerConditionStorage.LookupByKey(To.ConditionID);
if (condition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(player, condition))
{
continue;
}
}
shortestPath.Add(GetNodeIDFromVertexID(edge.To));
}
}
return(shortestPath.Count);
}
public bool AddMount(uint spellId, MountStatusFlags flags, bool factionMount = false, bool learned = false)
{
Player player = _owner.GetPlayer();
if (!player)
{
return(false);
}
MountRecord mount = Global.DB2Mgr.GetMount(spellId);
if (mount == null)
{
return(false);
}
var value = FactionSpecificMounts.LookupByKey(spellId);
if (value != 0 && !factionMount)
{
AddMount(value, flags, true, learned);
}
_mounts[spellId] = flags;
// Mount condition only applies to using it, should still learn it.
if (mount.PlayerConditionID != 0)
{
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(mount.PlayerConditionID);
if (playerCondition != null && !ConditionManager.IsPlayerMeetingCondition(player, playerCondition))
{
return(false);
}
}
if (!learned)
{
if (!factionMount)
{
SendSingleMountUpdate(spellId, flags);
}
if (!player.HasSpell(spellId))
{
player.LearnSpell(spellId, true);
}
}
return(true);
}
void HandleRequestLatestSplashScreen(RequestLatestSplashScreen requestLatestSplashScreen)
{
UISplashScreenRecord splashScreen = null;
foreach (var itr in CliDB.UISplashScreenStorage.Values)
{
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(itr.CharLevelConditionID);
if (playerCondition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(_player, playerCondition))
{
continue;
}
}
splashScreen = itr;
}
SplashScreenShowLatest splashScreenShowLatest = new();
splashScreenShowLatest.UISplashScreenID = splashScreen != null ? splashScreen.Id : 0;
SendPacket(splashScreenShowLatest);
}
void HandleTransmogrifyItems(TransmogrifyItems transmogrifyItems)
{
Player player = GetPlayer();
// Validate
if (!player.GetNPCIfCanInteractWith(transmogrifyItems.Npc, NPCFlags.Transmogrifier, NPCFlags2.None))
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - Unit (GUID: {0}) not found or player can't interact with it.", transmogrifyItems.ToString());
return;
}
long cost = 0;
Dictionary <Item, uint[]> transmogItems = new();// new Dictionary<Item, Tuple<uint, uint>>();
Dictionary <Item, uint> illusionItems = new();
List <Item> resetAppearanceItems = new();
List <Item> resetIllusionItems = new();
List <uint> bindAppearances = new();
bool validateAndStoreTransmogItem(Item itemTransmogrified, uint itemModifiedAppearanceId, bool isSecondary)
{
var itemModifiedAppearance = CliDB.ItemModifiedAppearanceStorage.LookupByKey(itemModifiedAppearanceId);
if (itemModifiedAppearance == null)
{
Log.outDebug(LogFilter.Network, $"WORLD: HandleTransmogrifyItems - {player.GetGUID()}, Name: {player.GetName()} tried to transmogrify using invalid appearance ({itemModifiedAppearanceId}).");
return(false);
}
if (isSecondary && itemTransmogrified.GetTemplate().GetInventoryType() != InventoryType.Shoulders)
{
Log.outDebug(LogFilter.Network, $"WORLD: HandleTransmogrifyItems - {player.GetGUID()}, Name: {player.GetName()} tried to transmogrify secondary appearance to non-shoulder item.");
return(false);
}
bool hasAppearance, isTemporary;
(hasAppearance, isTemporary) = GetCollectionMgr().HasItemAppearance(itemModifiedAppearanceId);
if (!hasAppearance)
{
Log.outDebug(LogFilter.Network, $"WORLD: HandleTransmogrifyItems - {player.GetGUID()}, Name: {player.GetName()} tried to transmogrify using appearance he has not collected ({itemModifiedAppearanceId}).");
return(false);
}
ItemTemplate itemTemplate = Global.ObjectMgr.GetItemTemplate(itemModifiedAppearance.ItemID);
if (player.CanUseItem(itemTemplate) != InventoryResult.Ok)
{
Log.outDebug(LogFilter.Network, $"WORLD: HandleTransmogrifyItems - {player.GetGUID()}, Name: {player.GetName()} tried to transmogrify using appearance he can never use ({itemModifiedAppearanceId}).");
return(false);
}
// validity of the transmogrification items
if (!Item.CanTransmogrifyItemWithItem(itemTransmogrified, itemModifiedAppearance))
{
Log.outDebug(LogFilter.Network, $"WORLD: HandleTransmogrifyItems - {player.GetGUID()}, Name: {player.GetName()} failed CanTransmogrifyItemWithItem ({itemTransmogrified.GetEntry()} with appearance {itemModifiedAppearanceId}).");
return(false);
}
if (!transmogItems.ContainsKey(itemTransmogrified))
{
transmogItems[itemTransmogrified] = new uint[2];
}
if (!isSecondary)
{
transmogItems[itemTransmogrified][0] = itemModifiedAppearanceId;
}
else
{
transmogItems[itemTransmogrified][1] = itemModifiedAppearanceId;
}
if (isTemporary)
{
bindAppearances.Add(itemModifiedAppearanceId);
}
return(true);
};
foreach (TransmogrifyItem transmogItem in transmogrifyItems.Items)
{
// slot of the transmogrified item
if (transmogItem.Slot >= EquipmentSlot.End)
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - Player ({0}, name: {1}) tried to transmogrify wrong slot {2} when transmogrifying items.", player.GetGUID().ToString(), player.GetName(), transmogItem.Slot);
return;
}
// transmogrified item
Item itemTransmogrified = player.GetItemByPos(InventorySlots.Bag0, (byte)transmogItem.Slot);
if (!itemTransmogrified)
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - Player (GUID: {0}, name: {1}) tried to transmogrify an invalid item in a valid slot (slot: {2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.Slot);
return;
}
if (transmogItem.ItemModifiedAppearanceID != 0 || transmogItem.SecondaryItemModifiedAppearanceID != 0)
{
if (!validateAndStoreTransmogItem(itemTransmogrified, (uint)transmogItem.ItemModifiedAppearanceID, false))
{
return;
}
if (!validateAndStoreTransmogItem(itemTransmogrified, (uint)transmogItem.SecondaryItemModifiedAppearanceID, true))
{
return;
}
// add cost
cost += itemTransmogrified.GetSellPrice(_player);
}
else
{
resetAppearanceItems.Add(itemTransmogrified);
}
if (transmogItem.SpellItemEnchantmentID != 0)
{
if (transmogItem.Slot != EquipmentSlot.MainHand && transmogItem.Slot != EquipmentSlot.OffHand)
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - {0}, Name: {1} tried to transmogrify illusion into non-weapon slot ({2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.Slot);
return;
}
SpellItemEnchantmentRecord illusion = CliDB.SpellItemEnchantmentStorage.LookupByKey(transmogItem.SpellItemEnchantmentID);
if (illusion == null)
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - {0}, Name: {1} tried to transmogrify illusion using invalid enchant ({2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.SpellItemEnchantmentID);
return;
}
if (illusion.ItemVisual == 0 || !illusion.Flags.HasAnyFlag(EnchantmentSlotMask.Collectable))
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - {0}, Name: {1} tried to transmogrify illusion using not allowed enchant ({2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.SpellItemEnchantmentID);
return;
}
PlayerConditionRecord condition = CliDB.PlayerConditionStorage.LookupByKey(illusion.TransmogUseConditionID);
if (condition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(player, condition))
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - {0}, Name: {1} tried to transmogrify illusion using not allowed enchant ({2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.SpellItemEnchantmentID);
return;
}
}
if (illusion.ScalingClassRestricted > 0 && illusion.ScalingClassRestricted != (byte)player.GetClass())
{
Log.outDebug(LogFilter.Network, "WORLD: HandleTransmogrifyItems - {0}, Name: {1} tried to transmogrify illusion using not allowed class enchant ({2}).", player.GetGUID().ToString(), player.GetName(), transmogItem.SpellItemEnchantmentID);
return;
}
illusionItems[itemTransmogrified] = (uint)transmogItem.SpellItemEnchantmentID;
cost += illusion.TransmogCost;
}
else
{
resetIllusionItems.Add(itemTransmogrified);
}
}
if (!player.HasAuraType(AuraType.RemoveTransmogCost) && cost != 0) // 0 cost if reverting look
{
if (!player.HasEnoughMoney(cost))
{
return;
}
player.ModifyMoney(-cost);
}
// Everything is fine, proceed
foreach (var transmogPair in transmogItems)
{
Item transmogrified = transmogPair.Key;
if (!transmogrifyItems.CurrentSpecOnly)
{
transmogrified.SetModifier(ItemModifier.TransmogAppearanceAllSpecs, transmogPair.Value[0]);
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec1, 0);
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec2, 0);
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec3, 0);
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec4, 0);
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs, transmogPair.Value[1]);
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1, 0);
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2, 0);
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3, 0);
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4, 0);
}
else
{
if (transmogrified.GetModifier(ItemModifier.TransmogAppearanceSpec1) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec1, transmogrified.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogAppearanceSpec2) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec2, transmogrified.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogAppearanceSpec3) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec3, transmogrified.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogAppearanceSpec4) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogAppearanceSpec4, transmogrified.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1, transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2, transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3, transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4) == 0)
{
transmogrified.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4, transmogrified.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
transmogrified.SetModifier(ItemConst.AppearanceModifierSlotBySpec[player.GetActiveTalentGroup()], transmogPair.Value[0]);
transmogrified.SetModifier(ItemConst.SecondaryAppearanceModifierSlotBySpec[player.GetActiveTalentGroup()], transmogPair.Value[1]);
}
player.SetVisibleItemSlot(transmogrified.GetSlot(), transmogrified);
transmogrified.SetNotRefundable(player);
transmogrified.ClearSoulboundTradeable(player);
transmogrified.SetState(ItemUpdateState.Changed, player);
}
foreach (var illusionPair in illusionItems)
{
Item transmogrified = illusionPair.Key;
if (!transmogrifyItems.CurrentSpecOnly)
{
transmogrified.SetModifier(ItemModifier.EnchantIllusionAllSpecs, illusionPair.Value);
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec1, 0);
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec2, 0);
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec3, 0);
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec4, 0);
}
else
{
if (transmogrified.GetModifier(ItemModifier.EnchantIllusionSpec1) == 0)
{
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec1, transmogrified.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.EnchantIllusionSpec2) == 0)
{
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec2, transmogrified.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.EnchantIllusionSpec3) == 0)
{
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec3, transmogrified.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (transmogrified.GetModifier(ItemModifier.EnchantIllusionSpec4) == 0)
{
transmogrified.SetModifier(ItemModifier.EnchantIllusionSpec4, transmogrified.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
transmogrified.SetModifier(ItemConst.IllusionModifierSlotBySpec[player.GetActiveTalentGroup()], illusionPair.Value);
}
player.SetVisibleItemSlot(transmogrified.GetSlot(), transmogrified);
transmogrified.SetNotRefundable(player);
transmogrified.ClearSoulboundTradeable(player);
transmogrified.SetState(ItemUpdateState.Changed, player);
}
foreach (Item item in resetAppearanceItems)
{
if (!transmogrifyItems.CurrentSpecOnly)
{
item.SetModifier(ItemModifier.TransmogAppearanceAllSpecs, 0);
item.SetModifier(ItemModifier.TransmogAppearanceSpec1, 0);
item.SetModifier(ItemModifier.TransmogAppearanceSpec2, 0);
item.SetModifier(ItemModifier.TransmogAppearanceSpec3, 0);
item.SetModifier(ItemModifier.TransmogAppearanceSpec4, 0);
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs, 0);
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1, 0);
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2, 0);
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3, 0);
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4, 0);
}
else
{
if (item.GetModifier(ItemModifier.TransmogAppearanceSpec1) == 0)
{
item.SetModifier(ItemModifier.TransmogAppearanceSpec1, item.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogAppearanceSpec2) == 0)
{
item.SetModifier(ItemModifier.TransmogAppearanceSpec2, item.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogAppearanceSpec2) == 0)
{
item.SetModifier(ItemModifier.TransmogAppearanceSpec3, item.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogAppearanceSpec4) == 0)
{
item.SetModifier(ItemModifier.TransmogAppearanceSpec4, item.GetModifier(ItemModifier.TransmogAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1) == 0)
{
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec1, item.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2) == 0)
{
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec2, item.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3) == 0)
{
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec3, item.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
if (item.GetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4) == 0)
{
item.SetModifier(ItemModifier.TransmogSecondaryAppearanceSpec4, item.GetModifier(ItemModifier.TransmogSecondaryAppearanceAllSpecs));
}
item.SetModifier(ItemConst.AppearanceModifierSlotBySpec[player.GetActiveTalentGroup()], 0);
item.SetModifier(ItemConst.SecondaryAppearanceModifierSlotBySpec[player.GetActiveTalentGroup()], 0);
item.SetModifier(ItemModifier.EnchantIllusionAllSpecs, 0);
}
item.SetState(ItemUpdateState.Changed, player);
player.SetVisibleItemSlot(item.GetSlot(), item);
}
foreach (Item item in resetIllusionItems)
{
if (!transmogrifyItems.CurrentSpecOnly)
{
item.SetModifier(ItemModifier.EnchantIllusionAllSpecs, 0);
item.SetModifier(ItemModifier.EnchantIllusionSpec1, 0);
item.SetModifier(ItemModifier.EnchantIllusionSpec2, 0);
item.SetModifier(ItemModifier.EnchantIllusionSpec3, 0);
item.SetModifier(ItemModifier.EnchantIllusionSpec4, 0);
}
else
{
if (item.GetModifier(ItemModifier.EnchantIllusionSpec1) == 0)
{
item.SetModifier(ItemModifier.EnchantIllusionSpec1, item.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (item.GetModifier(ItemModifier.EnchantIllusionSpec2) == 0)
{
item.SetModifier(ItemModifier.EnchantIllusionSpec2, item.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (item.GetModifier(ItemModifier.EnchantIllusionSpec3) == 0)
{
item.SetModifier(ItemModifier.EnchantIllusionSpec3, item.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
if (item.GetModifier(ItemModifier.EnchantIllusionSpec4) == 0)
{
item.SetModifier(ItemModifier.EnchantIllusionSpec4, item.GetModifier(ItemModifier.EnchantIllusionAllSpecs));
}
item.SetModifier(ItemConst.IllusionModifierSlotBySpec[player.GetActiveTalentGroup()], 0);
item.SetModifier(ItemModifier.TransmogAppearanceAllSpecs, 0);
}
item.SetState(ItemUpdateState.Changed, player);
player.SetVisibleItemSlot(item.GetSlot(), item);
}
foreach (uint itemModifedAppearanceId in bindAppearances)
{
var itemsProvidingAppearance = GetCollectionMgr().GetItemsProvidingTemporaryAppearance(itemModifedAppearanceId);
foreach (ObjectGuid itemGuid in itemsProvidingAppearance)
{
Item item = player.GetItemByGuid(itemGuid);
if (item)
{
item.SetNotRefundable(player);
item.ClearSoulboundTradeable(player);
GetCollectionMgr().AddItemAppearance(item);
}
}
}
}
public void BuildQuestRewards(QuestRewards rewards, Player player)
{
rewards.ChoiceItemCount = GetRewChoiceItemsCount();
rewards.ItemCount = GetRewItemsCount();
rewards.Money = player.GetQuestMoneyReward(this);
rewards.XP = player.GetQuestXPReward(this);
rewards.ArtifactCategoryID = RewardArtifactCategoryID;
rewards.Title = RewardTitleId;
rewards.FactionFlags = RewardReputationMask;
var displaySpellIndex = 0;
foreach (QuestRewardDisplaySpell displaySpell in RewardDisplaySpell)
{
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(displaySpell.PlayerConditionId);
if (playerCondition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(player, playerCondition))
{
continue;
}
}
rewards.SpellCompletionDisplayID[displaySpellIndex] = (int)displaySpell.SpellId;
if (++displaySpellIndex >= rewards.SpellCompletionDisplayID.Length)
{
break;
}
}
rewards.SpellCompletionID = RewardSpell;
rewards.SkillLineID = RewardSkillId;
rewards.NumSkillUps = RewardSkillPoints;
rewards.TreasurePickerID = (uint)TreasurePickerID;
for (int i = 0; i < SharedConst.QuestRewardChoicesCount; ++i)
{
rewards.ChoiceItems[i].LootItemType = RewardChoiceItemType[i];
rewards.ChoiceItems[i].Item = new ItemInstance();
rewards.ChoiceItems[i].Item.ItemID = RewardChoiceItemId[i];
rewards.ChoiceItems[i].Quantity = RewardChoiceItemCount[i];
}
for (int i = 0; i < SharedConst.QuestRewardItemCount; ++i)
{
rewards.ItemID[i] = RewardItemId[i];
rewards.ItemQty[i] = RewardItemCount[i];
}
for (int i = 0; i < SharedConst.QuestRewardReputationsCount; ++i)
{
rewards.FactionID[i] = RewardFactionId[i];
rewards.FactionOverride[i] = RewardFactionOverride[i];
rewards.FactionValue[i] = RewardFactionValue[i];
rewards.FactionCapIn[i] = RewardFactionCapIn[i];
}
for (int i = 0; i < SharedConst.QuestRewardCurrencyCount; ++i)
{
rewards.CurrencyID[i] = RewardCurrencyId[i];
rewards.CurrencyQty[i] = RewardCurrencyCount[i];
}
}
void HandleArtifactSetAppearance(ArtifactSetAppearance artifactSetAppearance)
{
if (!_player.GetGameObjectIfCanInteractWith(artifactSetAppearance.ForgeGUID, GameObjectTypes.ItemForge))
{
return;
}
ArtifactAppearanceRecord artifactAppearance = CliDB.ArtifactAppearanceStorage.LookupByKey(artifactSetAppearance.ArtifactAppearanceID);
if (artifactAppearance == null)
{
return;
}
Item artifact = _player.GetItemByGuid(artifactSetAppearance.ArtifactGUID);
if (!artifact)
{
return;
}
ArtifactAppearanceSetRecord artifactAppearanceSet = CliDB.ArtifactAppearanceSetStorage.LookupByKey(artifactAppearance.ArtifactAppearanceSetID);
if (artifactAppearanceSet == null || artifactAppearanceSet.ArtifactID != artifact.GetTemplate().GetArtifactID())
{
return;
}
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(artifactAppearance.UnlockPlayerConditionID);
if (playerCondition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(_player, playerCondition))
{
return;
}
}
artifact.SetAppearanceModId(artifactAppearance.ItemAppearanceModifierID);
artifact.SetModifier(ItemModifier.ArtifactAppearanceId, artifactAppearance.Id);
artifact.SetState(ItemUpdateState.Changed, _player);
Item childItem = _player.GetChildItemByGuid(artifact.GetChildItem());
if (childItem)
{
childItem.SetAppearanceModId(artifactAppearance.ItemAppearanceModifierID);
childItem.SetState(ItemUpdateState.Changed, _player);
}
if (artifact.IsEquipped())
{
// change weapon appearance
_player.SetVisibleItemSlot(artifact.GetSlot(), artifact);
if (childItem)
{
_player.SetVisibleItemSlot(childItem.GetSlot(), childItem);
}
// change druid form appearance
if (artifactAppearance.OverrideShapeshiftDisplayID != 0 && artifactAppearance.OverrideShapeshiftFormID != 0 && _player.GetShapeshiftForm() == (ShapeShiftForm)artifactAppearance.OverrideShapeshiftFormID)
{
_player.RestoreDisplayId(_player.IsMounted());
}
}
}
public void SendListInventory(ObjectGuid vendorGuid)
{
Creature vendor = GetPlayer().GetNPCIfCanInteractWith(vendorGuid, NPCFlags.Vendor);
if (vendor == null)
{
Log.outDebug(LogFilter.Network, "WORLD: SendListInventory - {0} not found or you can not interact with him.", vendorGuid.ToString());
GetPlayer().SendSellError(SellResult.CantFindVendor, null, ObjectGuid.Empty);
return;
}
// remove fake death
if (GetPlayer().HasUnitState(UnitState.Died))
{
GetPlayer().RemoveAurasByType(AuraType.FeignDeath);
}
// Stop the npc if moving
if (vendor.HasUnitState(UnitState.Moving))
{
vendor.StopMoving();
}
VendorItemData vendorItems = vendor.GetVendorItems();
int rawItemCount = vendorItems != null?vendorItems.GetItemCount() : 0;
VendorInventory packet = new VendorInventory();
packet.Vendor = vendor.GetGUID();
float discountMod = GetPlayer().GetReputationPriceDiscount(vendor);
byte count = 0;
for (uint slot = 0; slot < rawItemCount; ++slot)
{
VendorItem vendorItem = vendorItems.GetItem(slot);
if (vendorItem == null)
{
continue;
}
VendorItemPkt item = new VendorItemPkt();
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(vendorItem.PlayerConditionId);
if (playerCondition != null)
{
if (!ConditionManager.IsPlayerMeetingCondition(_player, playerCondition))
{
item.PlayerConditionFailed = (int)playerCondition.Id;
}
}
if (vendorItem.Type == ItemVendorType.Item)
{
ItemTemplate itemTemplate = Global.ObjectMgr.GetItemTemplate(vendorItem.item);
if (itemTemplate == null)
{
continue;
}
int leftInStock = vendorItem.maxcount == 0 ? -1 : (int)vendor.GetVendorItemCurrentCount(vendorItem);
if (!GetPlayer().IsGameMaster())
{
if (!Convert.ToBoolean(itemTemplate.GetAllowableClass() & GetPlayer().getClassMask()) && itemTemplate.GetBonding() == ItemBondingType.OnAcquire)
{
continue;
}
if ((itemTemplate.GetFlags2().HasAnyFlag(ItemFlags2.FactionHorde) && GetPlayer().GetTeam() == Team.Alliance) ||
(itemTemplate.GetFlags2().HasAnyFlag(ItemFlags2.FactionAlliance) && GetPlayer().GetTeam() == Team.Horde))
{
continue;
}
if (leftInStock == 0)
{
continue;
}
}
if (!Global.ConditionMgr.IsObjectMeetingVendorItemConditions(vendor.GetEntry(), vendorItem.item, _player, vendor))
{
Log.outDebug(LogFilter.Condition, "SendListInventory: conditions not met for creature entry {0} item {1}", vendor.GetEntry(), vendorItem.item);
continue;
}
int price = (int)(vendorItem.IsGoldRequired(itemTemplate) ? Math.Floor(itemTemplate.GetBuyPrice() * discountMod) : 0);
int priceMod = GetPlayer().GetTotalAuraModifier(AuraType.ModVendorItemsPrices);
if (priceMod != 0)
{
price -= MathFunctions.CalculatePct(price, priceMod);
}
item.MuID = (int)slot + 1;
item.Durability = (int)itemTemplate.MaxDurability;
item.ExtendedCostID = (int)vendorItem.ExtendedCost;
item.Type = (int)vendorItem.Type;
item.Quantity = leftInStock;
item.StackCount = (int)itemTemplate.GetBuyCount();
item.Price = (ulong)price;
item.DoNotFilterOnVendor = vendorItem.IgnoreFiltering;
item.Item.ItemID = vendorItem.item;
if (!vendorItem.BonusListIDs.Empty())
{
item.Item.ItemBonus.HasValue = true;
item.Item.ItemBonus.Value.BonusListIDs = vendorItem.BonusListIDs;
}
packet.Items.Add(item);
}
else if (vendorItem.Type == ItemVendorType.Currency)
{
CurrencyTypesRecord currencyTemplate = CliDB.CurrencyTypesStorage.LookupByKey(vendorItem.item);
if (currencyTemplate == null)
{
continue;
}
if (vendorItem.ExtendedCost == 0)
{
continue; // there's no price defined for currencies, only extendedcost is used
}
item.MuID = (int)slot + 1; // client expects counting to start at 1
item.ExtendedCostID = (int)vendorItem.ExtendedCost;
item.Item.ItemID = vendorItem.item;
item.Type = (int)vendorItem.Type;
item.StackCount = (int)vendorItem.maxcount;
item.DoNotFilterOnVendor = vendorItem.IgnoreFiltering;
packet.Items.Add(item);
}
else
{
continue;
}
if (++count >= SharedConst.MaxVendorItems)
{
break;
}
}
SendPacket(packet);
}
void HandleActivateTaxi(ActivateTaxi activateTaxi)
{
Creature unit = GetPlayer().GetNPCIfCanInteractWith(activateTaxi.Vendor, NPCFlags.FlightMaster);
if (unit == null)
{
Log.outDebug(LogFilter.Network, "WORLD: HandleActivateTaxiOpcode - {0} not found or you can't interact with it.", activateTaxi.Vendor.ToString());
SendActivateTaxiReply(ActivateTaxiReply.TooFarAway);
return;
}
uint curloc = Global.ObjectMgr.GetNearestTaxiNode(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ(), unit.GetMapId(), GetPlayer().GetTeam());
if (curloc == 0)
{
return;
}
TaxiNodesRecord from = CliDB.TaxiNodesStorage.LookupByKey(curloc);
TaxiNodesRecord to = CliDB.TaxiNodesStorage.LookupByKey(activateTaxi.Node);
if (to == null)
{
return;
}
if (!GetPlayer().isTaxiCheater())
{
if (!GetPlayer().m_taxi.IsTaximaskNodeKnown(curloc) || !GetPlayer().m_taxi.IsTaximaskNodeKnown(activateTaxi.Node))
{
SendActivateTaxiReply(ActivateTaxiReply.NotVisited);
return;
}
}
uint preferredMountDisplay = 0;
MountRecord mount = CliDB.MountStorage.LookupByKey(activateTaxi.FlyingMountID);
if (mount != null)
{
if (GetPlayer().HasSpell(mount.SourceSpellID))
{
var mountDisplays = Global.DB2Mgr.GetMountDisplays(mount.Id);
if (mountDisplays != null)
{
List <MountXDisplayRecord> usableDisplays = mountDisplays.Where(mountDisplay =>
{
PlayerConditionRecord playerCondition = CliDB.PlayerConditionStorage.LookupByKey(mountDisplay.PlayerConditionID);
if (playerCondition != null)
{
return(ConditionManager.IsPlayerMeetingCondition(GetPlayer(), playerCondition));
}
return(true);
}).ToList();
if (!usableDisplays.Empty())
{
preferredMountDisplay = usableDisplays.SelectRandom().CreatureDisplayInfoID;
}
}
}
}
List <uint> nodes = new List <uint>();
Global.TaxiPathGraph.GetCompleteNodeRoute(from, to, GetPlayer(), nodes);
GetPlayer().ActivateTaxiPathTo(nodes, unit, 0, preferredMountDisplay);
}
