Ejemplo n.º 1
0
// Tower specific events
void OPvPCapturePointEP::UpdateTowerEvents()
{
    if (m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
    {
        uint32 team = (m_State == OBJECTIVESTATE_ALLIANCE) ? ALLIANCE : HORDE;
        switch (m_TowerType)
        {
        case EP_TOWER_CROWNGUARD:
            LinkGraveYard(team);
            break;
        case EP_TOWER_EASTWALL:
            SummonSupportUnits(team);
            break;
        case EP_TOWER_NORTHPASS:
            SummonShrine(team);
            break;
        case EP_TOWER_PLAGUEWOOD:
            SummonFlightMaster(team);
            break;
        }
    }
    else if (m_OldState == OBJECTIVESTATE_ALLIANCE || m_OldState == OBJECTIVESTATE_HORDE)
    {
        switch (m_TowerType)
        {
        case EP_TOWER_CROWNGUARD:
            UnlinkGraveYard();
            break;
        case EP_TOWER_EASTWALL:
            UnsummonSupportUnits();
            break;
        case EP_TOWER_NORTHPASS:
            UnsummonShrine();
            break;
        case EP_TOWER_PLAGUEWOOD:
            UnsummonFlightMaster();
            break;
        }
    }
}
Ejemplo n.º 2
0
bool OutdoorPvPEP::ProcessCaptureEvent(GameObject* go, uint32 towerId, Team team, uint32 newWorldState)
{
    if (team == ALLIANCE)
    {
        // update banner
        for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
            SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);

        // update counter
        ++m_towersAlliance;
        SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_ALLIANCE, m_towersAlliance);

        // buff players
        BuffTeam(ALLIANCE, plaguelandsTowerBuffs[m_towersAlliance - 1].spellIdAlliance);
    }
    else if (team == HORDE)
    {
        // update banner
        for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
            SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);

        // update counter
        ++m_towersHorde;
        SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_HORDE, m_towersHorde);

        // buff players
        BuffTeam(HORDE, plaguelandsTowerBuffs[m_towersHorde - 1].spellIdHorde);
    }
    else
    {
        // update banner
        for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
            SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);

        if (m_towerOwner[towerId] == ALLIANCE)
        {
            // update counter
            --m_towersAlliance;
            SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_ALLIANCE, m_towersAlliance);

            if (m_towersAlliance == 0)
                BuffTeam(ALLIANCE, plaguelandsTowerBuffs[0].spellIdAlliance, true);
        }
        else
        {
            // update counter
            --m_towersHorde;
            SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_HORDE, m_towersHorde);

            if (m_towersHorde == 0)
                BuffTeam(HORDE, plaguelandsTowerBuffs[0].spellIdHorde, true);
        }
    }

    bool eventHandled = true;

    if (team != TEAM_NONE)
    {
        // update capture point owner before rewards are applied
        m_towerOwner[towerId] = team;

        // apply rewards of changed tower
        switch (towerId)
        {
            case TOWER_ID_NORTHPASS:
                RespawnGO(go, team == ALLIANCE ? m_lordaeronShrineAlliance : m_lordaeronShrineHorde, true);
                break;
            case TOWER_ID_CROWNGUARD:
                sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_EASTERN_PLAGUE, GRAVEYARD_ZONE_EASTERN_PLAGUE, team);
                break;
            case TOWER_ID_EASTWALL:
                // Return false - allow the DB to handle summons
                if (m_towerOwner[TOWER_ID_NORTHPASS] != team)
                    eventHandled = false;
                break;
            case TOWER_ID_PLAGUEWOOD:
                // Return false - allow the DB to handle summons
                eventHandled = false;
                break;
        }
    }
    else
    {
        // remove rewards of changed tower
        switch (towerId)
        {
            case TOWER_ID_NORTHPASS:
                RespawnGO(go, m_towerOwner[TOWER_ID_NORTHPASS] == ALLIANCE ? m_lordaeronShrineAlliance : m_lordaeronShrineHorde, false);
                break;
            case TOWER_ID_CROWNGUARD:
                sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_EASTERN_PLAGUE, GRAVEYARD_ZONE_EASTERN_PLAGUE, TEAM_INVALID);
                break;
            case TOWER_ID_EASTWALL:
                UnsummonSoldiers(go);
                break;
            case TOWER_ID_PLAGUEWOOD:
                UnsummonFlightMaster(go);
                break;
        }

        // update capture point owner after rewards have been removed
        m_towerOwner[towerId] = team;
    }

    // update tower state
    SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_REMOVE);
    m_towerWorldState[towerId] = newWorldState;
    SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_ADD);

    // there are some events which required further DB script
    return eventHandled;
}
Ejemplo n.º 3
0
void OutdoorPvPEP::ProcessCaptureEvent(GameObject* pGo, uint32 uiTowerId, Team team, uint32 uiNewWorldState)
{
    if (team == ALLIANCE)
    {
        for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
            SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);

        ++m_uiTowersAlliance;
        BuffTeam(ALLIANCE, m_aPlaguelandsTowerBuffs[m_uiTowersAlliance - 1].uiSpellIdAlliance);
    }
    else if (team == HORDE)
    {
        for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
            SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);

        ++m_uiTowersHorde;
        BuffTeam(HORDE, m_aPlaguelandsTowerBuffs[m_uiTowersHorde - 1].uiSpellIdHorde);
    }
    else
    {
        for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
            SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);

        if (m_capturePointOwner[uiTowerId] == ALLIANCE)
        {
            if (--m_uiTowersAlliance == 0)
                BuffTeam(ALLIANCE, m_aPlaguelandsTowerBuffs[0].uiSpellIdAlliance, true);
        }
        else
        {
            if (--m_uiTowersHorde == 0)
                BuffTeam(HORDE, m_aPlaguelandsTowerBuffs[0].uiSpellIdHorde, true);
        }
    }

    // handle rewards of each tower
    if (team != TEAM_NONE)
    {
        // update capture point owner
        m_capturePointOwner[uiTowerId] = team;

        switch (uiTowerId)
        {
            case TOWER_ID_NORTHPASS:
                UpdateShrine(pGo);
                break;
            case TOWER_ID_CROWNGUARD:
                SetGraveyard();
                break;
            case TOWER_ID_EASTWALL:
                if (m_capturePointOwner[TOWER_ID_NORTHPASS] != team)
                    SummonSoldiers(pGo);
                break;
            case TOWER_ID_PLAGUEWOOD:
                SummonFlightMaster(pGo);
                break;
        }
    }
    else
    {
        switch (uiTowerId)
        {
            case TOWER_ID_NORTHPASS:
                UpdateShrine(pGo, true);
                break;
            case TOWER_ID_CROWNGUARD:
                SetGraveyard(true);
                break;
            case TOWER_ID_EASTWALL:
                UnsummonSoldiers(pGo);
                break;
            case TOWER_ID_PLAGUEWOOD:
                UnsummonFlightMaster(pGo);
                break;
        }

        // update capture point owner
        m_capturePointOwner[uiTowerId] = team;
    }

    // update tower state
    SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_REMOVE);
    m_uiTowerWorldState[uiTowerId] = uiNewWorldState;
    SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_ADD);

    // update counter state
    UpdateWorldState();
}