void UpdateAI(const uint32 uiDiff)
    {
        if(!UpdateVictim())
            return;

        if (!m_pInstance || m_pInstance->GetData(DATA_SAURFANG_EVENT) != IN_PROGRESS)
            me->ForcedDespawn();

     if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
     {
        if (m_uiScentOfBloodTimer < uiDiff)
        {
            if (!ScentOfBlood && (me->GetHealth()*100) / me->GetMaxHealth() < 20)
            {
                if (urand(0,1))
                DoCast(me, SPELL_SCENT_OF_BLOOD);
                ScentOfBlood = true;
                m_uiScentOfBloodTimer = 9000;
//                pSaurfang->ModifyPower(pSaurfang->getPowerType(POWER_BLOOD_POWER), +1);
            }
        } else m_uiScentOfBloodTimer -= uiDiff;
     }

        DoMeleeAttackIfReady();
    }
Example #2
0
    void UpdateAI(const uint32 uiDiff)
    {
        if (!UpdateVictim())
            return;

        if (m_uiGastricBloatTimer < uiDiff)
        {
            Unit* pTarget = SelectUnit(SELECT_TARGET_TOPAGGRO, 0);
            DoCast(pTarget, SPELL_GASTRIC_BLOAT);
            m_uiGastricBloatTimer = 21000;
        } else m_uiGastricBloatTimer -= uiDiff;

        if(m_uiInhaleBlightTimer < uiDiff)
        {
            if (me->HasAura(SPELL_PUNGENT_BLIGHT))
            {
                me->RemoveAurasDueToSpell(SPELL_PUNGENT_BLIGHT);
            }
            DoCast(me, SPELL_INHALE_BLIGHT);
            m_uiInhaleBlightTimer = 33000;
        } else m_uiInhaleBlightTimer -= uiDiff;

        if (m_uiVileGasTimer < uiDiff)
        {
            Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
            DoCast(pTarget, SPELL_VILE_GAS);
            m_uiVileGasTimer = 37000;
        } else m_uiVileGasTimer -= uiDiff;

        if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
        {
            if (m_uiGasSporesTimer < uiDiff)
            {
                DoScriptText(SAY_GAS_SPORES, me);
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
                if (pTarget && !pTarget->HasAura(SPELL_GAS_SPORES))
                    {
                        DoCast(pTarget, SPELL_GAS_SPORES);
                    }
                m_uiGasSporesTimer = 23000;
            } else m_uiGasSporesTimer -= uiDiff;
        }

        if (m_uiPungentBlightTimer < uiDiff)
        {
            DoCastAOE(SPELL_PUNGENT_BLIGHT);
            m_uiPungentBlightTimer = 120000;
            m_uiInhaleBlightTimer = 33000;
            me->RemoveAllAuras();
        } else m_uiPungentBlightTimer -= uiDiff;

        if(m_uiBerserkTimer < uiDiff)
        {
            DoCast(me, SPELL_BERSERK);
            m_uiBerserkTimer = 300000;
        }

        DoMeleeAttackIfReady();
    }
Example #3
0
    void Reset()
    {
                me->SetReactState(REACT_PASSIVE);

                if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
                {
                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
                }
    }
Example #4
0
    void Reset()
    {
                uiNetherPortalEffectTimer = urand (1000,2000);
                uiSpellNetherPortal = urand (1000,2000);
                me->SetDisplayId(25206);
                me->SetReactState(REACT_PASSIVE);
                m_bIsSummonGuardian = false;

                if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
                {
                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
                }
    }
        void Reset()
        {
            m_uiImpaleTimer = urand(8*IN_MILLISECONDS, 10*IN_MILLISECONDS);
            m_uiStaggeringStompTimer = 15*IN_MILLISECONDS;
            m_uiSummonTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);;

            if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL ||
                getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
                m_uiSummonCount = 5;
            else
                m_uiSummonCount = 4;

            Summons.DespawnAll();
        }
Example #6
0
 void Reset()
 {
     if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL) {
         me->ApplySpellImmune(0, IMMUNITY_MECHANIC, SPELL_EFFECT_BIND, true);
         me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_CHARM, true);
     }
 }
Example #7
0
 void Reset()
 {
     _Reset();
     
     me->SetReactState(REACT_PASSIVE);
     
     // Spawn NPC Helpers
     if (Helper[0] = me->SummonCreature(NPC_FIELD_MEDIC_PENNY, 1983.75, -243.36, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
         if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[0]->GetPositionX(), Helper[0]->GetPositionY(), Helper[0]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
         {
             pIceBlock->CastSpell(Helper[0], SPELL_BLOCK_OF_ICE, true);
             Helper[0]->AddThreat(me, 100);
         }
     if (Helper[1] = me->SummonCreature(NPC_EIVI_NIGHTFEATHER, 1999.90, -230.49, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
         if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[1]->GetPositionX(), Helper[1]->GetPositionY(), Helper[1]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
         {
             pIceBlock->CastSpell(Helper[1], SPELL_BLOCK_OF_ICE, true);
             Helper[1]->AddThreat(me, 100);
         }
     if (Helper[2] = me->SummonCreature(NPC_ELEMENTALIST_MAHFUUN, 2010.06, -243.45, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
         if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[2]->GetPositionX(), Helper[2]->GetPositionY(), Helper[2]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
         {
             pIceBlock->CastSpell(Helper[2], SPELL_BLOCK_OF_ICE, true);
             Helper[2]->AddThreat(me, 100);
         }
     if (Helper[3] = me->SummonCreature(NPC_MISSY_FLAMECUFFS, 2021.12, -236.65, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
         if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[3]->GetPositionX(), Helper[3]->GetPositionY(), Helper[3]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
         {
             pIceBlock->CastSpell(Helper[3], SPELL_BLOCK_OF_ICE, true);
             Helper[3]->AddThreat(me, 100);
         }
             
     if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
     {
         if (Helper[4] = me->SummonCreature(NPC_FIELD_MEDIC_JESSY, 1976.60, -233.53, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
             if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[4]->GetPositionX(), Helper[4]->GetPositionY(), Helper[4]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
             {
                 pIceBlock->CastSpell(Helper[4], SPELL_BLOCK_OF_ICE, true);
                 Helper[4]->AddThreat(me, 100);
             }            
         if (Helper[5] = me->SummonCreature(NPC_ELLIE_NIGHTFEATHER, 1992.90, -237.54, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
             if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[5]->GetPositionX(), Helper[5]->GetPositionY(), Helper[5]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
             {
                 pIceBlock->CastSpell(Helper[5], SPELL_BLOCK_OF_ICE, true);
                 Helper[5]->AddThreat(me, 100);
             }            
         if (Helper[6] = me->SummonCreature(NPC_ELEMENTALIST_AVUUN, 2014.18, -232.80, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
             if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[6]->GetPositionX(), Helper[6]->GetPositionY(), Helper[6]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
             {
                 pIceBlock->CastSpell(Helper[6], SPELL_BLOCK_OF_ICE, true);
                 Helper[6]->AddThreat(me, 100);
             }            
         if (Helper[7] = me->SummonCreature(NPC_SISSY_FLAMECUFFS, 2028.10, -244.66, 432.767, 1.57, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
             if (Creature *pIceBlock = me->SummonCreature(NPC_FLASH_FREEZE, Helper[7]->GetPositionX(), Helper[7]->GetPositionY(), Helper[7]->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN))
             {
                 pIceBlock->CastSpell(Helper[7], SPELL_BLOCK_OF_ICE, true);
                 Helper[7]->AddThreat(me, 100);
             }            
     }
 }
Example #8
0
        void EnterCombat(Unit* who)
        {
            if (!instance->CheckRequiredBosses(DATA_LADY_DEATHWHISPER, who->ToPlayer()))
            {
                EnterEvadeMode();
                instance->DoCastSpellOnPlayers(LIGHT_S_HAMMER_TELEPORT);
                return;
            }

            me->setActive(true);
            DoZoneInCombat();

            events.Reset();
            events.SetPhase(PHASE_ONE);
            // phase-independent events
            events.ScheduleEvent(EVENT_BERSERK, 600000);
            events.ScheduleEvent(EVENT_DEATH_AND_DECAY, 10000);
            // phase one only
            events.ScheduleEvent(EVENT_P1_SUMMON_WAVE, 5000, 0, PHASE_ONE);
            events.ScheduleEvent(EVENT_P1_SHADOW_BOLT, urand(5500, 6000), 0, PHASE_ONE);
            events.ScheduleEvent(EVENT_P1_EMPOWER_CULTIST, urand(20000, 30000), 0, PHASE_ONE);
            if (getDifficulty() != RAID_DIFFICULTY_10MAN_NORMAL)
                events.ScheduleEvent(EVENT_DOMINATE_MIND_H, 27000);

            Talk(SAY_AGGRO);
            DoStartNoMovement(who);
            me->RemoveAurasDueToSpell(SPELL_SHADOW_CHANNELING);
            DoCast(me, SPELL_MANA_BARRIER, true);

            instance->SetBossState(DATA_LADY_DEATHWHISPER, IN_PROGRESS);
        }
Example #9
0
 // summoning function for first phase
 void SummonWaveP1()
 {
     uint8 addIndex = uiAddWaveCounter & 1;
     uint8 addIndexOther = addIndex ^ 1;
     _SummonAdd(uiAddEntries[addIndex], addSpawnPos[addIndex*3]);
     _SummonAdd(uiAddEntries[addIndexOther], addSpawnPos[addIndex*3+1]);
     _SummonAdd(uiAddEntries[addIndex], addSpawnPos[addIndex*3+2]);
     if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
     {
         _SummonAdd(uiAddEntries[addIndexOther], addSpawnPos[addIndexOther*3]);
         _SummonAdd(uiAddEntries[addIndex], addSpawnPos[addIndexOther*3+1]);
         _SummonAdd(uiAddEntries[addIndexOther], addSpawnPos[addIndexOther*3+2]);
         _SummonAdd(uiAddEntries[urand(0,1)], addSpawnPos[6]);
     }
     ++uiAddWaveCounter;
 }
Example #10
0
 void DoGothikSummon(uint32 entry)
 {
     if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
     {
         switch(entry)
         {
             case MOB_LIVE_TRAINEE:
             {
                 if (Creature *LiveTrigger0 = Unit::GetCreature(*me, LiveTriggerGUID[0]))
                     DoSummon(MOB_LIVE_TRAINEE, LiveTrigger0, 1);
                 if (Creature *LiveTrigger1 = Unit::GetCreature(*me, LiveTriggerGUID[1]))
                     DoSummon(MOB_LIVE_TRAINEE, LiveTrigger1, 1);
                 if (Creature *LiveTrigger2 = Unit::GetCreature(*me, LiveTriggerGUID[2]))
                     DoSummon(MOB_LIVE_TRAINEE, LiveTrigger2, 1);
                 break;
             }
             case MOB_LIVE_KNIGHT:
             {
                 if (Creature *LiveTrigger3 = Unit::GetCreature(*me, LiveTriggerGUID[3]))
                     DoSummon(MOB_LIVE_KNIGHT, LiveTrigger3, 1);
                 if (Creature *LiveTrigger5 = Unit::GetCreature(*me, LiveTriggerGUID[5]))
                     DoSummon(MOB_LIVE_KNIGHT, LiveTrigger5, 1);
                 break;
             }
             case MOB_LIVE_RIDER:
             {
                 if (Creature *LiveTrigger4 = Unit::GetCreature(*me, LiveTriggerGUID[4]))
                     DoSummon(MOB_LIVE_RIDER, LiveTrigger4, 1);
                 break;
             }
         }
     }
     else
     {
         switch(entry)
         {
             case MOB_LIVE_TRAINEE:
             {
                 if (Creature *LiveTrigger0 = Unit::GetCreature(*me, LiveTriggerGUID[4]))
                     DoSummon(MOB_LIVE_TRAINEE, LiveTrigger0, 1);
                 if (Creature *LiveTrigger1 = Unit::GetCreature(*me, LiveTriggerGUID[4]))
                     DoSummon(MOB_LIVE_TRAINEE, LiveTrigger1, 1);
                 break;
             }
             case MOB_LIVE_KNIGHT:
             {
                 if (Creature *LiveTrigger5 = Unit::GetCreature(*me, LiveTriggerGUID[4]))
                     DoSummon(MOB_LIVE_KNIGHT, LiveTrigger5, 1);
                 break;
             }
             case MOB_LIVE_RIDER:
             {
                 if (Creature *LiveTrigger4 = Unit::GetCreature(*me, LiveTriggerGUID[4]))
                     DoSummon(MOB_LIVE_RIDER, LiveTrigger4, 1);
                 break;
             }
         }
     }
 }
Example #11
0
 void JustDied(Unit * /*killer*/)
 {
     if (pInstance && getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL)
     {
         if (Creature *pFaerlina = pInstance->instance->GetCreature(pInstance->GetData64(DATA_FAERLINA)))
             DoCast(pFaerlina, SPELL_WIDOWS_EMBRACE);
     }
 }
Example #12
0
        void EnterCombat(Unit * /*who*/) {
            _EnterCombat();
            DoScriptText(SAY_AGGRO, me);
            events.ScheduleEvent(EVENT_IMPALE, 10000 + rand() % 10000);
            events.ScheduleEvent(EVENT_LOCUST, 90000);
            events.ScheduleEvent(EVENT_BERSERK, 600000);

            if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL)
                events.ScheduleEvent(EVENT_SPAWN_GUARDIAN_NORMAL,
                        urand(15000, 20000));
        }
Example #13
0
 void JustDied(Unit * /*killer*/)
 {
     if (pInstance && getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL)
     {
         if (Creature *pFaerlina = pInstance->instance->GetCreature(pInstance->GetData64(DATA_FAERLINA)))
         {
             me->InterruptNonMeleeSpells(false);
             DoCast(pFaerlina, SPELL_WIDOWS_EMBRACE,true);
         }
     }
 }
Example #14
0
        void Reset()
        {
                    me->SetSpeed(MOVE_RUN, 1.5f);

                    m_uiStaggeringStompTimer = urand(13*IN_MILLISECONDS,15*IN_MILLISECONDS);
                    m_uiImpaleTimer = urand(30*IN_MILLISECONDS,35*IN_MILLISECONDS);
                    m_uiFireBombTimer = urand(30*IN_MILLISECONDS,40*IN_MILLISECONDS);
                    m_uiFireBombTriggerTimer = urand(10*IN_MILLISECONDS,18*IN_MILLISECONDS);
                    m_uiMaxSnobolds = RAID_MODE(4,5,4,5);
                    m_uiSnoboldsLaunched = 0;
                    m_uiSnoboldTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
                    m_bIsNextPhase = false;

                    if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
                    {
                            m_uiNextEncounterTimer = 180*IN_MILLISECONDS;
                    }

                    if (m_pInstance)
                            m_pInstance->SetData(PHASE_1, NOT_STARTED);
        }
Example #15
0
    void UpdateAI(const uint32 uiDiff)
    {
        if (!UpdateVictim())
            return;

        if (m_uiGrabTimer < uiDiff)
        {
            if(InVehicle == false)
            {
                if(Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1))
                {
                    pTarget->EnterVehicle(vehicle);
                    InVehicle = true;
                    DoCast(me, SPELL_WINGS_OF_THE_DAMNED);

                    if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
                    {
                        DoCast(pTarget, SPELL_LIFE_SIPHON);
                    }
                }
            }
            m_uiGrabTimer = 120000;
        } else m_uiGrabTimer -= uiDiff;

        if (m_uiMovementTimer < uiDiff)
        {
            me->GetMotionMaster()->MovePoint(0, ValkyrMoveMent);
            m_uiMovementTimer = 120000;
        } else m_uiMovementTimer -= uiDiff;

        if (m_uiFallPlayerTimer < uiDiff)
        {
            if(!OutVehicle)
            {
                vehicle->RemoveAllPassengers();
                OutVehicle = true;
            }
            m_uiFallPlayerTimer = 120000;
        } else m_uiFallPlayerTimer -= uiDiff;
    }
Example #16
0
 // summoning function for second phase
 void SummonWaveP2()
 {
     if (getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
     {
         uint8 addIndex = uiAddWaveCounter & 1;
         _SummonAdd(uiAddEntries[addIndex], addSpawnPos[addIndex*3]);
         _SummonAdd(uiAddEntries[addIndex ^ 1], addSpawnPos[addIndex*3+1]);
         _SummonAdd(uiAddEntries[addIndex], addSpawnPos[addIndex*3+2]);
     }
     else
         _SummonAdd(uiAddEntries[urand(0,1)], addSpawnPos[6]);
     ++uiAddWaveCounter;
 }
Example #17
0
		void EnterPhaseGround() {
			me->SetReactState(REACT_AGGRESSIVE);
			me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
			DoZoneInCombat();
			if (me->getThreatManager().isThreatListEmpty())
				EnterEvadeMode();
			else {
				events.ScheduleEvent(EVENT_BALCONY, 110000);
				events.ScheduleEvent(EVENT_CURSE, 10000 + rand() % 15000);
				events.ScheduleEvent(EVENT_WARRIOR, 30000);
				if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
					events.ScheduleEvent(EVENT_BLINK, 20000 + rand() % 20000);
			}
		}
        void Reset()
        {
            _Reset();

            if (Creature* Sentry = me->SummonCreature(NPC_SANCTUM_SENTRY, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
                Sentry->GetMotionMaster()->MoveFollow(me, 0.5, 1.5, MOTION_SLOT_ACTIVE);
            if (Creature* Sentry = me->SummonCreature(NPC_SANCTUM_SENTRY, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
                Sentry->GetMotionMaster()->MoveFollow(me, 0.5, -1.5, MOTION_SLOT_ACTIVE);

            if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
            {
                if (Creature* Sentry = me->SummonCreature(NPC_SANCTUM_SENTRY, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
                    Sentry->GetMotionMaster()->MoveFollow(me, -2.5, 1.5, MOTION_SLOT_ACTIVE);
                if (Creature* Sentry = me->SummonCreature(NPC_SANCTUM_SENTRY, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000))
                    Sentry->GetMotionMaster()->MoveFollow(me, -2.5, -1.5, MOTION_SLOT_ACTIVE);
            }
        }
    void Reset()
    {
		m_uiPhase = 1;
		m_uiSummonWaveTimer	= 15000;
		m_uiDeathandDecayTimer = 10000;
		m_uiIntroText = 0;
        m_uiIntroTextTimer = 12000;
		m_uiFrostBoltTimer = 15000;
		m_uiFrostValleyTimer = 5000;
		m_uiShadowBoltTimer = urand(5000,10000);
		m_uiDarkEmpoweredTimer	= 30000;

		if (!getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL)
		m_uiDominateMindTimer = 15000;

		if (m_pInstance)
            m_pInstance->SetData(DATA_DEATHWHISPER_EVENT, NOT_STARTED);
    }
Example #20
0
void sudokuBoard::obfuscateBoard() { 

  vector <int> options;
  for (int i=1; i<11; ++i) options.push_back(i); // 1 2 3 4 5 6 7 8 9 10
  int percent = 5;
  int curr_opt = 0;
  int count = 0;

  for (int i = 0; i<BOARDSIZE; i++) {
    for (int j = 0; j<BOARDSIZE; j++) {
      display_board[i][j] = current_board[i][j];
    }
  }

  switch( getDifficulty() ) {
    case (1): cout << "\n\033[1;32mNew Easy Puzzle\033[0m" << endl;
              percent = 6;
              break;
    case (2): cout << "\n\033[1;32mNew Medium Puzzle\033[0m" << endl;
              percent = 5;
              break;
    case (3): cout << "\n\033[1;32mNew Hard Puzzle\033[0m" << endl;
              percent = 4;
              break;
    case (4): cout << "\n\033[1;32mNew Expert Puzzle\033[0m" << endl;
              percent = 3;
              break;
    default: return;
  }          



  while (count < BOARDSIZE*BOARDSIZE) {
    random_shuffle ( options.begin(), options.end(), myrandom );
    curr_opt = options.back();
    if ( curr_opt > percent ) {
      display_board[count/BOARDSIZE][count%BOARDSIZE] = 0;
    }
    count++;
  }

  return; 
}
Example #21
0
        void Reset() {
            _Reset();

            hasTaunted = false;

            if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL) {
                Position pos;

                // respawn guard using home position,
                // otherwise, after a wipe, they respawn where boss was at wipe moment.
                pos = me->GetHomePosition();
                pos.m_positionY -= 10.0f;
                me->SummonCreature(MOB_CRYPT_GUARD, pos,
                        TEMPSUMMON_CORPSE_DESPAWN);

                pos = me->GetHomePosition();
                pos.m_positionY += 10.0f;
                me->SummonCreature(MOB_CRYPT_GUARD, pos,
                        TEMPSUMMON_CORPSE_DESPAWN);
            }
        }
Example #22
0
            void EnterCombat(Unit* who)
            {
                events.Reset();
                events.SetPhase(PHASE_ONE);
                // phase-independent events
                events.ScheduleEvent(EVENT_BERSERK, 600000);
                events.ScheduleEvent(EVENT_DEATH_AND_DECAY, 10000);
                // phase one only
                events.ScheduleEvent(EVENT_P1_SUMMON_WAVE, 5000, 0, PHASE_ONE);
                events.ScheduleEvent(EVENT_P1_SHADOW_BOLT, urand(5500, 6000), 0, PHASE_ONE);
                events.ScheduleEvent(EVENT_P1_EMPOWER_CULTIST, urand(20000, 30000), 0, PHASE_ONE);
                if (getDifficulty() != RAID_DIFFICULTY_10MAN_NORMAL)
                    events.ScheduleEvent(EVENT_DOMINATE_MIND_H, 27000);

                DoScriptText(SAY_AGGRO, me);
                DoStartNoMovement(who);
                me->RemoveAurasDueToSpell(SPELL_SHADOW_CHANNELING);
                DoCast(me, SPELL_MANA_BARRIER, true);

                instance->SetBossState(DATA_LADY_DEATHWHISPER, IN_PROGRESS);
            }
Example #23
0
 void DoGothikSummon(uint32 entry)
 {
     if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
     {
         switch(entry)
         {
             case MOB_LIVE_TRAINEE:
                 DoSummon(MOB_LIVE_TRAINEE, liveTrigger[0], 1);
                 DoSummon(MOB_LIVE_TRAINEE, liveTrigger[1], 1);
                 DoSummon(MOB_LIVE_TRAINEE, liveTrigger[2], 1);
                 break;
             case MOB_LIVE_KNIGHT:
                 DoSummon(MOB_LIVE_KNIGHT, liveTrigger[3], 1);
                 DoSummon(MOB_LIVE_KNIGHT, liveTrigger[5], 1);
                 break;
             case MOB_LIVE_RIDER:
                 DoSummon(MOB_LIVE_RIDER, liveTrigger[4], 1);
                 break;
         }
     }
     else
     {
         switch(entry)
         {
             case MOB_LIVE_TRAINEE:
                 DoSummon(MOB_LIVE_TRAINEE, liveTrigger[0], 1);
                 DoSummon(MOB_LIVE_TRAINEE, liveTrigger[1], 1);
                 break;
             case MOB_LIVE_KNIGHT:
                 DoSummon(MOB_LIVE_KNIGHT, liveTrigger[5], 1);
                 break;
             case MOB_LIVE_RIDER:
                 DoSummon(MOB_LIVE_RIDER, liveTrigger[4], 1);
                 break;
         }
     }
 }
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim() || !CheckInRoom())
                return;

            events.Update(diff);

            if (!thirtyPercentReached && HealthBelowPct(30) && phaseTwo)
            {
                thirtyPercentReached = true;
                if (instance)
                    instance->SetData(DATA_GOTHIK_GATE, GO_STATE_ACTIVE);
            }

            if (me->HasUnitState(UNIT_STAT_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch(eventId)
                {
                    case EVENT_SUMMON:
                        if (waves[waveCount].entry)
                        {
                            if ((waves[waveCount].mode == 2) && (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL))
                               DoGothikSummon(waves[waveCount].entry);
                            else if ((waves[waveCount].mode == 0) && (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL))
                                DoGothikSummon(waves[waveCount].entry);
                            else if (waves[waveCount].mode == 1)
                                DoGothikSummon(waves[waveCount].entry);

                            // if group is not splitted, open gate and merge both sides at ~ 2 minutes (wave 11)
                            if (waveCount == 11)
                            {
                                if (!CheckGroupSplitted())
                                {
                                    if (instance)
                                        instance->SetData(DATA_GOTHIK_GATE, GO_STATE_ACTIVE);
                                    summons.DoAction(0, 0);
                                    summons.DoZoneInCombat();
                                    mergedSides = true;
                                }
                            }

                            if (waves[waveCount].mode == 1)
                                events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
                            else if ((waves[waveCount].mode == 2) && (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL))
                                events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
                            else if ((waves[waveCount].mode == 0) && (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL))
                                events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
                            else
                                events.ScheduleEvent(EVENT_SUMMON, 0);

                            ++waveCount;
                        }
                        else
                        {
                            phaseTwo = true;
                            DoScriptText(SAY_TELEPORT, me);
                            DoTeleportTo(PosGroundLiveSide);
                            me->SetReactState(REACT_AGGRESSIVE);
                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
                            summons.DoAction(0, 0);
                            summons.DoZoneInCombat();
                            events.ScheduleEvent(EVENT_BOLT, 1000);
                            events.ScheduleEvent(EVENT_HARVEST, urand(3000, 15000));
                            events.ScheduleEvent(EVENT_TELEPORT, 20000);
                        }
                        break;
                    case EVENT_BOLT:
                        DoCast(me->getVictim(), RAID_MODE(SPELL_SHADOW_BOLT, H_SPELL_SHADOW_BOLT));
                        events.ScheduleEvent(EVENT_BOLT, 1000);
                        break;
                    case EVENT_HARVEST:
                        DoCast(me->getVictim(), SPELL_HARVEST_SOUL, true);
                        events.ScheduleEvent(EVENT_HARVEST, urand(20000, 25000));
                        break;
                    case EVENT_TELEPORT:
                        if (!thirtyPercentReached)
                        {
                            me->AttackStop();
                            if (IN_LIVE_SIDE(me))
                            {
                                DoTeleportTo(PosGroundDeadSide);
                            }
                            else
                            {
                                DoTeleportTo(PosGroundLiveSide);
                            }

                            me->getThreatManager().resetAggro(NotOnSameSide(me));
                            if (Unit *pTarget = SelectTarget(SELECT_TARGET_NEAREST, 0))
                            {
                                me->getThreatManager().addThreat(pTarget, 100.0f);
                                AttackStart(pTarget);
                            }

                            events.ScheduleEvent(EVENT_TELEPORT, 20000);
                        }
                        break;
                }
            }

            DoMeleeAttackIfReady();
        }
Example #25
0
void MenuManager::play() {
  bool keyCatch = false; // To get only 1 key per keydown
  SDL_Event event;
  bool done = false;

  // Here, we need to create an instance of the Manager,
  // the one that manages the game:
  Manager manager;
  manager.pause();

  while ( not done ) {

    drawBackground();
    menu.draw();
    SDL_Flip(screen);

    SDL_PollEvent(&event);
    if (event.type ==  SDL_QUIT) { break; }
    if(event.type == SDL_KEYDOWN) {
      switch ( event.key.keysym.sym ) {
        case SDLK_ESCAPE :
        case SDLK_q : {
          done = true;
          break;
        }
        case SDLK_RETURN : {
          if ( !keyCatch ) {
            menu.lightOn();
            if ( menu.getIconClicked() == "Start Game" ) {
              // Here is where we call the play() function in Manager:
              std::cout << "Starting game ..." << std::endl;
               Manager manager;
               manager.setDifficulty(difficulty);
               manager.unpause();
               manager.play();
               manager.pause();
            }
            if ( menu.getIconClicked() == "Difficulty" ) {
              getDifficulty();
              // After we get the number, we must pass it to Manager:
              std::cout<<difficulty<<std::endl;
              manager.setDifficulty(difficulty);
            }
            if ( menu.getIconClicked() == "Help" ) {
              // Here is where we explain how to play the game"
              std::cout << "Give help  ..." << std::endl;
              getHelp();
            }
            if ( menu.getIconClicked() == "Exit" ) {
              drawBackground();
              menu.draw();
              SDL_Flip(screen);
              SDL_Delay(250);
              done = true;
            }
          }
          break;
        }
        case SDLK_DOWN   : {
          if ( !keyCatch ) {
            menu.increment();
          }
          break;
        }
        case SDLK_UP   : {
          if ( !keyCatch ) {
            menu.decrement();
          }
          break;
        }
        default          : break;
      }
      keyCatch = true;
    }
    if(event.type == SDL_KEYUP) {
      keyCatch = false;
      menu.lightOff();
    }
  }
}
    void UpdateAI(const uint32 uiDiff)
    {
		if (m_uiIntroText == 1 || m_uiIntroText == 2 || 
			m_uiIntroText == 3 || m_uiIntroText == 4 ||
			m_uiIntroText == 5 || m_uiIntroText == 6)
			{
			if (m_uiIntroTextTimer < uiDiff)
            {
                switch(m_uiIntroText)
                {
                    case 1: DoScriptText(SAY_INTRO_2, me); break;
                    case 2: DoScriptText(SAY_INTRO_3, me); break;
					case 3: DoScriptText(SAY_INTRO_4, me); break;
					case 4: DoScriptText(SAY_INTRO_5, me); break;
					case 5: DoScriptText(SAY_INTRO_6, me); break;
					case 6: DoScriptText(SAY_INTRO_7, me); break;
                }
                m_uiIntroText++;
                m_uiIntroTextTimer = 10500;
            }
            else m_uiIntroTextTimer -= uiDiff;
        }

        if (!UpdateVictim())
            return;

		if (m_uiPhase == 1)
        {
			if (m_uiShadowBoltTimer < uiDiff)
            {
				Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM);
				DoCast(pTarget, SPELL_SHADOW_BOLT);
				m_uiShadowBoltTimer = urand(5000,10000);
            }
			else m_uiShadowBoltTimer -= uiDiff;

			if (m_uiDarkEmpoweredTimer < uiDiff)
            {
				DoScriptText(SAY_EMPOWERMENT, me);
				switch(rand() % 2)
				{
					case 0: AdherentList(me); break;
					case 1: FanaticList(me); break;
				}
				m_uiDarkEmpoweredTimer = urand(25000,30000);
            }
            else m_uiDarkEmpoweredTimer -= uiDiff;

			if (m_uiSummonWaveTimer < uiDiff)
			{
				for (uint8 i = 0; i < RAID_MODE(3,6,3,6); ++i)
				{
					me->SummonCreature(RAND(NPC_CULT_FANATIC, NPC_CULT_ADHERENT), SpawnLoc[i][0], SpawnLoc [i][1], SpawnLoc[i][2],0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);
				}
				m_uiSummonWaveTimer = 60000;
            }
            else m_uiSummonWaveTimer -= uiDiff;

			if (!me->HasAura(SPELL_MANA_BARRIER))
                DoCast(me, SPELL_MANA_BARRIER);
			if (!me->HasAura(SPELL_ROOT))
                DoCast(me, SPELL_ROOT);

			if (m_uiPhase == 1 || m_uiPhase == 2)
			{
			if (m_uiDominateMindTimer < uiDiff)
            {
				uint32 count = RAID_MODE(0,1,1,3);
                for (uint8 i = 1; i <= count; i++)
                {
					Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 200, true);
					if (pTarget && !pTarget->isCharmed())
					{
						DoCast(pTarget, SPELL_DOMINATE_MIND);
					}
				}
				m_uiDominateMindTimer = urand(15000,30000);
            }
            else m_uiDominateMindTimer -= uiDiff;

			if (m_uiDeathandDecayTimer < uiDiff)
            {
				Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM);
				DoCast(pTarget, SPELL_DEATH_AND_DECAY);
				m_uiDeathandDecayTimer = urand(10000,12000);
            }
            else m_uiDeathandDecayTimer -= uiDiff;

			if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
			if (m_uiSummonWaveTimer < uiDiff)
            {
                for (uint8 i = 0; i < RAID_MODE(3,3,3,3); ++i)
				{
					me->SummonCreature(RAND(NPC_CULT_FANATIC, NPC_CULT_ADHERENT), HeroicSpawnLoc[i][0], HeroicSpawnLoc [i][1], HeroicSpawnLoc[i][2],0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);
				}
                m_uiSummonWaveTimer = 60000;
            }
            else m_uiSummonWaveTimer -= uiDiff;
		}

			if ((me->GetPower(POWER_MANA)*100 / me->GetMaxPower(POWER_MANA)) < 1)
			{
				DoScriptText(SAY_PHASE_2, me);
                m_uiPhase = 2;
            }
		}

		if (m_uiPhase == 2)
        {
            if (me->HasAura(SPELL_MANA_BARRIER))
                me->RemoveAurasDueToSpell(SPELL_MANA_BARRIER);

			if (me->HasAura(SPELL_ROOT))
                me->RemoveAurasDueToSpell(SPELL_ROOT);

			if (m_uiFrostBoltTimer < uiDiff)
            {
				DoCast(me->getVictim(), SPELL_FROST_BOLT);
				m_uiFrostBoltTimer = urand(5000,10000);
            }
            else m_uiFrostBoltTimer -= uiDiff;

			if (m_uiFrostValleyTimer < uiDiff)
            {
				DoCastAOE(SPELL_FROST_BOLT_VALLEY);
				m_uiFrostValleyTimer = urand(30000,35000);
            }
            else m_uiFrostValleyTimer -= uiDiff;

			DoMeleeAttackIfReady();
		}
	}
         void SummonChampions()
    {
        Map::PlayerList const &players = pInstance->instance->GetPlayers();
        uint32 TeamInInstance = 0;
                Difficulty diffic = getDifficulty();

        uint8 team = (mPlayerTeam==ALLIANCE) ? 1 : 0;
        uint8 coordsIdx = 0;
        uint8 guidIdx = 0;
        uint8 entryIdx = 0;
        uint8 r = RAID_MODE(2,4);
        uint8 hm = RAID_MODE(2,3);

        //Ranged
        entryIdx = mRChampRnd1;
        for(coordsIdx=0; coordsIdx < r; ++coordsIdx)
        {
            if(Unit *champ = me->SummonCreature(ChampRanged[team][entryIdx],
                ChampSpawnLocs[team][coordsIdx][0],
                ChampSpawnLocs[team][coordsIdx][1],
                ChampSpawnLocs[team][coordsIdx][2],
                ChampSpawnLocs[team][coordsIdx][3],
                TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
            {
                mChampionsGUID[guidIdx++] = champ->GetGUID();
            }
            entryIdx = (entryIdx + mRChampRnd2) % 5;
        }
        //Healers
        entryIdx = mHChampRnd1;
        for(coordsIdx=4; coordsIdx < hm+4; ++coordsIdx)
        {
            if(Unit *champ = me->SummonCreature(ChampHealers[team][entryIdx],
                ChampSpawnLocs[team][coordsIdx][0],
                ChampSpawnLocs[team][coordsIdx][1],
                ChampSpawnLocs[team][coordsIdx][2],
                ChampSpawnLocs[team][coordsIdx][3],
                TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
            {
                mChampionsGUID[guidIdx++] = champ->GetGUID();
            }
            entryIdx = (entryIdx + mHChampRnd2) % 4;
        }
        //Melee
        entryIdx = mMChampRnd1;
        for(coordsIdx=7; coordsIdx < hm+7; ++coordsIdx)
        {
            if(Unit *champ = me->SummonCreature(ChampMelee[team][entryIdx],
                ChampSpawnLocs[team][coordsIdx][0],
                ChampSpawnLocs[team][coordsIdx][1],
                ChampSpawnLocs[team][coordsIdx][2],
                ChampSpawnLocs[team][coordsIdx][3],
                TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
            {
                mChampionsGUID[guidIdx++] = champ->GetGUID();
            }
            entryIdx = (entryIdx + mMChampRnd2) % 5;
        }

        mChampionsDead = 0;
    }
Example #28
0
    void UpdateAI(const uint32 uiDiff)
    {
        if(!UpdateVictim())
            return;

        if (m_uiResetTimer <= uiDiff)
        {
            if (me->GetDistance2d(me->GetHomePosition().GetPositionX(), me->GetHomePosition().GetPositionY()) > 80)
                EnterEvadeMode();
            m_uiResetTimer = 5000;
        } else m_uiResetTimer -= uiDiff;

        if(TransitionPhase3 == false)
        {
            if (m_uiRandomSpeechTimer < uiDiff)
            {
                DoScriptText(SAY_RANDOM, me);
                m_uiRandomSpeechTimer = 33000;
            } else m_uiRandomSpeechTimer -= uiDiff;
        }

        if (m_uiBerserkTimer < uiDiff)
        {
            DoScriptText(SAY_BERSERK, me);
            DoCast(me, SPELL_BERSERK);
            m_uiBerserkTimer = 900000;
        }
        else m_uiBerserkTimer -= uiDiff;

        if(m_uiPhase == 1)
        {
            if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
            {
                if (m_uiSummonShadowTrap < uiDiff)
                {
                    Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                    DoCast(pTarget, SPELL_SUMMON_SHADOW_TRAP);
                    m_uiSummonShadowTrap = 30000;
                } else m_uiSummonShadowTrap -= uiDiff;
            }

            if (m_uiInfestTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_INFEST);
                m_uiInfestTimer = 30000;
            } else m_uiInfestTimer -= uiDiff;

            if (m_uiPlagueSiphonTimer < uiDiff)
            {
                DoCast(me, SPELL_PLAGUE_SIPHON);
                m_uiPlagueSiphonTimer = 30000;
            } else m_uiPlagueSiphonTimer -= uiDiff;

            if (m_uiSummonDrudgeGhoulsTimer < uiDiff)
            {
                DoCast(SPELL_SUMMON_DRUDGE_GHOULS);
                m_uiSummonDrudgeGhoulsTimer = 20000;
            } else m_uiSummonDrudgeGhoulsTimer -= uiDiff;

            if (m_uiSummonShamblingHorrorTimer < uiDiff)
            {
                DoCast(me, SPELL_SUMMON_SHAMBLING_HORROR);
                m_uiSummonShamblingHorrorTimer = 40000;
            } else m_uiSummonShamblingHorrorTimer -= uiDiff;

            if (m_uiNecroticPlagueTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_NECROTIC_PLAGUE);
                m_uiNecroticPlagueTimer = 5000;
            } else m_uiNecroticPlagueTimer -= uiDiff;
        }

        if(TransitionPhase1 == true)
        {
            if (m_uiRemorselesWinterTimer < uiDiff)
            {
                DoScriptText(SAY_REMORSELESS_WINTER, me);
                DoCast(me, SPELL_REMORSELES_WINTER);
                m_uiRemorselesWinterTimer = 90000;
            } else m_uiRemorselesWinterTimer -= uiDiff;

            if (m_uiSummonSpiritTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_SUMMON_RAGING_SPIRIT);
                m_uiSummonSpiritTimer    = 16000;
            } else m_uiSummonSpiritTimer -= uiDiff;

            if (m_uiIcePulsSummonTimer < uiDiff)
            {
                DoCast(SPELL_SUMMON_ICE_SPEHERE);
                m_uiIcePulsSummonTimer    = 15000;
            } else m_uiIcePulsSummonTimer -= uiDiff;

            if (m_uiPainandSufferingTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
                DoCast(pTarget, SPELL_PAIN_AND_SUFFERING);
                m_uiPainandSufferingTimer = 2000;
            } else m_uiPainandSufferingTimer -= uiDiff;

            if (m_uiQuakeTimer < uiDiff)
            {
                DoScriptText(SAY_BROKEN_ARENA, me);
                DoCast(SPELL_QUAKE);
                me->SetReactState(REACT_AGGRESSIVE);
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveChase(me->getVictim());
                m_uiPhase = 2;
                TransitionPhase1 = false;

            } else m_uiQuakeTimer -= uiDiff;
        }

        if(m_uiPhase == 2)
        {
            if (m_uiDefileTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_SPAWN_DEFILE);
                m_uiDefileTimer = 20000;
            } else m_uiDefileTimer -= uiDiff;

            if (m_uiSummonValkyrTimer < uiDiff)
            {
                DoScriptText(SAY_SUMMON_VALKYR, me);
                DoCast(me, SPELL_SUMMON_VALKYR);
                m_uiSummonValkyrTimer = 20000;
            } else m_uiSummonValkyrTimer -= uiDiff;

            if (m_uiSoulReaperTimer < uiDiff)
            {
                DoCast(me->getVictim(), SPELL_SOUL_REAPER);
                m_uiSoulReaperTimer = 20000;
            } else m_uiSoulReaperTimer -= uiDiff;

            if (m_uiInfestTimer < uiDiff)
            {
                DoCast(me, SPELL_INFEST);
                m_uiInfestTimer = 30000;
            } else m_uiInfestTimer -= uiDiff;
        }

        if(TransitionPhase2 = true)
        {
            if (m_uiRemorselesWinterTimer < uiDiff)
            {
                DoScriptText(SAY_REMORSELESS_WINTER, me);
                DoCast(me, SPELL_REMORSELES_WINTER);
                m_uiRemorselesWinterTimer = 90000;
            } else m_uiRemorselesWinterTimer -= uiDiff;

            if (m_uiSummonSpiritTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_SUMMON_RAGING_SPIRIT);
                m_uiSummonSpiritTimer = 16000;
            } else m_uiSummonSpiritTimer -= uiDiff;

            if (m_uiIcePulsSummonTimer < uiDiff)
            {
                DoCast(me, SPELL_SUMMON_ICE_SPEHERE);
                m_uiIcePulsSummonTimer    = 15000;
            } else m_uiIcePulsSummonTimer -= uiDiff;

            if (m_uiPainandSufferingTimer < uiDiff)
            {
                Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
                DoCast(pTarget, SPELL_PAIN_AND_SUFFERING);
                m_uiPainandSufferingTimer = 3000;
            } else m_uiPainandSufferingTimer -= uiDiff;

            if (m_uiQuakeTimer < uiDiff)
            {
                DoScriptText(SAY_BROKEN_ARENA, me);
                DoCast(me, SPELL_QUAKE);
                me->SetReactState(REACT_AGGRESSIVE);
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveChase(me->getVictim());
                m_uiPhase = 3;
                TransitionPhase2 = false;
            } else m_uiQuakeTimer -= uiDiff;
        }

        if(m_uiPhase == 3)
        {
            if (m_uiSummonVileSpiritTimer < uiDiff)
            {
                DoCast(me, SPELL_SUMMON_VILE_SPIRIT);
                m_uiSummonVileSpiritTimer = 30000;
            } else m_uiSummonVileSpiritTimer -= uiDiff;

            if (m_uiHarvestSoulTimer < uiDiff)
            {
                DoScriptText(SAY_HARVEST_SOUL, me);
                Unit* pTarget = SelectUnit(SELECT_TARGET_TOPAGGRO, 0);
                DoCast(pTarget, SPELL_HARVEST_SOULS);
                m_uiHarvestSoulTimer = 70000;
            } else m_uiHarvestSoulTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();

        if (m_uiEndingTimer <= uiDiff)
            EndingPhase();
        else m_uiEndingTimer -= uiDiff;

        if(me->GetHealth()*100 / me->GetMaxHealth() < 70)
        {
            if(TransitionPhase1 = false)
            {
                TransitionPhase1 = true;
                Phasenswitch();
            }
        }

        if(me->GetHealth()*100 / me->GetMaxHealth() < 40)
        {
            if(TransitionPhase2 = false)
            {
                m_uiPhase = 3;
                m_uiRemorselesWinterTimer = 5000;
                m_uiQuakeTimer = 70000;
                m_uiIcePulsSummonTimer    = 10000;
                m_uiPainandSufferingTimer = 10000;
                m_uiSummonSpiritTimer = 18000;
                Phasenswitch();
                TransitionPhase2 = true;
            }
        }

        if(me->GetHealth()*100 / me->GetMaxHealth() < 11)
        {
            if(!TriggerSpawned)
            {
                pSafeZone = me->SummonCreature(CREATURE_TRIGGER, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN, 360000);
                pSafeZone->AI()->AttackStart(me);
                pSafeZone->SetDisplayId(MODEL_INVISIBLE);
                TriggerSpawned = true;
        }   }

        if(me->GetHealth()*100 / me->GetMaxHealth() < 10)
        {
            if(TransitionPhase3 = false)
            {
                TransitionPhase3 = true;
                SetEnding();
            }
        }
    }
Example #29
0
// This function does boundary checking on the ball, also determines where
// it hits the paddle, and changes the behavior of the ball depending.
void checkBallCollisions(int paddlePos)
{    
    // first check for any brick collisions
    char detected = drawBricks(&ball);
    
    // if no bricks hit, continue with normal collision detection
    if(detected == 'n')
    {
        // right wall
        if(ball.x >= SCREEN_WIDTH - BALL_RADIUS)
        {
            ball.x = SCREEN_WIDTH - (BALL_RADIUS + 1);
            xdir = -xdir;
            playTone(500, 50);
            return;
        }
        // left wall
        if(ball.x <= BALL_RADIUS)
        {
            ball.x = BALL_RADIUS + 1;
            xdir = -xdir;
            playTone(500, 50);
            return;
        }
        // ceiling
        if(ball.y >= SCREEN_HEIGHT - BALL_RADIUS)
        {
            ydir = -1.0;
            playTone(500, 50);
            return;
        }
        // middle of paddle
        if(ball.y <= 19 && (ball.x <= paddlePos + (PADDLE_WIDTH / 2) + (BALL_RADIUS + 1) &&
                            ball.x >= paddlePos + (PADDLE_WIDTH / 2) - (BALL_RADIUS + 1)))
        {
            paddleHits++;
            // increase ball speed slightly with every 6 paddle hits
            if((paddleHits % 18 == 0) && (paddleHits <= 36))
                speed += 1.0;
            
            ball.y = 20;
            ydir = 1.0;
            playTone(500,50);
            return;
        }
        // right side of paddle
        else if(ball.y <= 19 && ((ball.x <= paddlePos + PADDLE_WIDTH) &&
                                 (ball.x > paddlePos + (PADDLE_WIDTH / 2) + (BALL_RADIUS + 1))))
        {
            paddleHits++;
            // increase ball speed slightly with every 6 paddle hits
            if((paddleHits % 18 == 0) && (paddleHits <= 36))
                speed += 1.0;
            
            ball.y = 20;
            ydir = 1.0;
            xdir += 1.0;
            playTone(500, 50);
            return;
        }
        // left side of paddle
        else if(ball.y <= 19 && ((ball.x >= paddlePos) &&
                                 (ball.x < paddlePos + (PADDLE_WIDTH / 2) - (BALL_RADIUS + 1))))
        {
            paddleHits++;
            // increase ball speed slightly with every 6 paddle hits
            if((paddleHits % 18 == 0) && (paddleHits <= 36))
                speed += 1.0;
            
            ball.y = 20;
            ydir = 1.0;
            xdir -= 1.0;
            playTone(500, 50);
            return;
        }
        // ball hits floor, lives lost, score deducted
        if(ball.y <= 10 && ((ball.x < paddlePos) || (ball.x > paddlePos + PADDLE_WIDTH)))
        {
            playTone(50,500);
            tft.fillCircle(ball.y, ball.x, BALL_RADIUS, ST7735_BLACK);
            drawPaddle();
            initializeBall(getDifficulty());
            decreaseLives();
            displayStats();
            delay(20);
        }
    }
    // brick collision detected, adjust ball accordingly
    else
    {
        // corner of brick hit
        if(detected == 'c')
        {
            xdir = -xdir;
            ydir = -ydir;
            playTone(200,50);
            return;
        }
        else
        {
            // left/right side of brick hit
            if(detected == 'x')
            {
                xdir = -xdir;
                playTone(200,50);
                return;
            }
            // top/bottom of brick hit  
            else if(detected == 'y')
            {
                ydir = -ydir;
                playTone(200,50);
                return;
            }
        }
    }
}
Example #30
0
    void UpdateAI(const uint32 diff)
    {
        if (!UpdateCombatState())
            return;

        events.Update(diff);

        if (Phase == 1)
        {
            while(uint32 eventId = events.GetEvent())
            {
                switch (eventId)
                {
                    case EVENT_WASTE:
                        DoSummon(NPC_WASTE, Pos[RAND(0,3,6,9)]);
                        events.RepeatEvent(urand(2000,5000));
                        break;
                    case EVENT_ABOMIN:
                        if (nAbomination < 8)
                        {
                            DoSummon(NPC_ABOMINATION, Pos[RAND(1,4,7,10)]);
                            nAbomination++;
                            events.RepeatEvent(20000);
                        }
                        else
                            events.PopEvent();
                        break;
                    case EVENT_WEAVER:
                        if (nWeaver < 8)
                        {
                            DoSummon(NPC_WEAVER, Pos[RAND(0,3,6,9)]);
                            nWeaver++;
                            events.RepeatEvent(25000);
                        }
                        else
                            events.PopEvent();
                        break;
                    case EVENT_TRIGGER:
                        if (GameObject *pKTTrigger = m_creature->GetMap()->GetGameObject(KTTriggerGUID))    
                            pKTTrigger->SetPhaseMask(2, true);
                        events.PopEvent();
                        break;
                    case EVENT_PHASE:
                        events.Reset();
                        DoScriptText(RAND(SAY_AGGRO_1,SAY_AGGRO_2,SAY_AGGRO_3), me);
                        spawns.DespawnAll();
                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_NOT_SELECTABLE);
                        me->CastStop();

                        DoStartMovement(me->getVictim());
                        events.ScheduleEvent(EVENT_BOLT, urand(5000,10000));
                        events.ScheduleEvent(EVENT_NOVA, 15000);
                        events.ScheduleEvent(EVENT_DETONATE, urand(30000,40000));
                        events.ScheduleEvent(EVENT_FISSURE, urand(10000,30000));
                        events.ScheduleEvent(EVENT_BLAST, urand(60000,120000));
                        if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
                            events.ScheduleEvent(EVENT_CHAIN, urand(30000,60000));
                        Phase = 2;
                        break;
                    default:
                        events.PopEvent();
                        break;
                }
            }
        }
        else
        {
            //start phase 3 when we are 45% health
            if (Phase != 3)
            {
                if (HealthBelowPct(45))
                {
                    Phase = 3 ;
                    DoScriptText(SAY_REQUEST_AID, m_creature);
                    //here Lich King should respond to KelThuzad but I don't know which Creature to make talk
                    //so for now just make Kelthuzad says it.
                    DoScriptText(SAY_ANSWER_REQUEST, m_creature);

                    for (uint8 i = 0; i <= 3; ++i)
                    {
                        if (GameObject *pPortal = m_creature->GetMap()->GetGameObject(PortalsGUID[i]))
                        {
                            if (pPortal->getLootState() == GO_READY)
                                pPortal->UseDoorOrButton();
                        }
                    }
                }
            }
            else if (nGuardiansOfIcecrownCount < RAID_MODE(2,4))
            {
                if (uiGuardiansOfIcecrownTimer <= diff)
                {
                    // TODO : Add missing text
                    if (Creature* pGuardian = DoSummon(NPC_ICECROWN, Pos[RAND(2,5,8,11)]))
                        pGuardian->SetFloatValue(UNIT_FIELD_COMBATREACH, 2);
                    ++nGuardiansOfIcecrownCount;
                    uiGuardiansOfIcecrownTimer = 5000;
                }
                else uiGuardiansOfIcecrownTimer -= diff;
            }

            if (me->hasUnitState(UNIT_STAT_CASTING))
                return;

            if (uint32 eventId = events.GetEvent())
            {
                switch (eventId)
                {
                    case EVENT_BOLT:
                        DoCastVictim(RAID_MODE(SPELL_FROST_BOLT,H_SPELL_FROST_BOLT));
                        events.RepeatEvent(urand(5000,10000));
                        break;
                    case EVENT_NOVA:
                        DoCastAOE(RAID_MODE(SPELL_FROST_BOLT_AOE,H_SPELL_FROST_BOLT_AOE));
                        events.RepeatEvent(urand(15000,30000));
                        break;
                    case EVENT_CHAIN:
                    {
                        uint32 count = urand(1,3);
                        for (uint8 i = 1; i <= count; i++)
                        {
                            Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 200, true);
                            if (pTarget && !pTarget->isCharmed() && (chained.find(pTarget->GetGUID()) == chained.end()))
                            {
                                DoCast(pTarget, SPELL_CHAINS_OF_KELTHUZAD);
                                float scale = pTarget->GetFloatValue(OBJECT_FIELD_SCALE_X);
                                chained.insert(std::make_pair(pTarget->GetGUID(), scale));
                                pTarget->SetFloatValue(OBJECT_FIELD_SCALE_X, scale * 2);
                                events.ScheduleEvent(EVENT_CHAINED_SPELL, 2000); //core has 2000ms to set unit flag charm
                            }
                        }
                        if (!chained.empty())
                            DoScriptText(RAND(SAY_CHAIN_1,SAY_CHAIN_2), me);
                        events.RepeatEvent(urand(100000,180000));
                        break;
                    }
                    case EVENT_CHAINED_SPELL:
                    {
                        std::map<uint64, float>::iterator itr;
                        for (itr = chained.begin(); itr != chained.end();)
                        {
                            if (Unit* player = Unit::GetPlayer((*itr).first))
                            {
                                if (!player->isCharmed())
                                {
                                    player->SetFloatValue(OBJECT_FIELD_SCALE_X, (*itr).second);
                                    std::map<uint64, float>::iterator next = itr;
                                    ++next;
                                    chained.erase(itr);
                                    itr = next;
                                    continue;
                                }

                                if (Unit *pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO, 0, NotCharmedTargetSelector()))
                                {
                                    switch(player->getClass())
                                    {
                                        case CLASS_DRUID:
                                            if (urand(0,1))
                                                player->CastSpell(pTarget, SPELL_MOONFIRE, false);
                                            else
                                                player->CastSpell(m_creature, SPELL_LIFEBLOOM, false);
                                            break;
                                        case CLASS_HUNTER:
                                            player->CastSpell(pTarget, RAND(SPELL_MULTI_SHOT, SPELL_VOLLEY), false);
                                            break;
                                        case CLASS_MAGE:
                                            player->CastSpell(pTarget, RAND(SPELL_FROST_FIREBOLT, SPELL_ARCANE_MISSILES), false);
                                            break;
                                        case CLASS_WARLOCK:
                                            player->CastSpell(pTarget, RAND(SPELL_CURSE_OF_AGONY, SPELL_SHADOW_BOLT), true);
                                            break;
                                        case CLASS_WARRIOR:
                                            player->CastSpell(pTarget, RAND(SPELL_BLADESTORM, SPELL_CLEAVE), false);
                                            break;
                                        case CLASS_PALADIN:
                                            if (urand(0,1))
                                                player->CastSpell(pTarget, SPELL_HAMMER_OF_JUSTICE, false);
                                            else
                                                player->CastSpell(m_creature, SPELL_HOLY_SHOCK, false);
                                            break;
                                        case CLASS_PRIEST:
                                            if (urand(0,1))
                                                player->CastSpell(pTarget, SPELL_VAMPIRIC_TOUCH, false);
                                            else
                                                player->CastSpell(m_creature, SPELL_RENEW, false);
                                            break;
                                        case CLASS_SHAMAN:
                                            if (urand(0,1))
                                                player->CastSpell(pTarget, SPELL_EARTH_SHOCK, false);
                                            else
                                                player->CastSpell(m_creature, SPELL_HEALING_WAVE, false);
                                            break;
                                        case CLASS_ROGUE:
                                            player->CastSpell(pTarget, RAND(SPELL_HEMORRHAGE, SPELL_MUTILATE), false);
                                            break;
                                        case CLASS_DEATH_KNIGHT:
                                            if (urand(0,1))
                                                player->CastSpell(pTarget, SPELL_PLAGUE_STRIKE, true);
                                            else
                                                player->CastSpell(pTarget, SPELL_HOWLING_BLAST, true);
                                            break;
                                    }
                                }
                            }
                            itr++;
                        }

                        if (chained.empty())
                            events.PopEvent();
                        else
                            events.RepeatEvent(5000);

                        break;
                    }
                    case EVENT_DETONATE:
                    {
                        std::vector<Unit*> unitList;
                        std::list<HostileReference*> *threatList = &me->getThreatManager().getThreatList();
                        for (std::list<HostileReference*>::const_iterator itr = threatList->begin(); itr != threatList->end(); ++itr)
                        {
                            if ((*itr)->getTarget()->GetTypeId() == TYPEID_PLAYER
                                && (*itr)->getTarget()->getPowerType() == POWER_MANA
                                && (*itr)->getTarget()->GetPower(POWER_MANA))
                                unitList.push_back((*itr)->getTarget());
                        }

                        if (!unitList.empty())
                        {
                            std::vector<Unit*>::iterator itr = unitList.begin();
                            advance(itr, rand()%unitList.size());
                            DoCast(*itr, SPELL_MANA_DETONATION);
                            DoScriptText(RAND(SAY_SPECIAL_1,SAY_SPECIAL_2,SAY_SPECIAL_3), me);
                        }

                        events.RepeatEvent(urand(20000,50000));
                        break;
                    }
                    case EVENT_FISSURE:
                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                            DoCast(pTarget, SPELL_SHADOW_FISURE);
                        events.RepeatEvent(urand(10000,45000));
                        break;
                    case EVENT_BLAST:
                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, RAID_MODE(1,0), 0, true))
                            DoCast(pTarget, SPELL_FROST_BLAST);
                        if (rand()%2)
                            DoScriptText(SAY_FROST_BLAST, m_creature);
                        events.RepeatEvent(urand(30000,90000));
                        break;
                    default:
                        events.PopEvent();
                        break;
                }
            }

            DoMeleeAttackIfReady();
        }
    }