skill.cpp.svn-base

絲路server源碼 Silk Road server source

#define SKILLS_CHANNEL_UPDATE_INTERVAL 1000

extern pEffect SKILLSEffects[TOTAL_SKILLS_EFFECTS];

bool IsQuestTameSKILLS(uint32 SKILLSId)
{
    SKILLSid const *SKILLSproto = sSKILLSStore.Lookupid(SKILLSId);
    if (!SKILLSproto) return false;

    return SKILLSproto->Effect[0] == SKILLS_EFFECT_THREAT
        && SKILLSproto->Effect[1] == SKILLS_EFFECT_APPLY_AURA && SKILLSproto->EffectApplyAuraName[1] == SKILLS_AURA_DUMMY;
}

SKILLSCastTargets::SKILLSCastTargets()
{
    m_unitTarget = NULL;
    m_itemTarget = NULL;
    m_GOTarget   = NULL;

    m_unitTargetGUID   = 0;
    m_GOTargetGUID     = 0;
    m_CorpseTargetGUID = 0;
    m_itemTargetGUID   = 0;

    m_srcX = m_srcY = m_srcZ = m_destX = m_destY = m_destZ = 0;
    m_strTarget = "";
    m_targetMask = 0;
}

SKILLSCastTargets::~SKILLSCastTargets()
{
}

void SKILLSCastTargets::setUnitTarget(Unit *target)
{
    if (!target)
        return;

    m_destX = target->GetPositionX();
    m_destY = target->GetPositionY();
    m_destZ = target->GetPositionZ();
    m_unitTarget = target;
    m_unitTargetGUID = target->GetGUID();
    m_targetMask |= TARGET_FLAG_UNIT;
}

void SKILLSCastTargets::setDestination(float x, float y, float z)
{
    m_destX = x;
    m_destY = y;
    m_destZ = z;
    m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}

void SKILLSCastTargets::setGOTarget(GameObject *target)
{
    m_GOTarget = target;
    m_GOTargetGUID = target->GetGUID();
    //    m_targetMask |= TARGET_FLAG_OBJECT;
}

void SKILLSCastTargets::setItemTarget(Item* item)
{
    if(!item)
        return;

    m_itemTarget = item;
    m_itemTargetGUID = item->GetGUID();
    m_targetMask |= TARGET_FLAG_ITEM;
}

void SKILLSCastTargets::setCorpseTarget(Corpse* corpse)
{
    m_CorpseTargetGUID = corpse->GetGUID();
}

void SKILLSCastTargets::Update(Unit* caster)
{
    m_GOTarget   = m_GOTargetGUID ? ObjectAccessor::GetGameObject(*caster,m_GOTargetGUID) : NULL;
    m_unitTarget = m_unitTargetGUID ?
        ( m_unitTargetGUID==caster->GetGUID() ? caster : ObjectAccessor::GetUnit(*caster, m_unitTargetGUID) ) :
    NULL;

    m_itemTarget = NULL;
    if(caster->GetTypeId()==TYPEID_PLAYER)
    {
        if(m_targetMask & TARGET_FLAG_ITEM)
            m_itemTarget = ((Player*)caster)->GetItemByGuid(m_itemTargetGUID);
        else
        {
            Player* pTrader = ((Player*)caster)->GetTrader();
            if(pTrader && m_itemTargetGUID < TRADE_SLOT_COUNT)
                m_itemTarget = pTrader->GetItemByPos(pTrader->GetItemPosByTradeSlot(m_itemTargetGUID));
        }
    }
}

bool SKILLSCastTargets::read ( WorldPacket * data, Unit *caster )
{
    if(data->rpos()+2 > data->size())
        return false;

    *data >> m_targetMask;

    if(m_targetMask == TARGET_FLAG_SELF)
    {
        m_destX = caster->GetPositionX();
        m_destY = caster->GetPositionY();
        m_destZ = caster->GetPositionZ();
        m_unitTarget = caster;
        m_unitTargetGUID = caster->GetGUID();
        return true;
    }

    if( m_targetMask & TARGET_FLAG_UNIT )
        if(!readGUID(*data, m_unitTargetGUID))
            return false;

    if( m_targetMask & ( TARGET_FLAG_OBJECT | TARGET_FLAG_OBJECT_UNK ))
        if(!readGUID(*data, m_GOTargetGUID))
            return false;

    if(( m_targetMask & ( TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM )) && caster->GetTypeId() == TYPEID_PLAYER)
        if(!readGUID(*data, m_itemTargetGUID))
            return false;

    if( m_targetMask & TARGET_FLAG_SOURCE_LOCATION )
    {
        if(data->rpos()+4+4+4 > data->size())
            return false;

        *data >> m_srcX >> m_srcY >> m_srcZ;
        if(!VENICE::IsValidMapCoord(m_srcX, m_srcY))
            return false;
    }

    if( m_targetMask & TARGET_FLAG_DEST_LOCATION )
    {
        if(data->rpos()+4+4+4 > data->size())
            return false;

        *data >> m_destX >> m_destY >> m_destZ;
        if(!VENICE::IsValidMapCoord(m_destX, m_destY))
            return false;
    }

    if( m_targetMask & TARGET_FLAG_STRING )
    {
        if(data->rpos()+1 > data->size())
            return false;

        *data >> m_strTarget;
    }

    if( m_targetMask & (TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE ) )
        if(!readGUID(*data, m_CorpseTargetGUID))
            return false;

    // find real units/GOs
    Update(caster);
    return true;
}

void SKILLSCastTargets::write ( WorldPacket * data )
{
    *data << uint32(m_targetMask);

    if(m_targetMask & TARGET_FLAG_UNIT)
    {
        if(m_unitTarget)
            data->append(m_unitTarget->GetPackGUID());
        else
            *data << uint8(0);
    }

    if( m_targetMask & ( TARGET_FLAG_OBJECT | TARGET_FLAG_OBJECT_UNK ) )
    {
        if(m_GOTarget)
            data->append(m_GOTarget->GetPackGUID());
        else
            *data << uint8(0);
    }

    if( m_targetMask & ( TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM ) )
    {
        if(m_itemTarget)
            data->append(m_itemTarget->GetPackGUID());
        else
            *data << uint8(0);
    }

    if( m_targetMask & TARGET_FLAG_SOURCE_LOCATION )
        *data << m_srcX << m_srcY << m_srcZ;

    if( m_targetMask & TARGET_FLAG_DEST_LOCATION )
        *data << m_destX << m_destY << m_destZ;

    if( m_targetMask & TARGET_FLAG_STRING )
        *data << m_strTarget;

    if( m_targetMask & ( TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE ) )
        data->appendPackGUID(m_CorpseTargetGUID);
}

SKILLS::SKILLS( Unit* Caster, SKILLSid const *info, bool triggered, uint64 originalCasterGUID, SKILLS** triggeringContainer )
{
    ASSERT( Caster != NULL && info != NULL );
    ASSERT( info == sSKILLSStore.Lookupid( info->Id ) && "`info` must be pointer to sSKILLSStore element");

    m_SKILLSInfo = info;
    m_caster = Caster;
    m_selfContainer = NULL;
    m_triggeringContainer = triggeringContainer;
    m_deletable = true;

    // Get data for type of attack
    switch (m_SKILLSInfo->DmgClass)
    {
     case SKILLS_DAMAGE_CLASS_MELEE:
         if (m_SKILLSInfo->AttributesEx3 & 0x1000000) m_attackType = OFF_ATTACK;
         else                                        m_attackType = BASE_ATTACK;
         break;
     case SKILLS_DAMAGE_CLASS_RANGED: 
         m_attackType = RANGED_ATTACK; 
         break;
     default:
         if (m_SKILLSInfo->Id == 5019) m_attackType = RANGED_ATTACK; // Wands
         else                         m_attackType = BASE_ATTACK;
         break;
    }

    m_SKILLSSchoolMask = GetSKILLSSchoolMask(info);           // Can be override for some SKILLS (wand shoot for example)

    if(m_attackType == RANGED_ATTACK)
    {
        // wand case
        if((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->GetTypeId()==TYPEID_PLAYER)
        {
            if(Item* pItem = ((Player*)m_caster)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED))
                m_SKILLSSchoolMask = SKILLSSchoolMask(1 << pItem->GetProto()->Damage->DamageType);
        }
    }

    if(originalCasterGUID)
        m_originalCasterGUID = originalCasterGUID;
    else
        m_originalCasterGUID = m_caster->GetGUID();

    if(m_originalCasterGUID==m_caster->GetGUID())
        m_originalCaster = m_caster;
    else
        m_originalCaster = ObjectAccessor::GetUnit(*m_caster,m_originalCasterGUID);

    for(int i=0; i <3; ++i)
        m_currentBasePoints[i] = m_SKILLSInfo->EffectBasePoints[i];

    m_SKILLSState = SKILLS_STATE_NULL;

    m_castPositionX = m_castPositionY = m_castPositionZ = 0;
    m_TriggerSKILLSs.clear();
    m_IsTriggeredSKILLS = triggered;
    //m_AreaAura = false;
    m_CastItem = NULL;

    unitTarget = NULL;
    itemTarget = NULL;
    gameObjTarget = NULL;
    focusObject = NULL;
    m_cast_count = 0;
    m_triggeredByAuraSKILLS  = NULL;

    m_autoRepeat = false;
    if( m_SKILLSInfo->AttributesEx2 == 0x000020 )            //Auto Shot & Shoot
        m_autoRepeat = true;

    m_casttime = 0;                                         // setup to correct value in SKILLS::prepare, don't must be used before.
    m_timer = 0;                                            // will set to castime in preper

    m_needAliveTargetMask = 0;

    m_meleeSKILLS = false;

    m_rangedShoot = ((m_SKILLSInfo->Attributes & 18) == 18);
    if( m_SKILLSInfo->StartRecoveryTime == 0 && !m_autoRepeat && !m_rangedShoot )
    {
        for (int i = 0; i < 3; i++)
        {
            if (m_SKILLSInfo->Effect[i]==SKILLS_EFFECT_WEAPON_DAMAGE_NOSCHOOL ||
                m_SKILLSInfo->Effect[i]==SKILLS_EFFECT_WEAPON_DAMAGE)
            {
                m_meleeSKILLS = true;
                break;
            }
        }
    }

    // determine reflection
    m_canReflect = false;

    if(m_SKILLSInfo->DmgClass == SKILLS_DAMAGE_CLASS_MAGIC && (m_SKILLSInfo->AttributesEx2 & 0x4)==0)
    {
        for(int j=0;j<3;j++)
        {
            if (m_SKILLSInfo->Effect[j]==0)
                continue;

            if(!IsPositiveTarget(m_SKILLSInfo->EffectImplicitTargetA[j],m_SKILLSInfo->EffectImplicitTargetB[j]))
                m_canReflect = true;
            else
                m_canReflect = (m_SKILLSInfo->AttributesEx & (1<<7)) ? true : false;

            if(m_canReflect)
                continue;
            else
                break;
        }
    }

    CleanupTargetList();
}

SKILLS::~SKILLS()