自学教程：C++ DoorClose函数代码示例

void BattlegroundRV::TogglePillarCollision(){    // Toggle visual pillars, pulley, gear, and collision based on previous state    for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_GEAR_2; ++i)        _pillarCollision ? DoorOpen(i) : DoorClose(i);    for (uint8 i = BG_RV_OBJECT_PILAR_2; i <= BG_RV_OBJECT_PULLEY_2; ++i)        _pillarCollision ? DoorClose(i) : DoorOpen(i);    for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PILAR_COLLISION_4; ++i)    {        if (GameObject* go = GetBGObject(i))        {            if (i >= BG_RV_OBJECT_PILAR_COLLISION_1)            {                GOState state = ((go->GetGOInfo()->door.startOpen != 0) == _pillarCollision) ? GO_STATE_ACTIVE : GO_STATE_READY;                go->SetGoState(state);            }            for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                if (Player* player = ObjectAccessor::FindPlayer(itr->first))                    go->SendUpdateToPlayer(player);        }    }    _pillarCollision = !_pillarCollision;}

void BattlegroundRV::TogglePillarCollision(){    bool apply = GetPillarCollision();    // Toggle visual pillars, pulley, gear, and collision based on previous state    for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_GEAR_2; ++i)        apply ? DoorOpen(i) : DoorClose(i);    for (uint8 i = BG_RV_OBJECT_PILAR_2; i <= BG_RV_OBJECT_PULLEY_2; ++i)        apply ? DoorClose(i) : DoorOpen(i);    for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PILAR_COLLISION_4; ++i)    {        if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[i]))        {            if (i >= BG_RV_OBJECT_PILAR_COLLISION_1)            {                uint32 _state = GO_STATE_READY;                if (gob->GetGOInfo()->door.startOpen)                    _state = GO_STATE_ACTIVE;                gob->SetGoState(apply ? (GOState)_state : (GOState)(!_state));                if (gob->GetGOInfo()->door.startOpen)                    gob->EnableCollision(!apply); // Forced collision toggle            }            for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)                if (Player* player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER)))                    gob->SendUpdateToPlayer(player);        }    }    SetPillarCollision(!apply);}

void BattlegroundDS::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    _events.Update(diff);    while (uint32 eventId = _events.ExecuteEvent())    {        switch (eventId)        {            case BG_DS_EVENT_WATERFALL_WARNING:                // Add the water                DoorClose(BG_DS_OBJECT_WATER_2);                _events.ScheduleEvent(BG_DS_EVENT_WATERFALL_ON, BG_DS_WATERFALL_WARNING_DURATION);                break;            case BG_DS_EVENT_WATERFALL_ON:                // Active collision and start knockback timer                DoorClose(BG_DS_OBJECT_WATER_1);                _events.ScheduleEvent(BG_DS_EVENT_WATERFALL_OFF, BG_DS_WATERFALL_DURATION);                _events.ScheduleEvent(BG_DS_EVENT_WATERFALL_KNOCKBACK, BG_DS_WATERFALL_KNOCKBACK_TIMER);                break;            case BG_DS_EVENT_WATERFALL_OFF:                // Remove collision and water                DoorOpen(BG_DS_OBJECT_WATER_1);                DoorOpen(BG_DS_OBJECT_WATER_2);                _events.CancelEvent(BG_DS_EVENT_WATERFALL_KNOCKBACK);                _events.ScheduleEvent(BG_DS_EVENT_WATERFALL_WARNING, urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));                break;            case BG_DS_EVENT_WATERFALL_KNOCKBACK:                // Repeat knockback while the waterfall still active                if (Creature* waterSpout = GetBGCreature(BG_DS_NPC_WATERFALL_KNOCKBACK))                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_WATER_SPOUT, true);                _events.ScheduleEvent(eventId, BG_DS_WATERFALL_KNOCKBACK_TIMER);                break;            case BG_DS_EVENT_PIPE_KNOCKBACK:                for (uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)                    if (Creature* waterSpout = GetBGCreature(i))                        waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);                break;        }    }    if (_pipeKnockBackCount < BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)    {        if (_pipeKnockBackTimer < diff)        {            for (uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)                if (Creature* waterSpout = GetBGCreature(i))                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);            ++_pipeKnockBackCount;            _pipeKnockBackTimer = BG_DS_PIPE_KNOCKBACK_DELAY;        }        else            _pipeKnockBackTimer -= diff;    }}

void BattlegroundKT::StartingEventCloseDoors(){    SpawnBGObject(BG_KT_OBJECT_A_DOOR, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_KT_OBJECT_H_DOOR, RESPAWN_IMMEDIATELY);    DoorClose(BG_KT_OBJECT_A_DOOR);    DoorClose(BG_KT_OBJECT_H_DOOR);    for (uint8 i = 0; i < 4; ++i)        SpawnBGObject(BG_KT_OBJECT_ORB_1 + i, RESPAWN_ONE_DAY);}

void BattlegroundAB::StartingEventCloseDoors(){    for (uint32 obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < BG_AB_DYNAMIC_NODES_COUNT * BG_AB_OBJECTS_PER_NODE; ++obj)        SpawnBGObject(obj, RESPAWN_ONE_DAY);    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);    // Starting doors    SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);    DoorClose(BG_AB_OBJECT_GATE_A);    DoorClose(BG_AB_OBJECT_GATE_H);}

void BattlegroundBG::StartingEventCloseDoors(){    // despawn banners, auras and buffs    for (int object = BG_BG_OBJECT_BANNER_NEUTRAL; object < BG_BG_DYNAMIC_NODES_COUNT * 8; ++object)        SpawnBGObject(object, RESPAWN_ONE_DAY);    // Starting doors    DoorClose(BG_BG_OBJECT_GATE_A);    DoorClose(BG_BG_OBJECT_GATE_H);    SpawnBGObject(BG_BG_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_BG_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);    // Starting base spirit guides    _NodeOccupied(BG_BG_SPIRIT_ALIANCE, ALLIANCE);    _NodeOccupied(BG_BG_SPIRIT_HORDE, HORDE);}

void BattlegroundRV::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    if (getTimer() < diff)    {        switch (getState())        {            case BG_RV_STATE_OPEN_FENCES:                // Open fire (only at game start)                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_CLOSE_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                break;            case BG_RV_STATE_CLOSE_FIRE:                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorClose(i);                // Fire got closed after five seconds, leaves twenty seconds before toggling pillars                setTimer(BG_RV_FIRE_TO_PILLAR_TIMER);                setState(BG_RV_STATE_SWITCH_PILLARS);                break;            case BG_RV_STATE_SWITCH_PILLARS:                TogglePillarCollision();                setTimer(BG_RV_PILLAR_SWITCH_TIMER);                break;        }    }    else        setTimer(getTimer() - diff);}

void BattlegroundDS::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    if (getWaterFallTimer() < diff)    {        if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_OFF) // Add the water        {            DoorClose(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(BG_DS_WATERFALL_WARNING_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_WARNING);        }        else if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_WARNING) // Active collision        {            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_READY);            setWaterFallTimer(BG_DS_WATERFALL_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_ON);        }        else //if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Remove collision and water        {            // turn off collision            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_ACTIVE);            DoorOpen(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));            setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);        }    }    else        setWaterFallTimer(getWaterFallTimer() - diff);}

void BattlegroundBFG::StartingEventCloseDoors(){	// Remove banners, auras and buffs	for (int object = GILNEAS_BG_OBJECT_BANNER_NEUTRAL; object < GILNEAS_BG_DYNAMIC_NODES_COUNT * 8; ++object)		SpawnBGObject(object, RESPAWN_ONE_DAY);	for (int i = 0; i < GILNEAS_BG_DYNAMIC_NODES_COUNT * 3; ++i)		SpawnBGObject(GILNEAS_BG_OBJECT_SPEEDBUFF_LIGHTHOUSE + i, RESPAWN_ONE_DAY);	// Starting doors	DoorClose(GILNEAS_BG_OBJECT_GATE_A_1);	DoorClose(GILNEAS_BG_OBJECT_GATE_H_1);	// Starting base spirit guides	_NodeOccupied(GILNEAS_BG_SPIRIT_ALIANCE, ALLIANCE);	_NodeOccupied(GILNEAS_BG_SPIRIT_HORDE, HORDE);}

void BattlegroundAB::StartingEventCloseDoors(){    // despawn banners, auras and buffs    for (int obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < BG_AB_DYNAMIC_NODES_COUNT * 8; ++obj)        SpawnBGObject(obj, RESPAWN_ONE_DAY);    for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);    // Starting doors    DoorClose(BG_AB_OBJECT_GATE_A);    DoorClose(BG_AB_OBJECT_GATE_H);    SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);    // Starting base spirit guides    _NodeOccupied(BG_AB_SPIRIT_ALIANCE, ALLIANCE);    _NodeOccupied(BG_AB_SPIRIT_HORDE, HORDE);}

void BattleGroundWS::StartingEventCloseDoors(){    for(uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)    {        DoorClose(i);        SpawnBGObject(i, RESPAWN_IMMEDIATELY);    }    for(uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)        SpawnBGObject(i, RESPAWN_ONE_DAY);}

void BattlegroundRV::Update(uint32 diff){    Battleground::Update(diff);    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (GetStartTime() >= 47*MINUTE*IN_MILLISECONDS)    // after 47 minutes without one team losing, the arena closes with no winner and no rating change        {            UpdateArenaWorldState();            CheckArenaAfterTimerConditions();        }    }    if (getTimer() < diff)    {        uint32 i;        switch(getState())        {            case BG_RV_STATE_OPEN_FENCES:            {                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                break;            }            case BG_RV_STATE_CLOSE_FIRE:                for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorClose(i);                setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                setState(BG_RV_STATE_OPEN_PILARS);                break;            case BG_RV_STATE_OPEN_PILARS:                for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_OPEN_FIRE);                break;            case BG_RV_STATE_OPEN_FIRE:                // FIXME: after 3.2.0 it's only decorative and should be opened only one time at battle start                for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                setState(BG_RV_STATE_CLOSE_PILARS);                break;            case BG_RV_STATE_CLOSE_PILARS:                uint32 i;                for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                break;        }    }    else        setTimer(getTimer() - diff);}

void BattlegroundSSM::StartingEventCloseDoors(){    for (uint32 i = BG_SSM_OBJECT_DOOR_H_1; i <= BG_SSM_OBJECT_DOOR_H_2; ++i)    {        DoorClose(i);        SpawnBGObject(i, RESPAWN_IMMEDIATELY);    }    for (uint32 i = BG_SSM_OBJECT_BUFF_1; i <= BG_SSM_OBJECT_BUFF_4; ++i)        SpawnBGObject(i, RESPAWN_ONE_DAY);}

void BattlegroundKT::StartingEventCloseDoors(){    for (uint32 i = BG_KT_OBJECT_A_DOOR; i <= BG_KT_OBJECT_H_DOOR; ++i)    {        SpawnBGObject(i, RESPAWN_IMMEDIATELY);        DoorClose(i);    }    for (uint8 i = BG_KT_OBJECT_ORB_1; i <= BG_KT_OBJECT_ORB_4; ++i)        SpawnBGObject(i, RESPAWN_ONE_DAY);}

void BattlegroundWS::StartingEventCloseDoors(){    DoorClose(BG_WS_OBJECT_DOOR_A_1);    DoorClose(BG_WS_OBJECT_DOOR_A_2);    SpawnBGObject(BG_WS_OBJECT_DOOR_A_3, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_A_4, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_IMMEDIATELY);    DoorClose(BG_WS_OBJECT_DOOR_H_1);    DoorClose(BG_WS_OBJECT_DOOR_H_2);    SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_H_5, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_WS_OBJECT_DOOR_H_6, RESPAWN_IMMEDIATELY);    for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)        SpawnBGObject(i, RESPAWN_ONE_DAY);    UpdateWorldState(BG_WS_STATE_TIMER_ACTIVE, 1);    UpdateWorldState(BG_WS_STATE_TIMER, 25);}

void BattlegroundDS::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    if (getPipeKnockBackCount() < BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)    {        if (getPipeKnockBackTimer() < diff)        {            for (uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)                if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[i]))                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);            setPipeKnockBackCount(getPipeKnockBackCount() + 1);            setPipeKnockBackTimer(BG_DS_PIPE_KNOCKBACK_DELAY);        }        else            setPipeKnockBackTimer(getPipeKnockBackTimer() - diff);    }    if (getWaterFallTimer() < diff)    {        if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_OFF) // Add the water        {            DoorClose(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(BG_DS_WATERFALL_WARNING_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_WARNING);        }        else if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_WARNING) // Active collision and perform knockback        {            if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[BG_DS_NPC_WATERFALL_KNOCKBACK]))                waterSpout->CastSpell(waterSpout, BG_DS_SPELL_WATER_SPOUT, true);            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_READY);            setWaterFallTimer(BG_DS_WATERFALL_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_ON);        }        else //if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Remove collision and water        {            // turn off collision            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_ACTIVE);            DoorOpen(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));            setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);        }    }    else        setWaterFallTimer(getWaterFallTimer() - diff);}

void BattleGroundIC::StartingEventCloseDoors(){    uint16 i;    for (int obj = BG_IC_OBJECT_BANNER_NEUTRAL; obj < BG_IC_DYNAMIC_NODES_COUNT * 8; ++obj)        SpawnBGObject(obj, RESPAWN_ONE_DAY);    for (i = BG_IC_OBJECT_HORDE_PORTCULLIS; i <= BG_IC_OBJECT_SEAFOAM_BOMB_3 ; i++)        SpawnBGObject(i, RESPAWN_IMMEDIATELY);    // Starting doors    DoorClose(BG_IC_OBJECT_GATE_H_1);    DoorClose(BG_IC_OBJECT_GATE_A_1);    DoorClose(BG_IC_OBJECT_GATE_H_2);    DoorClose(BG_IC_OBJECT_GATE_A_2);    DoorClose(BG_IC_OBJECT_GATE_H_3);    DoorClose(BG_IC_OBJECT_GATE_A_3);    SpawnBGObject(BG_IC_OBJECT_GATE_H_1, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_IC_OBJECT_GATE_A_1, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_IC_OBJECT_GATE_H_2, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_IC_OBJECT_GATE_A_2, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_IC_OBJECT_GATE_H_3, RESPAWN_IMMEDIATELY);    SpawnBGObject(BG_IC_OBJECT_GATE_A_3, RESPAWN_IMMEDIATELY);    _NodeOccupied(BG_IC_SPIRIT_ALIANCE,ALLIANCE);    _NodeOccupied(BG_IC_SPIRIT_HORDE,HORDE);}

bool CCar::bfAssignObject(CScriptEntityAction *tpEntityAction){	CScriptObjectAction	&l_tObjectAction = tpEntityAction->m_tObjectAction;	if (l_tObjectAction.m_bCompleted || !xr_strlen(l_tObjectAction.m_caBoneName))		return((l_tObjectAction.m_bCompleted = true) == false);	s16	l_sBoneID = smart_cast<IKinematics*>(Visual())->LL_BoneID(l_tObjectAction.m_caBoneName);	if (is_Door(l_sBoneID)) {		switch(l_tObjectAction.m_tGoalType) {			case MonsterSpace::eObjectActionActivate : {				if (!DoorOpen(l_sBoneID))					return((l_tObjectAction.m_bCompleted = true) == false);				break;			}			case MonsterSpace::eObjectActionDeactivate : {				if (!DoorClose(l_sBoneID))					return((l_tObjectAction.m_bCompleted = true) == false);				break;			}			case MonsterSpace::eObjectActionUse : {				if (!DoorSwitch(l_sBoneID))					return((l_tObjectAction.m_bCompleted = true) == false);				break;			}			default : 				return	((l_tObjectAction.m_bCompleted = true) == false);		}		return		(false);	}	SCarLight* light=NULL;	if (m_lights.findLight(l_sBoneID,light)) {		switch(l_tObjectAction.m_tGoalType) {			case MonsterSpace::eObjectActionActivate : {				light->TurnOn();				return		((l_tObjectAction.m_bCompleted = true) == false);			}			case MonsterSpace::eObjectActionDeactivate : {				light->TurnOff();				return		((l_tObjectAction.m_bCompleted = true) == false);			}			case MonsterSpace::eObjectActionUse : {				light->Switch();				return		((l_tObjectAction.m_bCompleted = true) == false);			}			default : 				return	((l_tObjectAction.m_bCompleted = true) == false);		}		}		return			(false);}

void BattlegroundTP::StartingEventCloseDoors(){    for (uint32 i = BG_TP_OBJECT_DOOR_A_1; i <= BG_TP_OBJECT_DOOR_H_3; ++i)    {        DoorClose(i);        SpawnBGObject(i, RESPAWN_IMMEDIATELY);    }    for (uint32 i = BG_TP_OBJECT_A_FLAG; i <= BG_TP_OBJECT_BERSERKBUFF_2; ++i)        SpawnBGObject(i, RESPAWN_ONE_DAY);    UpdateWorldState(BG_TP_STATE_TIMER_ACTIVE, 1);    UpdateWorldState(BG_TP_STATE_TIMER, 25);}

void BattlegroundRV::Update(uint32 diff){    Battleground::Update(diff);    if (getTimer() < diff)    {        uint32 i;        switch(getState())        {        case BG_RV_STATE_OPEN_FENCES:        {            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_CLOSE_FIRE);            break;        }        case BG_RV_STATE_CLOSE_FIRE:            for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                DoorClose(i);            setTimer(BG_RV_FIRE_TO_PILAR_TIMER);            setState(BG_RV_STATE_OPEN_PILARS);            break;        case BG_RV_STATE_OPEN_PILARS:            for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                DoorOpen(i);            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_OPEN_FIRE);            break;        case BG_RV_STATE_OPEN_FIRE:            for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                DoorOpen(i);            setTimer(BG_RV_FIRE_TO_PILAR_TIMER);            setState(BG_RV_STATE_CLOSE_PILARS);            break;        case BG_RV_STATE_CLOSE_PILARS:            uint32 i;            for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                DoorOpen(i);            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_CLOSE_FIRE);            break;        }    }    else        setTimer(getTimer() - diff);}

void BattlegroundRV::PostUpdateImpl(uint32 diff){    if(GetStatus() != STATUS_IN_PROGRESS)        return;    if (getTimer() < diff)    {        switch (getState())        {        case BG_RV_STATE_OPEN_FENCES:            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_CLOSE_FIRE);            break;        case BG_RV_STATE_CLOSE_FIRE:            for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                DoorClose(i);            setTimer(BG_RV_FIRE_TO_PILAR_TIMER);            setState(BG_RV_STATE_OPEN_PILARS);            break;        case BG_RV_STATE_OPEN_PILARS:            for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                DoorOpen(i);            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_OPEN_FIRE);            SwitchDynLos();            break;        case BG_RV_STATE_OPEN_FIRE:            // FIXME: after 3.2.0 it's only decorative and should be opened only one time at battle start            for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                DoorOpen(i);            setTimer(BG_RV_FIRE_TO_PILAR_TIMER);            setState(BG_RV_STATE_CLOSE_PILARS);            break;        case BG_RV_STATE_CLOSE_PILARS:            for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                DoorOpen(i);            setTimer(BG_RV_PILAR_TO_FIRE_TIMER);            setState(BG_RV_STATE_CLOSE_FIRE);            SwitchDynLos();            break;        }    }    else        setTimer(getTimer() - diff);}

void BattlegroundRV::PostUpdateImpl(uint32 diff){    if (getTimer() < diff)    {        switch (getState())        {            case BG_RV_STATE_OPEN_FENCES:                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                break;            case BG_RV_STATE_CLOSE_FIRE:                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorClose(i);                setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                setState(BG_RV_STATE_OPEN_PILARS);                break;            case BG_RV_STATE_OPEN_PILARS:                for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                    DoorOpen(i);                TogglePillarCollision(false);                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_OPEN_FIRE);                break;            case BG_RV_STATE_OPEN_FIRE:                // FIXME: after 3.2.0 it's only decorative and should be opened only one time at battle start                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                setState(BG_RV_STATE_CLOSE_PILARS);                break;            case BG_RV_STATE_CLOSE_PILARS:                for (uint8 i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                    DoorOpen(i);                TogglePillarCollision(true);                setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                break;        }    }    else        setTimer(getTimer() - diff);}

//-------------------------------------------------------------------------//	功能：	设定物件状态//-------------------------------------------------------------------------void	KObj::SetState(int nState, int nPlaySoundFlag/* = 0*/){	if (nState < 0)		return;	m_nState = nState;	switch (m_nKind)	{	case Obj_Kind_Box:		if (nState == OBJ_BOX_STATE_CLOSE)			BoxClose();		else if (nState == OBJ_BOX_STATE_OPEN)			BoxOpen();		break;	case Obj_Kind_Door:		if (nState == OBJ_DOOR_STATE_CLOSE)			DoorClose();		else if (nState == OBJ_DOOR_STATE_OPEN)			DoorOpen();		break;	case Obj_Kind_Prop:		if (nState == OBJ_PROP_STATE_HIDE)		{			m_nBornTime = m_nLifeTime;		}		break;	}#ifndef _SERVER	if (nPlaySoundFlag)		PlaySound();#endif#ifdef _SERVER	SyncState();#endif}

void BattlegroundDS::Update(uint32 diff){    Battleground::Update(diff);    if(GetStatus() != STATUS_IN_PROGRESS)        return;    if(GetStatus() == STATUS_IN_PROGRESS)    {        if(GetStartTime() >= 47*MINUTE*IN_MILLISECONDS)    // after 47 minutes without one team losing, the arena closes with no winner and no rating change        {            UpdateArenaWorldState();            CheckArenaAfterTimerConditions();        }    }    if(getPipeKnockBackCount() < BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)    {        if(getPipeKnockBackTimer() < diff)        {            for(uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)                if(Creature* waterSpout = GetBgMap()->GetCreature(BGArrayForCreatures[i]))                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);            setPipeKnockBackCount(getPipeKnockBackCount() + 1);            setPipeKnockBackTimer(BG_DS_PIPE_KNOCKBACK_DELAY);        }        else            setPipeKnockBackTimer(getPipeKnockBackTimer() - diff);    }    //if(!m_knockback && m_teleport)    //{    //    if(m_teleport <= diff)    //    {    //        for(BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)    //        {    //            Player* plr = ObjectAccessor::FindPlayer(itr->first);    //            if(!plr)    //                continue;    //            if(plr->GetPositionZ() > 13.0f)    //                HandlePlayerUnderMap(plr);    //        }    //        m_teleport = 5 * IN_MILLISECONDS;    //    }    //    else    //        m_teleport -= diff;    //}    if(getWaterFallTimer() < diff)    {        switch(getWaterFallStatus())        {        case BG_DS_WATERFALL_STATUS_OFF: // Add the water            DoorClose(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(BG_DS_WATERFALL_WARNING_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_WARNING);            break;        case BG_DS_WATERFALL_STATUS_WARNING: // Active collision and start knockback timer            if(GameObject* gob = GetBgMap()->GetGameObject(BGArrayForObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_READY);            setWaterFallTimer(BG_DS_WATERFALL_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_ON);            setWaterFallKnockbackTimer(BG_DS_WATERFALL_KNOCKBACK_TIMER);            break;        case BG_DS_WATERFALL_STATUS_ON: // Remove collision and water            // turn off collision            if(GameObject* gob = GetBgMap()->GetGameObject(BGArrayForObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_ACTIVE);            DoorOpen(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));            setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);            break;        }    }    else        setWaterFallTimer(getWaterFallTimer() - diff);}

void BattlegroundRV::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    if (getTimer() < diff)    {        switch (getState())        {            case BG_RV_STATE_OPEN_FENCES:                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorOpen(i);                setTimer(BG_RV_CLOSE_FIRE_TIMER);                setState(BG_RV_STATE_CLOSE_FIRE);                for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)                    if (Player* player = itr->second)                    {                        // Demonic Circle Summon                        if (GameObject* gObj = player->GetGameObject(48018))                        {                            gObj->Relocate(gObj->GetPositionX(), gObj->GetPositionY(), 28.28f);                            gObj->UpdateObjectVisibility(true);                        }                        if (player->GetPositionZ() < 27.0f)                            TeleportUnitToNewZ(player, 28.28f, true);                        for (uint8 i = SUMMON_SLOT_TOTEM; i < MAX_TOTEM_SLOT; ++i)                            if (player->m_SummonSlot[i])                                if (Creature* totem = GetBgMap()->GetCreature(player->m_SummonSlot[i]))                                    if (totem->GetPositionZ() < 28.0f)                                        TeleportUnitToNewZ(totem, 28.28f, true);                        for (Unit::ControlSet::const_iterator itr = player->m_Controlled.begin(); itr != player->m_Controlled.end(); ++itr)                        {                            if ((*itr)->GetPositionZ() < 28.0f)                                TeleportUnitToNewZ((*itr), 28.28f, true);                            // Xinef: override stay position                            if (CharmInfo* charmInfo = (*itr)->GetCharmInfo())                                if (charmInfo->IsAtStay())                                {                                    (*itr)->StopMovingOnCurrentPos();                                    charmInfo->SaveStayPosition(false);                                }                        }                    }                // fix ground on elevators (so aoe spells can be casted there)                {                    uint32 objects[2] = {BG_RV_OBJECT_ELEVATOR_1, BG_RV_OBJECT_ELEVATOR_2};                    for (uint8 i=0; i<2; ++i)                        if (GameObject* go = GetBGObject(objects[i]))                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_TRANSPORT);                }                break;            case BG_RV_STATE_CLOSE_FIRE:                for (uint8 i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                    DoorClose(i);                // Fire got closed after five seconds, leaves twenty seconds before toggling pillars                setTimer(BG_RV_FIRE_TO_PILLAR_TIMER);                setState(BG_RV_STATE_SWITCH_PILLARS);                break;            case BG_RV_STATE_SWITCH_PILLARS:                UpdatePillars();                setTimer(BG_RV_PILLAR_SWITCH_TIMER);                break;        }    }    else        setTimer(getTimer() - diff);    if (getState() == BG_RV_STATE_OPEN_FENCES)        return;    if (CheckPlayersTimer <= diff)    {        CheckPlayersTimer = 0;        for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)            CheckPositionForUnit(itr->second);        // maybe for pets and m_Controlled also, but not really necessary    }    else        CheckPlayersTimer -= diff;}

void BattlegroundRV::Update(uint32 diff){    Battleground::Update(diff);    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (GetStartTime() >= 47*MINUTE*IN_MILLISECONDS)    // after 47 minutes without one team losing, the arena closes with no winner and no rating change        {            UpdateArenaWorldState();            CheckArenaAfterTimerConditions();        }        // bochki        if (!fencesopened)        {            if (fencestimer < diff)            {                fencesopened = true;            }            else                fencestimer -= diff;        }    }    if (getTimer() < diff)    {        uint32 i;        if (GetBgMap())            switch(getState())            {                case BG_RV_STATE_OPEN_FENCES:                {                    setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                    setState(BG_RV_STATE_CLOSE_FIRE);                    break;                }                case BG_RV_STATE_CLOSE_FIRE:                    for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                        DoorClose(i);                    setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                    setState(BG_RV_STATE_OPEN_PILARS);                    break;                case BG_RV_STATE_OPEN_PILARS:                    pillarsopened=true;                    for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                        DoorOpen(i);                    setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                    setState(BG_RV_STATE_OPEN_FIRE);                    break;                case BG_RV_STATE_OPEN_FIRE:                    for (i = BG_RV_OBJECT_FIRE_1; i <= BG_RV_OBJECT_FIREDOOR_2; ++i)                        DoorOpen(i);                    setTimer(BG_RV_FIRE_TO_PILAR_TIMER);                    setState(BG_RV_STATE_CLOSE_PILARS);                    break;                case BG_RV_STATE_CLOSE_PILARS:                    pillarsopened=false;                    uint32 i;                    for (i = BG_RV_OBJECT_PILAR_1; i <= BG_RV_OBJECT_PULLEY_2; ++i)                        DoorOpen(i);                    setTimer(BG_RV_PILAR_TO_FIRE_TIMER);                    setState(BG_RV_STATE_CLOSE_FIRE);                    break;            }    }    else        setTimer(getTimer() - diff);}

void BattleGroundWS::Update(uint32 diff){    BattleGround::Update(diff);    // after bg start we get there (once)    if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())    {        ModifyStartDelayTime(diff);        if (!(m_Events & 0x01))        {            m_Events |= 0x01;            // setup here, only when at least one player has ported to the map            if (!SetupBattleGround())            {                EndNow();                return;            }//            for (uint32 i = WS_SPIRIT_MAIN_ALLIANCE; i <= WS_SPIRIT_MAIN_HORDE; i++)//                SpawnBGCreature(i, RESPAWN_IMMEDIATELY);            for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_H_4; i++)            {                SpawnBGObject(i, RESPAWN_IMMEDIATELY);                DoorClose(i);            }            for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; i++)                SpawnBGObject(i, RESPAWN_ONE_DAY);            SetStartDelayTime(START_DELAY0);        }        // After 1 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY1 && !(m_Events & 0x04))        {            m_Events |= 0x04;            SendMessageToAll(GetTrinityString(LANG_BG_WS_ONE_MINUTE));        }        // After 1,5 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x08))        {            m_Events |= 0x08;            SendMessageToAll(GetTrinityString(LANG_BG_WS_HALF_MINUTE));        }        // After 2 minutes, gates OPEN ! x)        else if (GetStartDelayTime() < 0 && !(m_Events & 0x10))        {            m_Events |= 0x10;            for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_A_4; i++)                DoorOpen(i);            for (uint32 i = BG_WS_OBJECT_DOOR_H_1; i <= BG_WS_OBJECT_DOOR_H_2; i++)                DoorOpen(i);            SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_ONE_DAY);            for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; i++)                SpawnBGObject(i, RESPAWN_IMMEDIATELY);            SendMessageToAll(GetTrinityString(LANG_BG_WS_BEGIN));            PlaySoundToAll(SOUND_BG_START);            if (sWorld.getConfig(CONFIG_BG_START_MUSIC))                PlaySoundToAll(SOUND_BG_START_L70ETC); //MUSIC - Custom config            SetStatus(STATUS_IN_PROGRESS);            for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                if (Player* plr = sObjectMgr.GetPlayer(itr->first))                    plr->RemoveAurasDueToSpell(SPELL_PREPARATION);        }    }    else if (GetStatus() == STATUS_IN_PROGRESS)    {        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlag(ALLIANCE, true);            }        }        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)        {            m_FlagsDropTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsDropTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsDropTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlagAfterDrop(ALLIANCE);                m_BothFlagsKept = false;            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_HORDE] -= diff;//.........这里部分代码省略.........

void BattleGroundAB::Update(time_t diff){    BattleGround::Update(diff);    if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize() )    {        ModifyStartDelayTime(diff);        if (!(m_Events & 0x01) )        {            m_Events |= 0x01;            // setup here, only when at least one player has ported to the map            if (!SetupBattleGround())            {                EndNow();                return;            }            sLog.outDebug("Arathi Basin: entering state STATUS_WAIT_JOIN ...");            // despawn banners, auras and buffs            for (int obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < BG_AB_DYNAMIC_NODES_COUNT * 8; ++obj)                SpawnBGObject(obj, RESPAWN_ONE_DAY);            for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)                SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);            // Starting doors            SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);            SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);            DoorClose(BG_AB_OBJECT_GATE_A);            DoorClose(BG_AB_OBJECT_GATE_H);            // Starting base spirit guides            _NodeOccupied(BG_AB_SPIRIT_ALIANCE,ALLIANCE);            _NodeOccupied(BG_AB_SPIRIT_HORDE,HORDE);            SetStartDelayTime(START_DELAY0);        }        // After 1 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY1 && !(m_Events & 0x04) )        {            m_Events |= 0x04;            SendMessageToAll(GetNeoString(LANG_BG_AB_ONEMINTOSTART));        }        // After 1,5 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x08) )        {            m_Events |= 0x08;            SendMessageToAll(GetNeoString(LANG_BG_AB_HALFMINTOSTART));        }        // After 2 minutes, gates OPEN ! x)        else if (GetStartDelayTime() < 0 && !(m_Events & 0x10) )        {            m_Events |= 0x10;            SendMessageToAll(GetNeoString(LANG_BG_AB_STARTED));            // spawn neutral banners            for (int banner = BG_AB_OBJECT_BANNER_NEUTRAL, i = 0; i < 5; banner += 8, ++i)                SpawnBGObject(banner, RESPAWN_IMMEDIATELY);            for (int i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)            {                //randomly select buff to spawn                uint8 buff = urand(0, 2);                SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + buff + i * 3, RESPAWN_IMMEDIATELY);            }            DoorOpen(BG_AB_OBJECT_GATE_A);            DoorOpen(BG_AB_OBJECT_GATE_H);            PlaySoundToAll(SOUND_BG_START);            if (sWorld.getConfig(CONFIG_BG_START_MUSIC))                PlaySoundToAll(SOUND_BG_START_L70ETC); //MUSIC            SetStatus(STATUS_IN_PROGRESS);            for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                if (Player* plr = objmgr.GetPlayer(itr->first))                    plr->RemoveAurasDueToSpell(SPELL_PREPARATION);        }    }    else if (GetStatus() == STATUS_IN_PROGRESS )    {        int team_points[2] = { 0, 0 };        for (int node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)        {            // 3 sec delay to spawn new banner instead previous despawned one            if (m_BannerTimers[node].timer )            {                if (m_BannerTimers[node].timer > diff )                    m_BannerTimers[node].timer -= diff;                else                {                    m_BannerTimers[node].timer = 0;                    _CreateBanner(node, m_BannerTimers[node].type, m_BannerTimers[node].teamIndex, false);                }            }            // 1-minute to occupy a node from contested state            if (m_NodeTimers[node] )//.........这里部分代码省略.........

void BattlegroundDS::PostUpdateImpl(uint32 diff){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    if (getPipeKnockBackCount() < BG_DS_PIPE_KNOCKBACK_TOTAL_COUNT)    {        if (getPipeKnockBackTimer() < diff)        {            for (uint32 i = BG_DS_NPC_PIPE_KNOCKBACK_1; i <= BG_DS_NPC_PIPE_KNOCKBACK_2; ++i)                if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[i]))                    waterSpout->CastSpell(waterSpout, BG_DS_SPELL_FLUSH, true);            setPipeKnockBackCount(getPipeKnockBackCount() + 1);            setPipeKnockBackTimer(BG_DS_PIPE_KNOCKBACK_DELAY);        }        else            setPipeKnockBackTimer(getPipeKnockBackTimer() - diff);    }    if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Repeat knockback while the waterfall still active    {        if (getWaterFallKnockbackTimer() < diff)        {            if (Creature* waterSpout = GetBgMap()->GetCreature(BgCreatures[BG_DS_NPC_WATERFALL_KNOCKBACK]))                waterSpout->CastSpell(waterSpout, BG_DS_SPELL_WATER_SPOUT, true);            setWaterFallKnockbackTimer(BG_DS_WATERFALL_KNOCKBACK_TIMER);        }        else            setWaterFallKnockbackTimer(getWaterFallKnockbackTimer() - diff);    }    if (getWaterFallTimer() < diff)    {        if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_OFF) // Add the water        {            DoorClose(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(BG_DS_WATERFALL_WARNING_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_WARNING);        }        else if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_WARNING) // Active collision and start knockback timer        {            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_READY);            setWaterFallTimer(BG_DS_WATERFALL_DURATION);            setWaterFallStatus(BG_DS_WATERFALL_STATUS_ON);            setWaterFallKnockbackTimer(BG_DS_WATERFALL_KNOCKBACK_TIMER);        }        else //if (getWaterFallStatus() == BG_DS_WATERFALL_STATUS_ON) // Remove collision and water        {            // turn off collision            if (GameObject* gob = GetBgMap()->GetGameObject(BgObjects[BG_DS_OBJECT_WATER_1]))                gob->SetGoState(GO_STATE_ACTIVE);            DoorOpen(BG_DS_OBJECT_WATER_2);            setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));            setWaterFallStatus(BG_DS_WATERFALL_STATUS_OFF);        }    }    else        setWaterFallTimer(getWaterFallTimer() - diff);        if (GetStatus() == STATUS_IN_PROGRESS)    {        if(knockback < diff && knockbackCheck)        {            for(BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end();itr++)            {                Player * plr = ObjectAccessor::FindPlayer(itr->first);                if (plr->GetTeam() == ALLIANCE && plr->GetDistance2d(1214, 765) <= 50 && plr->GetPositionZ() > 10)                    KnockBackPlayer(plr, 6.15f, 50.00f, 7.00f);                if (plr->GetTeam() == HORDE && plr->GetDistance2d(1369, 817) <= 50 && plr->GetPositionZ() > 10)                    KnockBackPlayer(plr, 3.10f, 50.00f, 7.00f);                plr->RemoveAurasDueToSpell(48018);            }            knockbackCheck = false;        }            else knockback -= diff;    }}