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

Revision 102, 36.5 kB (checked in by yumileroy, 17 years ago)

[svn] Fixed copyright notices to comply with GPL.

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