root/trunk/src/game/OutdoorPvPEP.cpp @ 94

Revision 80, 35.8 kB (checked in by yumileroy, 17 years ago)

[svn] Fixed a crash in OutdoorPvP*::BuffTeam?().

Original author: w12x
Date: 2008-10-20 13:34:00-05:00
Line 
1#include "OutdoorPvPEP.h"
2#include "WorldPacket.h"
3#include "Player.h"
4#include "GameObject.h"
5#include "ObjectMgr.h"
6#include "ObjectAccessor.h"
7#include "OutdoorPvPMgr.h"
8#include "Creature.h"
9#include "Language.h"
10#include "World.h"
11#include "GossipDef.h"
12
13OutdoorPvPObjectiveEP_EWT::OutdoorPvPObjectiveEP_EWT(OutdoorPvP *pvp)
14: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_UnitsSummonedSide(0)
15{
16    AddCapturePoint(EPCapturePoints[EP_EWT].entry,EPCapturePoints[EP_EWT].map,EPCapturePoints[EP_EWT].x,EPCapturePoints[EP_EWT].y,EPCapturePoints[EP_EWT].z,EPCapturePoints[EP_EWT].o,EPCapturePoints[EP_EWT].rot0,EPCapturePoints[EP_EWT].rot1,EPCapturePoints[EP_EWT].rot2,EPCapturePoints[EP_EWT].rot3);
17    AddObject(EP_EWT_FLAGS,EPTowerFlags[EP_EWT].entry,EPTowerFlags[EP_EWT].map,EPTowerFlags[EP_EWT].x,EPTowerFlags[EP_EWT].y,EPTowerFlags[EP_EWT].z,EPTowerFlags[EP_EWT].o,EPTowerFlags[EP_EWT].rot0,EPTowerFlags[EP_EWT].rot1,EPTowerFlags[EP_EWT].rot2,EPTowerFlags[EP_EWT].rot3);
18}
19
20bool OutdoorPvPObjectiveEP_EWT::Update(uint32 diff)
21{
22    if(OutdoorPvPObjective::Update(diff))
23    {
24        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
25        {
26            // if changing from controlling alliance to horde or vice versa
27            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
28            {
29                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_A));
30                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
31            }
32            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
33            {
34                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_H));
35                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
36            }
37
38            uint32 artkit = 21;
39
40            switch(m_State)
41            {
42            case OBJECTIVESTATE_ALLIANCE:
43                if(m_ShiftPhase == m_ShiftMaxPhase)
44                    m_TowerState = EP_TS_A;
45                else
46                    m_TowerState = EP_TS_A_P;
47                artkit = 2;
48                SummonSupportUnitAtNorthpassTower(ALLIANCE);
49                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = ALLIANCE;
50                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
51                break;
52            case OBJECTIVESTATE_HORDE:
53                if(m_ShiftPhase == -m_ShiftMaxPhase)
54                    m_TowerState = EP_TS_H;
55                else
56                    m_TowerState = EP_TS_H_P;
57                artkit = 1;
58                SummonSupportUnitAtNorthpassTower(HORDE);
59                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = HORDE;
60                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
61                break;
62            case OBJECTIVESTATE_NEUTRAL:
63                m_TowerState = EP_TS_N;
64                break;
65            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
66            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
67                m_TowerState = EP_TS_N_A;
68                break;
69            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
70            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
71                m_TowerState = EP_TS_N_H;
72                break;
73            }
74
75            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
76            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_EWT_FLAGS]);
77            if(flag)
78            {
79                flag->SetGoArtKit(artkit);
80                flag->SendUpdateObjectToAllExcept(NULL);
81            }
82            if(flag2)
83            {
84                flag2->SetGoArtKit(artkit);
85                flag2->SendUpdateObjectToAllExcept(NULL);
86            }
87
88
89            UpdateTowerState();
90
91            // complete quest objective
92            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
93                SendObjectiveComplete(EP_EWT_CM, 0);
94        }
95
96        if(m_ShiftPhase != m_OldPhase)
97        {
98            // send this too, sometimes the slider disappears, dunno why :(
99            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
100            // send these updates to only the ones in this objective
101            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
102            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
103            // send this too, sometimes it resets :S
104            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
105        }
106        return true;
107    }
108    return false;
109}
110
111void OutdoorPvPObjectiveEP_EWT::FillInitialWorldStates(WorldPacket &data)
112{
113    data << EP_EWT_A << uint32(bool(m_TowerState & EP_TS_A));
114    data << EP_EWT_H << uint32(bool(m_TowerState & EP_TS_H));
115    data << EP_EWT_A_P << uint32(bool(m_TowerState & EP_TS_A_P));
116    data << EP_EWT_H_P << uint32(bool(m_TowerState & EP_TS_H_P));
117    data << EP_EWT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
118    data << EP_EWT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
119    data << EP_EWT_N << uint32(bool(m_TowerState & EP_TS_N));
120}
121
122void OutdoorPvPObjectiveEP_EWT::UpdateTowerState()
123{
124    m_PvP->SendUpdateWorldState(EP_EWT_A , bool(m_TowerState & EP_TS_A));
125    m_PvP->SendUpdateWorldState(EP_EWT_H , bool(m_TowerState & EP_TS_H));
126    m_PvP->SendUpdateWorldState(EP_EWT_A_P , bool(m_TowerState & EP_TS_A_P));
127    m_PvP->SendUpdateWorldState(EP_EWT_H_P , bool(m_TowerState & EP_TS_H_P));
128    m_PvP->SendUpdateWorldState(EP_EWT_N_A , bool(m_TowerState & EP_TS_N_A));
129    m_PvP->SendUpdateWorldState(EP_EWT_N_H , bool(m_TowerState & EP_TS_N_H));
130    m_PvP->SendUpdateWorldState(EP_EWT_N , bool(m_TowerState & EP_TS_N));
131}
132
133bool OutdoorPvPObjectiveEP_EWT::HandlePlayerEnter(Player *plr)
134{
135    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
136    {
137        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
138        uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
139        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
140        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
141        return true;
142    }
143    return false;
144}
145
146void OutdoorPvPObjectiveEP_EWT::HandlePlayerLeave(Player *plr)
147{
148    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
149    OutdoorPvPObjective::HandlePlayerLeave(plr);
150}
151
152bool OutdoorPvPObjectiveEP_EWT::HandleCapturePointEvent(Player *plr, uint32 eventId)
153{
154    if(eventId == EPTowerPlayerEnterEvents[EP_EWT])
155    {
156        this->HandlePlayerEnter(plr);
157        return true;
158    }
159    else if (eventId == EPTowerPlayerLeaveEvents[EP_EWT])
160    {
161        this->HandlePlayerLeave(plr);
162        return true;
163    }
164    return false;
165}
166
167void OutdoorPvPObjectiveEP_EWT::SummonSupportUnitAtNorthpassTower(uint32 team)
168{
169    if(m_UnitsSummonedSide != team)
170    {
171        m_UnitsSummonedSide = team;
172        const creature_type * ct = NULL;
173        if(team == ALLIANCE)
174            ct=EP_EWT_Summons_A;
175        else
176            ct=EP_EWT_Summons_H;
177
178        for(int i = 0; i < EP_EWT_NUM_CREATURES; ++i)
179        {
180            DelCreature(i);
181            AddCreature(i,ct[i].entry,ct[i].teamval,ct[i].map,ct[i].x,ct[i].y,ct[i].z,ct[i].o,1000000);
182        }
183    }
184}
185
186// NPT
187OutdoorPvPObjectiveEP_NPT::OutdoorPvPObjectiveEP_NPT(OutdoorPvP *pvp)
188: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_SummonedGOSide(0)
189{
190    AddCapturePoint(EPCapturePoints[EP_NPT].entry,EPCapturePoints[EP_NPT].map,EPCapturePoints[EP_NPT].x,EPCapturePoints[EP_NPT].y,EPCapturePoints[EP_NPT].z,EPCapturePoints[EP_NPT].o,EPCapturePoints[EP_NPT].rot0,EPCapturePoints[EP_NPT].rot1,EPCapturePoints[EP_NPT].rot2,EPCapturePoints[EP_NPT].rot3);
191    AddObject(EP_NPT_FLAGS,EPTowerFlags[EP_NPT].entry,EPTowerFlags[EP_NPT].map,EPTowerFlags[EP_NPT].x,EPTowerFlags[EP_NPT].y,EPTowerFlags[EP_NPT].z,EPTowerFlags[EP_NPT].o,EPTowerFlags[EP_NPT].rot0,EPTowerFlags[EP_NPT].rot1,EPTowerFlags[EP_NPT].rot2,EPTowerFlags[EP_NPT].rot3);
192}
193
194bool OutdoorPvPObjectiveEP_NPT::Update(uint32 diff)
195{
196    if(OutdoorPvPObjective::Update(diff))
197    {
198        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
199        {
200            // if changing from controlling alliance to horde or vice versa
201            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
202            {
203                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_A));
204                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
205            }
206            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
207            {
208                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_H));
209                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
210            }
211
212            uint32 artkit = 21;
213
214            switch(m_State)
215            {
216            case OBJECTIVESTATE_ALLIANCE:
217                if(m_ShiftPhase == m_ShiftMaxPhase)
218                    m_TowerState = EP_TS_A;
219                else
220                    m_TowerState = EP_TS_A_P;
221                artkit = 2;
222                SummonGO(ALLIANCE);
223                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = ALLIANCE;
224                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
225                break;
226            case OBJECTIVESTATE_HORDE:
227                if(m_ShiftPhase == -m_ShiftMaxPhase)
228                    m_TowerState = EP_TS_H;
229                else
230                    m_TowerState = EP_TS_H_P;
231                artkit = 1;
232                SummonGO(HORDE);
233                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = HORDE;
234                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
235                break;
236            case OBJECTIVESTATE_NEUTRAL:
237                m_TowerState = EP_TS_N;
238                m_SummonedGOSide = 0;
239                DelObject(EP_NPT_BUFF);
240                break;
241            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
242            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
243                m_TowerState = EP_TS_N_A;
244                break;
245            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
246            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
247                m_TowerState = EP_TS_N_H;
248                break;
249            }
250
251            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
252            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_NPT_FLAGS]);
253            if(flag)
254            {
255                flag->SetGoArtKit(artkit);
256                flag->SendUpdateObjectToAllExcept(NULL);
257            }
258            if(flag2)
259            {
260                flag2->SetGoArtKit(artkit);
261                flag2->SendUpdateObjectToAllExcept(NULL);
262            }
263
264            UpdateTowerState();
265
266            // complete quest objective
267            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
268                SendObjectiveComplete(EP_NPT_CM, 0);
269        }
270
271        if(m_ShiftPhase != m_OldPhase)
272        {
273            // send this too, sometimes the slider disappears, dunno why :(
274            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
275            // send these updates to only the ones in this objective
276            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
277            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
278            // send this too, sometimes it resets :S
279            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
280        }
281        return true;
282    }
283    return false;
284}
285
286void OutdoorPvPObjectiveEP_NPT::FillInitialWorldStates(WorldPacket &data)
287{
288    data << EP_NPT_A << uint32(bool(m_TowerState & EP_TS_A));
289    data << EP_NPT_H << uint32(bool(m_TowerState & EP_TS_H));
290    data << EP_NPT_A_P << uint32(bool(m_TowerState & EP_TS_A_P));
291    data << EP_NPT_H_P << uint32(bool(m_TowerState & EP_TS_H_P));
292    data << EP_NPT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
293    data << EP_NPT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
294    data << EP_NPT_N << uint32(bool(m_TowerState & EP_TS_N));
295}
296
297void OutdoorPvPObjectiveEP_NPT::UpdateTowerState()
298{
299    m_PvP->SendUpdateWorldState(EP_NPT_A , bool(m_TowerState & EP_TS_A));
300    m_PvP->SendUpdateWorldState(EP_NPT_H , bool(m_TowerState & EP_TS_H));
301    m_PvP->SendUpdateWorldState(EP_NPT_A_P , bool(m_TowerState & EP_TS_A_P));
302    m_PvP->SendUpdateWorldState(EP_NPT_H_P , bool(m_TowerState & EP_TS_H_P));
303    m_PvP->SendUpdateWorldState(EP_NPT_N_A , bool(m_TowerState & EP_TS_N_A));
304    m_PvP->SendUpdateWorldState(EP_NPT_N_H , bool(m_TowerState & EP_TS_N_H));
305    m_PvP->SendUpdateWorldState(EP_NPT_N , bool(m_TowerState & EP_TS_N));
306}
307
308bool OutdoorPvPObjectiveEP_NPT::HandlePlayerEnter(Player *plr)
309{
310    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
311    {
312        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
313        uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
314        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
315        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
316        return true;
317    }
318    return false;
319}
320
321void OutdoorPvPObjectiveEP_NPT::HandlePlayerLeave(Player *plr)
322{
323    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
324    OutdoorPvPObjective::HandlePlayerLeave(plr);
325}
326
327bool OutdoorPvPObjectiveEP_NPT::HandleCapturePointEvent(Player *plr, uint32 eventId)
328{
329    if(eventId == EPTowerPlayerEnterEvents[EP_NPT])
330    {
331        this->HandlePlayerEnter(plr);
332        return true;
333    }
334    else if (eventId == EPTowerPlayerLeaveEvents[EP_NPT])
335    {
336        this->HandlePlayerLeave(plr);
337        return true;
338    }
339    return false;
340}
341
342void OutdoorPvPObjectiveEP_NPT::SummonGO(uint32 team)
343{
344    if(m_SummonedGOSide != team)
345    {
346        m_SummonedGOSide = team;
347        DelObject(EP_NPT_BUFF);
348        AddObject(EP_NPT_BUFF,EP_NPT_LordaeronShrine.entry,EP_NPT_LordaeronShrine.map,EP_NPT_LordaeronShrine.x,EP_NPT_LordaeronShrine.y,EP_NPT_LordaeronShrine.z,EP_NPT_LordaeronShrine.o,EP_NPT_LordaeronShrine.rot0,EP_NPT_LordaeronShrine.rot1,EP_NPT_LordaeronShrine.rot2,EP_NPT_LordaeronShrine.rot3);
349        GameObject * go = HashMapHolder<GameObject>::Find(m_Objects[EP_NPT_BUFF]);
350        if(go)
351            go->SetUInt32Value(GAMEOBJECT_FACTION,(team == ALLIANCE ? 84 : 83));
352    }
353}
354
355// CGT
356OutdoorPvPObjectiveEP_CGT::OutdoorPvPObjectiveEP_CGT(OutdoorPvP *pvp)
357: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_GraveyardSide(0)
358{
359    AddCapturePoint(EPCapturePoints[EP_CGT].entry,EPCapturePoints[EP_CGT].map,EPCapturePoints[EP_CGT].x,EPCapturePoints[EP_CGT].y,EPCapturePoints[EP_CGT].z,EPCapturePoints[EP_CGT].o,EPCapturePoints[EP_CGT].rot0,EPCapturePoints[EP_CGT].rot1,EPCapturePoints[EP_CGT].rot2,EPCapturePoints[EP_CGT].rot3);
360    AddObject(EP_CGT_FLAGS,EPTowerFlags[EP_CGT].entry,EPTowerFlags[EP_CGT].map,EPTowerFlags[EP_CGT].x,EPTowerFlags[EP_CGT].y,EPTowerFlags[EP_CGT].z,EPTowerFlags[EP_CGT].o,EPTowerFlags[EP_CGT].rot0,EPTowerFlags[EP_CGT].rot1,EPTowerFlags[EP_CGT].rot2,EPTowerFlags[EP_CGT].rot3);
361}
362
363bool OutdoorPvPObjectiveEP_CGT::Update(uint32 diff)
364{
365    if(OutdoorPvPObjective::Update(diff))
366    {
367        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
368        {
369            // if changing from controlling alliance to horde or vice versa
370            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
371            {
372                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_A));
373                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
374            }
375            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
376            {
377                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_H));
378                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
379            }
380
381            uint32 artkit = 21;
382
383            switch(m_State)
384            {
385            case OBJECTIVESTATE_ALLIANCE:
386                if(m_ShiftPhase == m_ShiftMaxPhase)
387                    m_TowerState = EP_TS_A;
388                else
389                    m_TowerState = EP_TS_A_P;
390                artkit = 2;
391                LinkGraveYard(ALLIANCE);
392                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = ALLIANCE;
393                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
394                break;
395            case OBJECTIVESTATE_HORDE:
396                if(m_ShiftPhase == -m_ShiftMaxPhase)
397                    m_TowerState = EP_TS_H;
398                else
399                    m_TowerState = EP_TS_H_P;
400                artkit = 1;
401                LinkGraveYard(HORDE);
402                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = HORDE;
403                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
404                break;
405            case OBJECTIVESTATE_NEUTRAL:
406                m_TowerState = EP_TS_N;
407                break;
408            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
409            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
410                m_TowerState = EP_TS_N_A;
411                break;
412            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
413            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
414                m_TowerState = EP_TS_N_H;
415                break;
416            }
417
418            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
419            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_CGT_FLAGS]);
420            if(flag)
421            {
422                flag->SetGoArtKit(artkit);
423                flag->SendUpdateObjectToAllExcept(NULL);
424            }
425            if(flag2)
426            {
427                flag2->SetGoArtKit(artkit);
428                flag2->SendUpdateObjectToAllExcept(NULL);
429            }
430
431            UpdateTowerState();
432
433            // complete quest objective
434            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
435                SendObjectiveComplete(EP_CGT_CM, 0);
436        }
437
438        if(m_ShiftPhase != m_OldPhase)
439        {
440            // send this too, sometimes the slider disappears, dunno why :(
441            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
442            // send these updates to only the ones in this objective
443            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
444            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
445            // send this too, sometimes it resets :S
446            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
447        }
448        return true;
449    }
450    return false;
451}
452
453void OutdoorPvPObjectiveEP_CGT::FillInitialWorldStates(WorldPacket &data)
454{
455    data << EP_CGT_A << uint32(bool(m_TowerState & EP_TS_A));
456    data << EP_CGT_H << uint32(bool(m_TowerState & EP_TS_H));
457    data << EP_CGT_A_P << uint32(bool(m_TowerState & EP_TS_A_P));
458    data << EP_CGT_H_P << uint32(bool(m_TowerState & EP_TS_H_P));
459    data << EP_CGT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
460    data << EP_CGT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
461    data << EP_CGT_N << uint32(bool(m_TowerState & EP_TS_N));
462}
463
464void OutdoorPvPObjectiveEP_CGT::UpdateTowerState()
465{
466    m_PvP->SendUpdateWorldState(EP_CGT_A , bool(m_TowerState & EP_TS_A));
467    m_PvP->SendUpdateWorldState(EP_CGT_H , bool(m_TowerState & EP_TS_H));
468    m_PvP->SendUpdateWorldState(EP_CGT_A_P , bool(m_TowerState & EP_TS_A_P));
469    m_PvP->SendUpdateWorldState(EP_CGT_H_P , bool(m_TowerState & EP_TS_H_P));
470    m_PvP->SendUpdateWorldState(EP_CGT_N_A , bool(m_TowerState & EP_TS_N_A));
471    m_PvP->SendUpdateWorldState(EP_CGT_N_H , bool(m_TowerState & EP_TS_N_H));
472    m_PvP->SendUpdateWorldState(EP_CGT_N , bool(m_TowerState & EP_TS_N));
473}
474
475bool OutdoorPvPObjectiveEP_CGT::HandlePlayerEnter(Player *plr)
476{
477    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
478    {
479        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
480        uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
481        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
482        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
483        return true;
484    }
485    return false;
486}
487
488void OutdoorPvPObjectiveEP_CGT::HandlePlayerLeave(Player *plr)
489{
490    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
491    OutdoorPvPObjective::HandlePlayerLeave(plr);
492}
493
494bool OutdoorPvPObjectiveEP_CGT::HandleCapturePointEvent(Player *plr, uint32 eventId)
495{
496    if(eventId == EPTowerPlayerEnterEvents[EP_CGT])
497    {
498        this->HandlePlayerEnter(plr);
499        return true;
500    }
501    else if (eventId == EPTowerPlayerLeaveEvents[EP_CGT])
502    {
503        this->HandlePlayerLeave(plr);
504        return true;
505    }
506    return false;
507}
508
509void OutdoorPvPObjectiveEP_CGT::LinkGraveYard(uint32 team)
510{
511    if(m_GraveyardSide != team)
512    {
513        m_GraveyardSide = team;
514        objmgr.RemoveGraveYardLink(EP_GraveYardId,EP_GraveYardZone,team,false);
515        objmgr.AddGraveYardLink(EP_GraveYardId,EP_GraveYardZone,team,false);
516    }
517}
518
519// PWT
520OutdoorPvPObjectiveEP_PWT::OutdoorPvPObjectiveEP_PWT(OutdoorPvP *pvp)
521: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_FlightMasterSpawned(0)
522{
523    AddCapturePoint(EPCapturePoints[EP_PWT].entry,EPCapturePoints[EP_PWT].map,EPCapturePoints[EP_PWT].x,EPCapturePoints[EP_PWT].y,EPCapturePoints[EP_PWT].z,EPCapturePoints[EP_PWT].o,EPCapturePoints[EP_PWT].rot0,EPCapturePoints[EP_PWT].rot1,EPCapturePoints[EP_PWT].rot2,EPCapturePoints[EP_PWT].rot3);
524    AddObject(EP_PWT_FLAGS,EPTowerFlags[EP_PWT].entry,EPTowerFlags[EP_PWT].map,EPTowerFlags[EP_PWT].x,EPTowerFlags[EP_PWT].y,EPTowerFlags[EP_PWT].z,EPTowerFlags[EP_PWT].o,EPTowerFlags[EP_PWT].rot0,EPTowerFlags[EP_PWT].rot1,EPTowerFlags[EP_PWT].rot2,EPTowerFlags[EP_PWT].rot3);
525}
526
527bool OutdoorPvPObjectiveEP_PWT::Update(uint32 diff)
528{
529    if(OutdoorPvPObjective::Update(diff))
530    {
531        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
532        {
533            // if changing from controlling alliance to horde or vice versa
534            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
535            {
536                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_A));
537                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
538            }
539            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
540            {
541                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_H));
542                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
543            }
544
545            uint32 artkit = 21;
546
547            switch(m_State)
548            {
549            case OBJECTIVESTATE_ALLIANCE:
550                if(m_ShiftPhase == m_ShiftMaxPhase)
551                    m_TowerState = EP_TS_A;
552                else
553                    m_TowerState = EP_TS_A_P;
554                SummonFlightMaster(ALLIANCE);
555                artkit = 2;
556                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = ALLIANCE;
557                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
558                break;
559            case OBJECTIVESTATE_HORDE:
560                if(m_ShiftPhase == -m_ShiftMaxPhase)
561                    m_TowerState = EP_TS_H;
562                else
563                    m_TowerState = EP_TS_H_P;
564                SummonFlightMaster(HORDE);
565                artkit = 1;
566                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = HORDE;
567                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
568                break;
569            case OBJECTIVESTATE_NEUTRAL:
570                m_TowerState = EP_TS_N;
571                DelCreature(EP_PWT_FLIGHTMASTER);
572                m_FlightMasterSpawned = 0;
573                break;
574            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
575            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
576                m_TowerState = EP_TS_N_A;
577                break;
578            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
579            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
580                m_TowerState = EP_TS_N_H;
581                break;
582            }
583
584            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
585            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_PWT_FLAGS]);
586            if(flag)
587            {
588                flag->SetGoArtKit(artkit);
589                flag->SendUpdateObjectToAllExcept(NULL);
590            }
591            if(flag2)
592            {
593                flag2->SetGoArtKit(artkit);
594                flag2->SendUpdateObjectToAllExcept(NULL);
595            }
596
597            UpdateTowerState();
598
599            // complete quest objective
600            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
601                SendObjectiveComplete(EP_PWT_CM, 0);
602        }
603
604        if(m_ShiftPhase != m_OldPhase)
605        {
606            // send this too, sometimes the slider disappears, dunno why :(
607            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
608            // send these updates to only the ones in this objective
609            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
610            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
611            // send this too, sometimes it resets :S
612            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
613        }
614        return true;
615    }
616    return false;
617}
618
619void OutdoorPvPObjectiveEP_PWT::FillInitialWorldStates(WorldPacket &data)
620{
621    data << EP_PWT_A << uint32(bool(m_TowerState & EP_TS_A));
622    data << EP_PWT_H << uint32(bool(m_TowerState & EP_TS_H));
623    data << EP_PWT_A_P << uint32(bool(m_TowerState & EP_TS_A_P));
624    data << EP_PWT_H_P << uint32(bool(m_TowerState & EP_TS_H_P));
625    data << EP_PWT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
626    data << EP_PWT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
627    data << EP_PWT_N << uint32(bool(m_TowerState & EP_TS_N));
628}
629
630void OutdoorPvPObjectiveEP_PWT::UpdateTowerState()
631{
632    m_PvP->SendUpdateWorldState(EP_PWT_A , bool(m_TowerState & EP_TS_A));
633    m_PvP->SendUpdateWorldState(EP_PWT_H , bool(m_TowerState & EP_TS_H));
634    m_PvP->SendUpdateWorldState(EP_PWT_A_P , bool(m_TowerState & EP_TS_A_P));
635    m_PvP->SendUpdateWorldState(EP_PWT_H_P , bool(m_TowerState & EP_TS_H_P));
636    m_PvP->SendUpdateWorldState(EP_PWT_N_A , bool(m_TowerState & EP_TS_N_A));
637    m_PvP->SendUpdateWorldState(EP_PWT_N_H , bool(m_TowerState & EP_TS_N_H));
638    m_PvP->SendUpdateWorldState(EP_PWT_N , bool(m_TowerState & EP_TS_N));
639}
640
641bool OutdoorPvPObjectiveEP_PWT::HandlePlayerEnter(Player *plr)
642{
643    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
644    {
645        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
646        uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
647        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
648        plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
649        return true;
650    }
651    return false;
652}
653
654void OutdoorPvPObjectiveEP_PWT::HandlePlayerLeave(Player *plr)
655{
656    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
657    OutdoorPvPObjective::HandlePlayerLeave(plr);
658}
659
660bool OutdoorPvPObjectiveEP_PWT::HandleCapturePointEvent(Player *plr, uint32 eventId)
661{
662    if(eventId == EPTowerPlayerEnterEvents[EP_PWT])
663    {
664        this->HandlePlayerEnter(plr);
665        return true;
666    }
667    else if (eventId == EPTowerPlayerLeaveEvents[EP_PWT])
668    {
669        this->HandlePlayerLeave(plr);
670        return true;
671    }
672    return false;
673}
674
675void OutdoorPvPObjectiveEP_PWT::SummonFlightMaster(uint32 team)
676{
677    if(m_FlightMasterSpawned != team)
678    {
679        m_FlightMasterSpawned = team;
680        DelCreature(EP_PWT_FLIGHTMASTER);
681        AddCreature(EP_PWT_FLIGHTMASTER,EP_PWT_FlightMaster.entry,team,EP_PWT_FlightMaster.map,EP_PWT_FlightMaster.x,EP_PWT_FlightMaster.y,EP_PWT_FlightMaster.z,EP_PWT_FlightMaster.o);
682        Creature * c = HashMapHolder<Creature>::Find(m_Creatures[EP_PWT_FLIGHTMASTER]);
683        if(c)
684        {
685            GossipOption gso;
686            gso.Action = GOSSIP_OPTION_OUTDOORPVP;
687            gso.GossipId = 0;
688            gso.Option.assign(objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_FLIGHT_NPT));
689            gso.Id = 50;
690            gso.Icon = 0;
691            gso.NpcFlag = 0;
692            c->addGossipOption(gso);
693
694            gso.Action = GOSSIP_OPTION_OUTDOORPVP;
695            gso.GossipId = 0;
696            gso.Option.assign(objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_FLIGHT_EWT));
697            gso.Id = 50;
698            gso.Icon = 0;
699            gso.NpcFlag = 0;
700            c->addGossipOption(gso);
701
702            gso.Action = GOSSIP_OPTION_OUTDOORPVP;
703            gso.GossipId = 0;
704            gso.Option.assign(objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_FLIGHT_CGT));
705            gso.Id = 50;
706            gso.Icon = 0;
707            gso.NpcFlag = 0;
708            c->addGossipOption(gso);
709        }
710    }
711}
712
713bool OutdoorPvPObjectiveEP_PWT::CanTalkTo(Player * p, Creature * c, GossipOption &gso)
714{
715    if( p->GetTeam() == m_FlightMasterSpawned &&
716        c->GetGUID() == m_Creatures[EP_PWT_FLIGHTMASTER] &&
717        gso.Id == 50 )
718        return true;
719    return false;
720}
721
722bool OutdoorPvPObjectiveEP_PWT::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
723{
724    std::map<uint64,uint32>::iterator itr = m_CreatureTypes.find(guid);
725    if(itr != m_CreatureTypes.end())
726    {
727        Creature * cr = HashMapHolder<Creature>::Find(guid);
728        if(!cr)
729            return true;
730        if(itr->second == EP_PWT_FLIGHTMASTER)
731        {
732            uint32 src = EP_PWT_Taxi;
733            uint32 dst = 0;
734            switch(gossipid)
735            {
736            case 0:
737                dst = EP_NPT_Taxi;
738                break;
739            case 1:
740                dst = EP_EWT_Taxi;
741                break;
742            default:
743                dst = EP_CGT_Taxi;
744                break;
745            }
746
747            std::vector<uint32> nodes;
748            nodes.resize(2);
749            nodes[0] = src;
750            nodes[1] = dst;
751
752            plr->PlayerTalkClass->CloseGossip();
753            plr->ActivateTaxiPathTo(nodes, 0, cr);
754            // leave the opvp, seems like moveinlineofsight isn't called when entering a taxi
755            HandlePlayerLeave(plr);
756        }
757        return true;
758    }
759    return false;
760}
761
762// ep
763OutdoorPvPEP::OutdoorPvPEP()
764{
765    m_TypeId = OUTDOOR_PVP_EP;
766    memset(EP_Controls,0,sizeof(EP_Controls));
767    m_AllianceTowersControlled = 0;
768    m_HordeTowersControlled = 0;
769}
770
771bool OutdoorPvPEP::SetupOutdoorPvP()
772{
773    for(int i = 0; i < EPBuffZonesNum; ++i)
774        sOutdoorPvPMgr.AddZone(EPBuffZones[i],this);
775
776    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveEP_EWT(this));
777    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveEP_PWT(this));
778    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveEP_CGT(this));
779    m_OutdoorPvPObjectives.insert(new OutdoorPvPObjectiveEP_NPT(this));
780    return true;
781}
782
783bool OutdoorPvPEP::Update(uint32 diff)
784{
785    if(OutdoorPvP::Update(diff))
786    {
787        m_AllianceTowersControlled = 0;
788        m_HordeTowersControlled = 0;
789        for(int i = 0; i < EP_TOWER_NUM; ++i)
790        {
791            if(EP_Controls[i] == ALLIANCE)
792                ++m_AllianceTowersControlled;
793            else if(EP_Controls[i] == HORDE)
794                ++m_HordeTowersControlled;
795            SendUpdateWorldState(EP_UI_TOWER_COUNT_A,m_AllianceTowersControlled);
796            SendUpdateWorldState(EP_UI_TOWER_COUNT_H,m_HordeTowersControlled);
797            BuffTeams();
798        }
799        return true;
800    }
801    return false;
802}
803
804void OutdoorPvPEP::HandlePlayerEnterZone(Player * plr, uint32 zone)
805{
806    // add buffs
807    if(plr->GetTeam() == ALLIANCE)
808    {
809        if(m_AllianceTowersControlled && m_AllianceTowersControlled < 5)
810            plr->CastSpell(plr,EP_AllianceBuffs[m_AllianceTowersControlled-1],true);
811    }
812    else
813    {
814        if(m_HordeTowersControlled && m_HordeTowersControlled < 5)
815            plr->CastSpell(plr,EP_HordeBuffs[m_HordeTowersControlled-1],true);
816    }
817    OutdoorPvP::HandlePlayerEnterZone(plr,zone);
818}
819
820void OutdoorPvPEP::HandlePlayerLeaveZone(Player * plr, uint32 zone)
821{
822    // remove buffs
823    if(plr->GetTeam() == ALLIANCE)
824    {
825        for(int i = 0; i < 4; ++i)
826            plr->RemoveAurasDueToSpell(EP_AllianceBuffs[i]);
827    }
828    else
829    {
830        for(int i = 0; i < 4; ++i)
831            plr->RemoveAurasDueToSpell(EP_HordeBuffs[i]);
832    }
833    OutdoorPvP::HandlePlayerLeaveZone(plr, zone);
834}
835
836void OutdoorPvPEP::BuffTeams()
837{
838    for(std::set<uint64>::iterator itr = m_PlayerGuids[0].begin(); itr != m_PlayerGuids[0].end(); ++itr)
839    {
840        if(Player * plr = objmgr.GetPlayer(*itr))
841        {
842            for(int i = 0; i < 4; ++i)
843                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(EP_AllianceBuffs[i]);
844            if(m_AllianceTowersControlled && m_AllianceTowersControlled < 5)
845                if(plr->IsInWorld()) plr->CastSpell(plr,EP_AllianceBuffs[m_AllianceTowersControlled-1],true);
846        }
847    }
848    for(std::set<uint64>::iterator itr = m_PlayerGuids[1].begin(); itr != m_PlayerGuids[1].end(); ++itr)
849    {
850        if(Player * plr = objmgr.GetPlayer(*itr))
851        {
852            for(int i = 0; i < 4; ++i)
853                if(plr->IsInWorld()) plr->RemoveAurasDueToSpell(EP_HordeBuffs[i]);
854            if(m_HordeTowersControlled && m_HordeTowersControlled < 5)
855                if(plr->IsInWorld()) plr->CastSpell(plr,EP_HordeBuffs[m_HordeTowersControlled-1],true);
856        }
857    }
858}
859
860void OutdoorPvPEP::FillInitialWorldStates(WorldPacket & data)
861{
862    data << EP_UI_TOWER_COUNT_A << m_AllianceTowersControlled;
863    data << EP_UI_TOWER_COUNT_H << m_HordeTowersControlled;
864    data << EP_UI_TOWER_SLIDER_DISPLAY << uint32(0);
865    data << EP_UI_TOWER_SLIDER_POS << uint32(50);
866    data << EP_UI_TOWER_SLIDER_N << uint32(100);
867    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
868    {
869        (*itr)->FillInitialWorldStates(data);
870    }
871}
872
873void OutdoorPvPEP::SendRemoveWorldStates(Player *plr)
874{
875    plr->SendUpdateWorldState(EP_UI_TOWER_COUNT_A,0);
876    plr->SendUpdateWorldState(EP_UI_TOWER_COUNT_H,0);
877    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY,0);
878    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS,0);
879    plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N,0);
880
881    plr->SendUpdateWorldState(EP_EWT_A,0);
882    plr->SendUpdateWorldState(EP_EWT_H,0);
883    plr->SendUpdateWorldState(EP_EWT_N,0);
884    plr->SendUpdateWorldState(EP_EWT_A_P,0);
885    plr->SendUpdateWorldState(EP_EWT_H_P,0);
886    plr->SendUpdateWorldState(EP_EWT_N_A,0);
887    plr->SendUpdateWorldState(EP_EWT_N_H,0);
888
889    plr->SendUpdateWorldState(EP_PWT_A,0);
890    plr->SendUpdateWorldState(EP_PWT_H,0);
891    plr->SendUpdateWorldState(EP_PWT_N,0);
892    plr->SendUpdateWorldState(EP_PWT_A_P,0);
893    plr->SendUpdateWorldState(EP_PWT_H_P,0);
894    plr->SendUpdateWorldState(EP_PWT_N_A,0);
895    plr->SendUpdateWorldState(EP_PWT_N_H,0);
896
897    plr->SendUpdateWorldState(EP_NPT_A,0);
898    plr->SendUpdateWorldState(EP_NPT_H,0);
899    plr->SendUpdateWorldState(EP_NPT_N,0);
900    plr->SendUpdateWorldState(EP_NPT_A_P,0);
901    plr->SendUpdateWorldState(EP_NPT_H_P,0);
902    plr->SendUpdateWorldState(EP_NPT_N_A,0);
903    plr->SendUpdateWorldState(EP_NPT_N_H,0);
904
905    plr->SendUpdateWorldState(EP_CGT_A,0);
906    plr->SendUpdateWorldState(EP_CGT_H,0);
907    plr->SendUpdateWorldState(EP_CGT_N,0);
908    plr->SendUpdateWorldState(EP_CGT_A_P,0);
909    plr->SendUpdateWorldState(EP_CGT_H_P,0);
910    plr->SendUpdateWorldState(EP_CGT_N_A,0);
911    plr->SendUpdateWorldState(EP_CGT_N_H,0);
912}
Note: See TracBrowser for help on using the browser.