PlayerUpdates.cpp File Reference

#include "AchievementMgr.h"
#include "BattlefieldMgr.h"
#include "CellImpl.h"
#include "Channel.h"
#include "ChannelMgr.h"
#include "Formulas.h"
#include "GameTime.h"
#include "GridNotifiers.h"
#include "Group.h"
#include "Guild.h"
#include "InstanceScript.h"
#include "Language.h"
#include "OutdoorPvPMgr.h"
#include "Pet.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "SkillDiscovery.h"
#include "SpellAuraEffects.h"
#include "SpellMgr.h"
#include "UpdateFieldFlags.h"
#include "Vehicle.h"
#include "Weather.h"
#include "WeatherMgr.h"
#include "WorldState.h"
#include "WorldStatePackets.h"
#include "GridNotifiersImpl.h"

Go to the source code of this file.

Functions
int	SkillGainChance (uint32 SkillValue, uint32 GrayLevel, uint32 GreenLevel, uint32 YellowLevel)
int32	CraftSkillGainChance (uint32 skillValue, uint32 grayLevel, uint32 yellowLevel)
float	getProbabilityOfLevelUp (uint32 SkillValue)
template<class T >
void	UpdateVisibilityOf_helper (Player *player, T *target, std::vector< Unit * > &)
template<>
void	UpdateVisibilityOf_helper (Player *player, GameObject *target, std::vector< Unit * > &)
template<>
void	UpdateVisibilityOf_helper (Player *player, Creature *target, std::vector< Unit * > &v)
template<>
void	UpdateVisibilityOf_helper (Player *player, Player *target, std::vector< Unit * > &v)
template<class T >
void	BeforeVisibilityDestroy (T *, Player *)
template<>
void	BeforeVisibilityDestroy< Creature > (Creature *t, Player *p)

Variables
constexpr auto	ZONE_UPDATE_INTERVAL = 1000
static uint32	bonusSkillLevels [] = {75, 150, 225, 300, 375, 450}
static const std::size_t	bonusSkillLevelsSize

Function Documentation

BeforeVisibilityDestroy()

template<class T >

void BeforeVisibilityDestroy ( T *  , Player *    )

inline

{
}

BeforeVisibilityDestroy< Creature >()

template<>

void BeforeVisibilityDestroy< Creature > ( Creature *  t, Player *  p  )

inline

{
    if (p->GetPetGUID() == t->GetGUID() && t->IsPet())
        ((Pet*) t)->Remove(PET_SAVE_NOT_IN_SLOT, true);
}

References Object::GetGUID(), Unit::GetPetGUID(), Unit::IsPet(), and PET_SAVE_NOT_IN_SLOT.

Referenced by Player::UpdateVisibilityOf().

CraftSkillGainChance()

int32 CraftSkillGainChance ( uint32  skillValue, uint32  grayLevel, uint32  yellowLevel  )

inline

{
    int32 orangeChance = sWorld->getIntConfig(CONFIG_SKILL_CHANCE_ORANGE) * 10;
    int32 grayChance = sWorld->getIntConfig(CONFIG_SKILL_CHANCE_GREY) * 10;
 
    // Invalid or equal thresholds cannot be interpolated. Preserve the
    // previous orange/gray boundary behavior for malformed DBC entries.
    if (grayLevel <= yellowLevel)
        return skillValue < grayLevel ? orangeChance : grayChance;
 
    if (skillValue <= yellowLevel)
        return orangeChance;
    if (skillValue >= grayLevel)
        return grayChance;
 
    // Crafting skill-up chance falls linearly from orange at the yellow
    // threshold to gray at the gray threshold. The green threshold is the
    // midpoint of that range and therefore has a 50% chance by default.
    return grayChance + int32(int64(grayLevel - skillValue) * (orangeChance - grayChance) /
        (grayLevel - yellowLevel));
}

References CONFIG_SKILL_CHANCE_GREY, CONFIG_SKILL_CHANCE_ORANGE, and sWorld.

Referenced by Player::UpdateCraftSkill().

getProbabilityOfLevelUp()

float getProbabilityOfLevelUp

(

uint32

SkillValue

)

{
    /* According to El's Extreme Angling page, from 1 to 115 the probability of
     * a skill level up is 100% since 100/1 = 100. From 115 - 135 should average
     * 2 catches per skill up so that means 100/2 = 50%. This returns the
     * probability depending on the player's SkillValue.
     */
    if (!SkillValue)
    {
        return 0.0f;
    }
 
    std::array<uint32, 10> bounds {115, 135, 160, 190, 215,
                                   295, 315, 355, 425, 450};
    std::array<float, 11>  dens {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
                                9.0f, 10.0f, 11.0f, 12.0f, 1.0f};
    auto                   it =
        std::lower_bound(std::begin(bounds), std::end(bounds), SkillValue);
    return 100 / dens[std::distance(std::begin(bounds), it)];
}

Referenced by Player::UpdateFishingSkill().

SkillGainChance()

int SkillGainChance ( uint32  SkillValue, uint32  GrayLevel, uint32  GreenLevel, uint32  YellowLevel  )

inline

{
    if (SkillValue >= GrayLevel)
        return sWorld->getIntConfig(CONFIG_SKILL_CHANCE_GREY) * 10;
    if (SkillValue >= GreenLevel)
        return sWorld->getIntConfig(CONFIG_SKILL_CHANCE_GREEN) * 10;
    if (SkillValue >= YellowLevel)
        return sWorld->getIntConfig(CONFIG_SKILL_CHANCE_YELLOW) * 10;
    return sWorld->getIntConfig(CONFIG_SKILL_CHANCE_ORANGE) * 10;
}

References CONFIG_SKILL_CHANCE_GREEN, CONFIG_SKILL_CHANCE_GREY, CONFIG_SKILL_CHANCE_ORANGE, CONFIG_SKILL_CHANCE_YELLOW, and sWorld.

Referenced by Player::UpdateGatherSkill().

UpdateVisibilityOf_helper() [1/4]

template<>

void UpdateVisibilityOf_helper ( Player *  player, Creature *  target, std::vector< Unit * > &  v  )

inline

{
    player->GetObjectVisibilityContainer().LinkWorldObjectVisibility(target);
    v.push_back(target);
}

References WorldObject::GetObjectVisibilityContainer(), and ObjectVisibilityContainer::LinkWorldObjectVisibility().

UpdateVisibilityOf_helper() [2/4]

template<>

void UpdateVisibilityOf_helper ( Player *  player, GameObject *  target, std::vector< Unit * > &    )

inline

{
    player->GetObjectVisibilityContainer().LinkWorldObjectVisibility(target);
}

References WorldObject::GetObjectVisibilityContainer(), and ObjectVisibilityContainer::LinkWorldObjectVisibility().

UpdateVisibilityOf_helper() [3/4]

template<>

void UpdateVisibilityOf_helper ( Player *  player, Player *  target, std::vector< Unit * > &  v  )

inline

{
    player->GetObjectVisibilityContainer().LinkWorldObjectVisibility(target);
    v.push_back(target);
}

References WorldObject::GetObjectVisibilityContainer(), and ObjectVisibilityContainer::LinkWorldObjectVisibility().

UpdateVisibilityOf_helper() [4/4]

template<class T >

void UpdateVisibilityOf_helper ( Player *  player, T *  target, std::vector< Unit * > &    )

inline

{
    player->GetObjectVisibilityContainer().LinkWorldObjectVisibility(target);
}

References WorldObject::GetObjectVisibilityContainer(), and ObjectVisibilityContainer::LinkWorldObjectVisibility().

Referenced by Player::UpdateVisibilityOf().

Variable Documentation

bonusSkillLevels

uint32 bonusSkillLevels[] = {75, 150, 225, 300, 375, 450}

static

{75, 150, 225, 300, 375, 450};

Referenced by Player::UpdateSkillPro().

bonusSkillLevelsSize

const std::size_t bonusSkillLevelsSize

static

Initial value:

=
    sizeof(bonusSkillLevels) / sizeof(uint32)

Referenced by Player::UpdateSkillPro().

ZONE_UPDATE_INTERVAL

constexpr auto ZONE_UPDATE_INTERVAL = 1000

constexpr

Todo:

: this import is not necessary for compilation and marked as unused by the IDE

Referenced by Player::Update(), and Player::UpdateZone().