root/trunk/src/game/OutdoorPvPHP.cpp @ 240

Revision 111, 14.5 kB (checked in by yumileroy, 17 years ago)

[svn] * Fixed xp calculation for low level characters when grouped with a higher level player. Patch provided by Reiner030.
* Fixed positive spells being not resistable when cast on hostile units. Patch provided by QAston.
* Fixed compile warnings in gcc. Patch provided by WarHead?.

Original author: w12x
Date: 2008-10-26 11:50:07-05:00
Line 
1/*
2 * Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19#include "OutdoorPvPHP.h"
20#include "OutdoorPvP.h"
21#include "OutdoorPvPMgr.h"
22#include "Player.h"
23#include "WorldPacket.h"
24#include "World.h"
25#include "ObjectMgr.h"
26#include "Language.h"
27
28const uint32 HP_LANG_LOOSE_A[HP_TOWER_NUM] = {LANG_OPVP_HP_LOOSE_BROKENHILL_A,LANG_OPVP_HP_LOOSE_OVERLOOK_A,LANG_OPVP_HP_LOOSE_STADIUM_A};
29
30const uint32 HP_LANG_LOOSE_H[HP_TOWER_NUM] = {LANG_OPVP_HP_LOOSE_BROKENHILL_H,LANG_OPVP_HP_LOOSE_OVERLOOK_H,LANG_OPVP_HP_LOOSE_STADIUM_H};
31
32const uint32 HP_LANG_CAPTURE_A[HP_TOWER_NUM] = {LANG_OPVP_HP_CAPTURE_BROKENHILL_A,LANG_OPVP_HP_CAPTURE_OVERLOOK_A,LANG_OPVP_HP_CAPTURE_STADIUM_A};
33
34const uint32 HP_LANG_CAPTURE_H[HP_TOWER_NUM] = {LANG_OPVP_HP_CAPTURE_BROKENHILL_H,LANG_OPVP_HP_CAPTURE_OVERLOOK_H,LANG_OPVP_HP_CAPTURE_STADIUM_H};
35
36OutdoorPvPObjectiveHP::OutdoorPvPObjectiveHP(OutdoorPvP *pvp,OutdoorPvPHPTowerType type)
37: OutdoorPvPObjective(pvp), m_TowerType(type)
38{
39    AddCapturePoint(HPCapturePoints[type].entry,
40        HPCapturePoints[type].map,
41        HPCapturePoints[type].x,
42        HPCapturePoints[type].y,
43        HPCapturePoints[type].z,
44        HPCapturePoints[type].o,
45        HPCapturePoints[type].rot0,
46        HPCapturePoints[type].rot1,
47        HPCapturePoints[type].rot2,
48        HPCapturePoints[type].rot3);
49    AddObject(type,
50        HPTowerFlags[type].entry,
51        HPTowerFlags[type].map,
52        HPTowerFlags[type].x,
53        HPTowerFlags[type].y,
54        HPTowerFlags[type].z,
55        HPTowerFlags[type].o,
56        HPTowerFlags[type].rot0,
57        HPTowerFlags[type].rot1,
58        HPTowerFlags[type].rot2,
59        HPTowerFlags[type].rot3);
60}
61
62OutdoorPvPHP::OutdoorPvPHP()
63{
64    m_TypeId = OUTDOOR_PVP_HP;
65}
66
67bool OutdoorPvPHP::SetupOutdoorPvP()
68{
69    m_AllianceTowersControlled = 0;
70    m_HordeTowersControlled = 0;
71    // add the zones affected by the pvp buff
72    for(int i = 0; i < OutdoorPvPHPBuffZonesNum; ++i)
73        sOutdoorPvPMgr.AddZone(OutdoorPvPHPBuffZones[i],this);
74
75    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveHP(this,HP_TOWER_BROKEN_HILL));
76
77    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveHP(this,HP_TOWER_OVERLOOK));
78
79    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveHP(this,HP_TOWER_STADIUM));
80
81    return true;
82}
83
84void OutdoorPvPHP::HandlePlayerEnterZone(Player * plr, uint32 zone)
85{
86    // add buffs
87    if(plr->GetTeam() == ALLIANCE)
88    {
89        if(m_AllianceTowersControlled >=3)
90            plr->CastSpell(plr,AllianceBuff,true);
91    }
92    else
93    {
94        if(m_HordeTowersControlled >=3)
95            plr->CastSpell(plr,HordeBuff,true);
96    }
97    OutdoorPvP::HandlePlayerEnterZone(plr,zone);
98}
99
100void OutdoorPvPHP::HandlePlayerLeaveZone(Player * plr, uint32 zone)
101{
102    // remove buffs
103    if(plr->GetTeam() == ALLIANCE)
104    {
105        plr->RemoveAurasDueToSpell(AllianceBuff);
106    }
107    else
108    {
109        plr->RemoveAurasDueToSpell(HordeBuff);
110    }
111    OutdoorPvP::HandlePlayerLeaveZone(plr, zone);
112}
113
114bool OutdoorPvPHP::Update(uint32 diff)
115{
116    bool changed = false;
117    if(changed = OutdoorPvP::Update(diff))
118    {
119        if(m_AllianceTowersControlled == 3)
120            BuffTeam(ALLIANCE);
121        else if(m_HordeTowersControlled == 3)
122            BuffTeam(HORDE);
123        else
124            BuffTeam(0);
125        SendUpdateWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
126        SendUpdateWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
127    }
128    return changed;
129}
130
131void OutdoorPvPHP::SendRemoveWorldStates(Player *plr)
132{
133    plr->SendUpdateWorldState(HP_UI_TOWER_DISPLAY_A,0);
134    plr->SendUpdateWorldState(HP_UI_TOWER_DISPLAY_H,0);
135    plr->SendUpdateWorldState(HP_UI_TOWER_COUNT_H,0);
136    plr->SendUpdateWorldState(HP_UI_TOWER_COUNT_A,0);
137    plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N,0);
138    plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS,0);
139    plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY,0);
140    for(int i = 0; i < HP_TOWER_NUM; ++i)
141    {
142        plr->SendUpdateWorldState(HP_MAP_N[i],0);
143        plr->SendUpdateWorldState(HP_MAP_A[i],0);
144        plr->SendUpdateWorldState(HP_MAP_H[i],0);
145    }
146}
147
148void OutdoorPvPHP::FillInitialWorldStates(WorldPacket &data)
149{
150    data << uint32(HP_UI_TOWER_DISPLAY_A) << uint32(1);
151    data << uint32(HP_UI_TOWER_DISPLAY_H) << uint32(1);
152    data << uint32(HP_UI_TOWER_COUNT_A) << uint32(m_AllianceTowersControlled);
153    data << uint32(HP_UI_TOWER_COUNT_H) << uint32(m_HordeTowersControlled);
154    data << uint32(HP_UI_TOWER_SLIDER_DISPLAY) << uint32(0);
155    data << uint32(HP_UI_TOWER_SLIDER_POS) << uint32(50);
156    data << uint32(HP_UI_TOWER_SLIDER_N) << uint32(100);
157    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
158    {
159        (*itr)->FillInitialWorldStates(data);
160    }
161}
162
163bool OutdoorPvPObjectiveHP::Update(uint32 diff)
164{
165    // if status changed:
166    if(OutdoorPvPObjective::Update(diff))
167    {
168        if(m_OldState != m_State)
169        {
170            uint32 field = 0;
171            switch(m_OldState)
172            {
173            case OBJECTIVESTATE_NEUTRAL:
174                field = HP_MAP_N[m_TowerType];
175                break;
176            case OBJECTIVESTATE_ALLIANCE:
177                field = HP_MAP_A[m_TowerType];
178                if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled)
179                    ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled--;
180                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_A[m_TowerType]));
181                break;
182            case OBJECTIVESTATE_HORDE:
183                field = HP_MAP_H[m_TowerType];
184                if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled)
185                    ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled--;
186                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_H[m_TowerType]));
187                break;
188            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
189                field = HP_MAP_N[m_TowerType];
190                break;
191            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
192                field = HP_MAP_N[m_TowerType];
193                break;
194            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
195                field = HP_MAP_A[m_TowerType];
196                break;
197            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
198                field = HP_MAP_H[m_TowerType];
199                break;
200            }
201
202            // send world state update
203            if(field)
204            {
205                m_PvP->SendUpdateWorldState(field, 0);
206                field = 0;
207            }
208            uint32 artkit = 21;
209            uint32 artkit2 = HP_TowerArtKit_N[m_TowerType];
210            switch(m_State)
211            {
212            case OBJECTIVESTATE_NEUTRAL:
213                field = HP_MAP_N[m_TowerType];
214                break;
215            case OBJECTIVESTATE_ALLIANCE:
216                field = HP_MAP_A[m_TowerType];
217                artkit = 2;
218                artkit2 = HP_TowerArtKit_A[m_TowerType];
219                if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled<3)
220                    ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled++;
221                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_A[m_TowerType]));
222                break;
223            case OBJECTIVESTATE_HORDE:
224                field = HP_MAP_H[m_TowerType];
225                artkit = 1;
226                artkit2 = HP_TowerArtKit_H[m_TowerType];
227                if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled<3)
228                    ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled++;
229                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_H[m_TowerType]));
230                break;
231            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
232                field = HP_MAP_N[m_TowerType];
233                break;
234            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
235                field = HP_MAP_N[m_TowerType];
236                break;
237            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
238                field = HP_MAP_A[m_TowerType];
239                artkit = 2;
240                artkit2 = HP_TowerArtKit_A[m_TowerType];
241                break;
242            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
243                field = HP_MAP_H[m_TowerType];
244                artkit = 1;
245                artkit2 = HP_TowerArtKit_H[m_TowerType];
246                break;
247            }
248
249            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
250            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[m_TowerType]);
251            if(flag)
252            {
253                flag->SetGoArtKit(artkit);
254                flag->SendUpdateObjectToAllExcept(NULL);
255            }
256            if(flag2)
257            {
258                flag2->SetGoArtKit(artkit2);
259                flag2->SendUpdateObjectToAllExcept(NULL);
260            }
261
262            // send world state update
263            if(field)
264                m_PvP->SendUpdateWorldState(field, 1);
265
266            // complete quest objective
267            if(m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
268                SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], 0);
269        }
270
271        if(m_ShiftPhase != m_OldPhase)
272        {
273            SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_NeutralValue);
274            // send these updates to only the ones in this objective
275            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
276            SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
277            // send this too, sometimes the slider disappears, dunno why :(
278            SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
279        }
280        return true;
281    }
282    return false;
283}
284
285void OutdoorPvPObjectiveHP::FillInitialWorldStates(WorldPacket &data)
286{
287    switch(m_State)
288    {
289        case OBJECTIVESTATE_ALLIANCE:
290        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
291            data << uint32(HP_MAP_N[m_TowerType]) << uint32(0);
292            data << uint32(HP_MAP_A[m_TowerType]) << uint32(1);
293            data << uint32(HP_MAP_H[m_TowerType]) << uint32(0);
294            break;
295        case OBJECTIVESTATE_HORDE:
296        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
297            data << uint32(HP_MAP_N[m_TowerType]) << uint32(0);
298            data << uint32(HP_MAP_A[m_TowerType]) << uint32(0);
299            data << uint32(HP_MAP_H[m_TowerType]) << uint32(1);
300            break;
301        case OBJECTIVESTATE_NEUTRAL:
302        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
303        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
304        default:
305            data << uint32(HP_MAP_N[m_TowerType]) << uint32(1);
306            data << uint32(HP_MAP_A[m_TowerType]) << uint32(0);
307            data << uint32(HP_MAP_H[m_TowerType]) << uint32(0);
308            break;
309    }
310}
311
312bool OutdoorPvPObjectiveHP::HandlePlayerEnter(Player *plr)
313{
314    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
315    {
316        plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
317        uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
318        plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
319        plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_NeutralValue);
320        return true;
321    }
322    return false;
323}
324
325void OutdoorPvPObjectiveHP::HandlePlayerLeave(Player *plr)
326{
327    plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 0);
328    OutdoorPvPObjective::HandlePlayerLeave(plr);
329}
330
331void OutdoorPvPHP::BuffTeam(uint32 team)
332{
333    if(team == ALLIANCE)
334    {
335        for(std::set<uint64>::iterator itr = m_PlayerGuids[0].begin(); itr != m_PlayerGuids[0].end(); ++itr)
336        {
337            if(Player * plr = objmgr.GetPlayer(*itr))
338                if(plr->IsInWorld()) plr->CastSpell(plr,AllianceBuff,true);
339        }
340        for(std::set<uint64>::iterator itr = m_PlayerGuids[1].begin(); itr != m_PlayerGuids[1].end(); ++itr)
341        {
342            if(Player * plr = objmgr.GetPlayer(*itr))
343                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(HordeBuff);
344        }
345    }
346    else if(team == HORDE)
347    {
348        for(std::set<uint64>::iterator itr = m_PlayerGuids[1].begin(); itr != m_PlayerGuids[1].end(); ++itr)
349        {
350            if(Player * plr = objmgr.GetPlayer(*itr))
351                if(plr->IsInWorld()) plr->CastSpell(plr,HordeBuff,true);
352        }
353        for(std::set<uint64>::iterator itr = m_PlayerGuids[0].begin(); itr != m_PlayerGuids[0].end(); ++itr)
354        {
355            if(Player * plr = objmgr.GetPlayer(*itr))
356                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(AllianceBuff);
357        }
358    }
359    else
360    {
361        for(std::set<uint64>::iterator itr = m_PlayerGuids[0].begin(); itr != m_PlayerGuids[0].end(); ++itr)
362        {
363            if(Player * plr = objmgr.GetPlayer(*itr))
364                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(AllianceBuff);
365        }
366        for(std::set<uint64>::iterator itr = m_PlayerGuids[1].begin(); itr != m_PlayerGuids[1].end(); ++itr)
367        {
368            if(Player * plr = objmgr.GetPlayer(*itr))
369                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(HordeBuff);
370        }
371    }
372}
373
374void OutdoorPvPHP::HandleKillImpl(Player *plr, Unit * killed)
375{
376    if(killed->GetTypeId() != TYPEID_PLAYER)
377        return;
378
379    if(plr->GetTeam() == ALLIANCE && ((Player*)killed)->GetTeam() != ALLIANCE)
380        plr->CastSpell(plr,AlliancePlayerKillReward,true);
381    else if(plr->GetTeam() == HORDE && ((Player*)killed)->GetTeam() != HORDE)
382        plr->CastSpell(plr,HordePlayerKillReward,true);
383}
384
385bool OutdoorPvPObjectiveHP::HandleCapturePointEvent(Player *plr, uint32 eventId)
386{
387    if(eventId == HP_CapturePointEvent_Enter[m_TowerType])
388    {
389        this->HandlePlayerEnter(plr);
390        return true;
391    }
392    else if(eventId == HP_CapturePointEvent_Leave[m_TowerType])
393    {
394        this->HandlePlayerLeave(plr);
395        return true;
396    }
397    return false;
398}
Note: See TracBrowser for help on using the browser.