[C++]-Opakovač Eventů

[Paran 6]

Zdravím,

 

nascriptoval jsem si svého custom c++ bosse,který funguje ,tak jak by fungovat měl,ale má to jednu mouchu.On vycástí všechny eventy jenom 1x,což znamená ,že se neopakují.Nemůžu najít ten opakovač.Poradil by mi někdo ?

 

 

C++ Custom Boss Radeon

 

 

#include "SpellScript.h"
#include "Map.h"
#include "ScriptedCreature.h"

enum Texts 
{
   T_COMBAT                  = 0,
   T_FAZE                    = 1,
   T_BERSERK                 = 2,
   T_EVADE                   = 3,
   T_DEAD                    = 4,
//    T_FAZE_2                  = 6,
};

enum Spells
{
   FIRE_BLAST                = 2136,    // raging spirits also get it
   FROST_BOLT                = 116,
   MOLTEN_ARMOR              = 30482,
   BLAST_WAVE                = 11113,
   COUNTER_SPELL             = 2139,
   ICE_LANCE                 = 30455,
   ICE_BARRIER               = 98864,
   FIRE_BALL                 = 133,
   BERSERK                   = 28498,
   FROST_ARMOR               = 7302, 
};

enum Events
{
   EVENT_FIRE_BLAST          = 1,
   EVENT_FROST_BOLT          = 2,
   EVENT_BLAST_WAVE          = 3,
   EVENT_COUNTER_SPELL       = 9,
   EVENT_ICE_LANCE           = 4,
   EVENT_ICE_BARRIER         = 5,
   EVENT_FIRE_BALL           = 6,
   EVENT_BERSERK             = 7,
   EVENT_START               = 8,
};

enum MovePoints
{                      
   POINT_FAZE_1              = 1,
//    POINT_FAZE_2              = 2,
};                     

enum Phases
{
   START                     = 1,
   FAZE_1                    = 2,
//    FAZE_2                    = 4,
   START_MASK                = 1 << START,
   FAZE_MASK_1               = 1 << FAZE_1,
//    FAZE_MASK_2               = 1 << FAZE_2,    
};

class boss_radeon : public CreatureScript
{
   public:
       boss_radeon() : CreatureScript("boss_radeon") { }

       struct boss_radeonAI : public ScriptedAI
       {
           boss_radeonAI(Creature* creature) : ScriptedAI(creature)
           {
           }                        

           void Reset()
           {
           }

           void EnterCombat(Unit* target)
           {
               Talk(T_COMBAT);
               DoCast(me, MOLTEN_ARMOR);
               events.SetPhase(START);
               events.ScheduleEvent(EVENT_FIRE_BALL, 5000, 0, START);
               events.ScheduleEvent(EVENT_FIRE_BLAST, 8000, 0, START);
               events.ScheduleEvent(EVENT_BLAST_WAVE, 15000, 0, START);
               events.ScheduleEvent(EVENT_COUNTER_SPELL, 20000, 0, START);
           }

           void DoAction(int32 const action)
           {
               switch (action)
               {
                   case POINT_FAZE_1:
                       Talk(T_FAZE);
                       me->RemoveAurasDueToSpell(MOLTEN_ARMOR);
                       DoCast(me, FROST_ARMOR);
                       events.SetPhase(FAZE_1);                        
                       events.ScheduleEvent(EVENT_FROST_BOLT, 5000, 0, FAZE_1);
                       events.ScheduleEvent(EVENT_COUNTER_SPELL, 20000, 0, FAZE_1);
                       events.ScheduleEvent(EVENT_ICE_LANCE, 8000, 0, FAZE_1);
                       events.ScheduleEvent(EVENT_ICE_BARRIER, 30000, 0, FAZE_1);
                       events.ScheduleEvent(EVENT_BERSERK, 120000, 0, FAZE_1);                                                
                       break;
                   default:
                       break;
               }
           }

           void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/)
           {
             if (events.GetPhaseMask() & START_MASK && HealthBelowPct(45))
             {
                DoAction(POINT_FAZE_1);
             }
           }

           void EnterEvadeMode()
           {
               Talk(T_EVADE);
           }

           void JustDied()
           {
               Talk(T_DEAD);
           }                                    

           Unit* SelectEnemyCaster(bool /*casting*/)
           {
                std::list<HostileReference*> const& tList = me->getThreatManager().getThreatList();
                std::list<HostileReference*>::const_iterator iter;
                Unit* target;

           for (iter = tList.begin(); iter!=tList.end(); ++iter)
           {
               target = Unit::GetUnit((*me), (*iter)->getUnitGuid());
               if (target && target->getPowerType() == POWER_MANA)

               return target;
           }
               return NULL;
           }

           void UpdateAI(uint32 const diff)
           {
               events.Update(diff);                

               while (uint32 eventId = events.ExecuteEvent())
               {
                   switch (eventId)
                   {
                       case EVENT_FIRE_BLAST:
                           DoCastAOE(FIRE_BLAST);                            
                           break;
                       case EVENT_FROST_BOLT:
                           DoCastAOE(FROST_BOLT);                            
                           break;
                       case EVENT_BLAST_WAVE:
                           DoCastAOE(BLAST_WAVE);                            
                           break;						
                       case EVENT_ICE_LANCE:
                           DoCastAOE(ICE_LANCE);                            
                           break;
                       case EVENT_ICE_BARRIER:
                           if (!me->HasAura(ICE_BARRIER))
                           {
                             DoCast(me, ICE_BARRIER);
                           }                            
                           break;
                       case EVENT_FIRE_BALL:
                           DoCastAOE(FIRE_BALL);                            
                           break;
                       case EVENT_BERSERK:
                           DoCast(me, BERSERK);                            
                           break;
                       case EVENT_COUNTER_SPELL:
                           if (Unit* target = SelectEnemyCaster(false))
                           {  
                             DoCast(target, COUNTER_SPELL);
                           }                       
                           break;
                       default:
                           break;
                   }
               }

               DoMeleeAttackIfReady();
           }
       private:
           EventMap events;
       };

           CreatureAI* GetAI(Creature* creature) const
           {
               return new boss_radeonAI(creature);
           }
};

void AddSC_boss_radeon()
{
   new boss_radeon();
}

 

 

C++ Lady from ICC ( podle té jsem tvořil bosse, né úplně do detailů )

 

class boss_lady_deathwhisper : public CreatureScript
{
   public:
       boss_lady_deathwhisper() : CreatureScript("boss_lady_deathwhisper") { }

       struct boss_lady_deathwhisperAI : public BossAI
       {
           boss_lady_deathwhisperAI(Creature* creature) : BossAI(creature, DATA_LADY_DEATHWHISPER),
               _dominateMindCount(RAID_MODE<uint8>(0, 1, 1, 3)), _introDone(false)
           {
           }

           void Reset()
           {
               _Reset();
               me->SetPower(POWER_MANA, me->GetMaxPower(POWER_MANA));
               events.SetPhase(PHASE_ONE);
               _waveCounter = 0;
               _nextVengefulShadeTargetGUID = 0;
               _darnavanGUID = 0;
               DoCast(me, SPELL_SHADOW_CHANNELING);
               me->RemoveAurasDueToSpell(SPELL_BERSERK);
               me->RemoveAurasDueToSpell(SPELL_MANA_BARRIER);
               me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
               me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
           }

           void MoveInLineOfSight(Unit* who)
           {
               if (!_introDone && me->IsWithinDistInMap(who, 110.0f))
               {
                   _introDone = true;
                   Talk(SAY_INTRO_1);
                   events.SetPhase(PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_2, 11000, 0, PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_3, 21000, 0, PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_4, 31500, 0, PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_5, 39500, 0, PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_6, 48500, 0, PHASE_INTRO);
                   events.ScheduleEvent(EVENT_INTRO_7, 58000, 0, PHASE_INTRO);
               }
           }

           void AttackStart(Unit* victim)
           {
               if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
                   return;

               if (victim && me->Attack(victim, true) && !(events.GetPhaseMask() & PHASE_ONE_MASK))
                   me->GetMotionMaster()->MoveChase(victim);
           }

           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);
           }

           void JustDied(Unit* killer)
           {
               Talk(SAY_DEATH);

               std::set<uint32> livingAddEntries;
               // Full House achievement
               for (SummonList::iterator itr = summons.begin(); itr != summons.end(); ++itr)
                   if (Unit* unit = ObjectAccessor::GetUnit(*me, *itr))
                       if (unit->isAlive() && unit->GetEntry() != NPC_VENGEFUL_SHADE)
                           livingAddEntries.insert(unit->GetEntry());

               if (livingAddEntries.size() >= 5)
                   instance->DoUpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, SPELL_FULL_HOUSE, 0, me);

               if (Creature* darnavan = ObjectAccessor::GetCreature(*me, _darnavanGUID))
               {
                   if (darnavan->isAlive())
                   {
                       darnavan->setFaction(35);
                       darnavan->CombatStop(true);
                       darnavan->GetMotionMaster()->MoveIdle();
                       darnavan->SetReactState(REACT_PASSIVE);
                       darnavan->m_Events.AddEvent(new DaranavanMoveEvent(*darnavan), darnavan->m_Events.CalculateTime(10000));
                       darnavan->AI()->Talk(SAY_DARNAVAN_RESCUED);
                       if (Player* owner = killer->GetCharmerOrOwnerPlayerOrPlayerItself())
                       {
                           if (Group* group = owner->GetGroup())
                           {
                               for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
                                   if (Player* member = itr->getSource())
                                       member->KilledMonsterCredit(NPC_DARNAVAN_CREDIT, 0);
                           }
                           else
                               owner->KilledMonsterCredit(NPC_DARNAVAN_CREDIT, 0);
                       }
                   }
               }

               _JustDied();
           }

           void JustReachedHome()
           {
               _JustReachedHome();
               instance->SetBossState(DATA_LADY_DEATHWHISPER, FAIL);

               summons.DespawnAll();
               if (Creature* darnavan = ObjectAccessor::GetCreature(*me, _darnavanGUID))
               {
                   darnavan->DespawnOrUnsummon();
                   _darnavanGUID = 0;
               }
           }

           void KilledUnit(Unit* victim)
           {
               if (victim->GetTypeId() == TYPEID_PLAYER)
                   Talk(SAY_KILL);
           }

           void DamageTaken(Unit* /*damageDealer*/, uint32& damage)
           {
               // phase transition
               if (events.GetPhaseMask() & PHASE_ONE_MASK && damage > me->GetPower(POWER_MANA))
               {
                   Talk(SAY_PHASE_2);
                   Talk(EMOTE_PHASE_2);
                   DoStartMovement(me->getVictim());
                   damage -= me->GetPower(POWER_MANA);
                   me->SetPower(POWER_MANA, 0);
                   me->RemoveAurasDueToSpell(SPELL_MANA_BARRIER);
                   events.SetPhase(PHASE_TWO);
                   events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 12000), 0, PHASE_TWO);
                   events.ScheduleEvent(EVENT_P2_FROSTBOLT_VOLLEY, urand(19000, 21000), 0, PHASE_TWO);
                   events.ScheduleEvent(EVENT_P2_TOUCH_OF_INSIGNIFICANCE, urand(6000, 9000), 0, PHASE_TWO);
                   events.ScheduleEvent(EVENT_P2_SUMMON_SHADE, urand(12000, 15000), 0, PHASE_TWO);
                   // on heroic mode Lady Deathwhisper is immune to taunt effects in phase 2 and continues summoning adds
                   if (IsHeroic())
                   {
                       me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
                       me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
                       events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 45000, 0, PHASE_TWO);
                   }
               }
           }

           void JustSummoned(Creature* summon)
           {
               if (summon->GetEntry() == NPC_DARNAVAN)
                   _darnavanGUID = summon->GetGUID();
               else
                   summons.Summon(summon);

               Unit* target = NULL;
               if (summon->GetEntry() == NPC_VENGEFUL_SHADE)
               {
                   target = ObjectAccessor::GetUnit(*me, _nextVengefulShadeTargetGUID);   // Vengeful Shade
                   _nextVengefulShadeTargetGUID = 0;
               }
               else
                   target = SelectTarget(SELECT_TARGET_RANDOM);                        // Wave adds

               summon->AI()->AttackStart(target);                                      // CAN be NULL
               if (summon->GetEntry() == NPC_REANIMATED_FANATIC)
                   summon->CastSpell(summon, SPELL_FANATIC_S_DETERMINATION, true);
               else if (summon->GetEntry() == NPC_REANIMATED_ADHERENT)
                   summon->CastSpell(summon, SPELL_ADHERENT_S_DETERMINATION, true);
           }

           void UpdateAI(uint32 const diff)
           {
               if ((!UpdateVictim() && !(events.GetPhaseMask() & PHASE_INTRO_MASK)) || !CheckInRoom())
                   return;

               events.Update(diff);

               if (me->HasUnitState(UNIT_STAT_CASTING) && !(events.GetPhaseMask() & PHASE_INTRO_MASK))
                   return;

               while (uint32 eventId = events.ExecuteEvent())
               {
                   switch (eventId)
                   {
                       case EVENT_INTRO_2:
                           Talk(SAY_INTRO_2);
                           break;
                       case EVENT_INTRO_3:
                           Talk(SAY_INTRO_3);
                           break;
                       case EVENT_INTRO_4:
                           Talk(SAY_INTRO_4);
                           break;
                       case EVENT_INTRO_5:
                           Talk(SAY_INTRO_5);
                           break;
                       case EVENT_INTRO_6:
                           Talk(SAY_INTRO_6);
                           break;
                       case EVENT_INTRO_7:
                           Talk(SAY_INTRO_7);
                           break;
                       case EVENT_DEATH_AND_DECAY:
                           if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                               DoCast(target, SPELL_DEATH_AND_DECAY);
                           events.ScheduleEvent(EVENT_DEATH_AND_DECAY, urand(22000, 30000));
                           break;
                       case EVENT_DOMINATE_MIND_H:
                           Talk(SAY_DOMINATE_MIND);
                           for (uint8 i = 0; i < _dominateMindCount; i++)
                               if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_DOMINATE_MIND_H))
                                   DoCast(target, SPELL_DOMINATE_MIND_H);
                           events.ScheduleEvent(EVENT_DOMINATE_MIND_H, urand(40000, 45000));
                           break;
                       case EVENT_P1_SUMMON_WAVE:
                           SummonWaveP1();
                           events.ScheduleEvent(EVENT_P1_SUMMON_WAVE, IsHeroic() ? 45000 : 60000, 0, PHASE_ONE);
                           break;
                       case EVENT_P1_SHADOW_BOLT:
                           if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                               DoCast(target, SPELL_SHADOW_BOLT);
                           events.ScheduleEvent(EVENT_P1_SHADOW_BOLT, urand(5000, 8000), 0, PHASE_ONE);
                           break;
                       case EVENT_P1_REANIMATE_CULTIST:
                           ReanimateCultist();
                           break;
                       case EVENT_P1_EMPOWER_CULTIST:
                           EmpowerCultist();
                           events.ScheduleEvent(EVENT_P1_EMPOWER_CULTIST, urand(18000, 25000));
                           break;
                       case EVENT_P2_FROSTBOLT:
                           DoCastVictim(SPELL_FROSTBOLT);
                           events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 11000), 0, PHASE_TWO);
                           break;
                       case EVENT_P2_FROSTBOLT_VOLLEY:
                           DoCastAOE(SPELL_FROSTBOLT_VOLLEY);
                           events.ScheduleEvent(EVENT_P2_FROSTBOLT_VOLLEY, urand(13000, 15000), 0, PHASE_TWO);
                           break;
                       case EVENT_P2_TOUCH_OF_INSIGNIFICANCE:
                           DoCastVictim(SPELL_TOUCH_OF_INSIGNIFICANCE);
                           events.ScheduleEvent(EVENT_P2_TOUCH_OF_INSIGNIFICANCE, urand(9000, 13000), 0, PHASE_TWO);
                           break;
                       case EVENT_P2_SUMMON_SHADE:
                           if (Unit* shadeTarget = SelectTarget(SELECT_TARGET_RANDOM, 1))
                           {
                               _nextVengefulShadeTargetGUID = shadeTarget->GetGUID();
                               DoCast(shadeTarget, SPELL_SUMMON_SHADE);
                           }
                           events.ScheduleEvent(EVENT_P2_SUMMON_SHADE, urand(18000, 23000), 0, PHASE_TWO);
                           break;
                       case EVENT_P2_SUMMON_WAVE:
                           SummonWaveP2();
                           events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 45000, 0, PHASE_TWO);
                           break;
                       case EVENT_BERSERK:
                           DoCast(me, SPELL_BERSERK);
                           Talk(SAY_BERSERK);
                           break;
                   }
               }

               // We should not melee attack when barrier is up
               if (me->HasAura(SPELL_MANA_BARRIER))
                   return;

               DoMeleeAttackIfReady();
           }

           // summoning function for first phase
           void SummonWaveP1()
           {
               uint8 addIndex = _waveCounter & 1;
               uint8 addIndexOther = uint8(addIndex ^ 1);

               // Summon first add, replace it with Darnavan if weekly quest is active
               if (_waveCounter || !sPoolMgr->IsSpawnedObject<Quest>(QUEST_DEPROGRAMMING))
                   Summon(SummonEntries[addIndex], SummonPositions[addIndex * 3]);
               else
                   Summon(NPC_DARNAVAN, SummonPositions[addIndex * 3]);

               Summon(SummonEntries[addIndexOther], SummonPositions[addIndex * 3 + 1]);
               Summon(SummonEntries[addIndex], SummonPositions[addIndex * 3 + 2]);
               if (Is25ManRaid())
               {
                   Summon(SummonEntries[addIndexOther], SummonPositions[addIndexOther * 3]);
                   Summon(SummonEntries[addIndex], SummonPositions[addIndexOther * 3 + 1]);
                   Summon(SummonEntries[addIndexOther], SummonPositions[addIndexOther * 3 + 2]);
                   Summon(SummonEntries[urand(0, 1)], SummonPositions[6]);
               }

               ++_waveCounter;
           }

           // summoning function for second phase
           void SummonWaveP2()
           {
               if (Is25ManRaid())
               {
                   uint8 addIndex = _waveCounter & 1;
                   Summon(SummonEntries[addIndex], SummonPositions[addIndex * 3]);
                   Summon(SummonEntries[addIndex ^ 1], SummonPositions[addIndex * 3 + 1]);
                   Summon(SummonEntries[addIndex], SummonPositions[addIndex * 3+ 2]);
               }
               else
                   Summon(SummonEntries[urand(0, 1)], SummonPositions[6]);

               ++_waveCounter;
           }

           // helper for summoning wave mobs
           void Summon(uint32 entry, const Position& pos)
           {
               if (TempSummon* summon = me->SummonCreature(entry, pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000))
                   summon->AI()->DoCast(summon, SPELL_TELEPORT_VISUAL);
           }

           void SetGUID(uint64 guid, int32 id/* = 0*/)
           {
               if (id != GUID_CULTIST)
                   return;

               _reanimationQueue.push_back(guid);
               events.ScheduleEvent(EVENT_P1_REANIMATE_CULTIST, 3000, 0, PHASE_ONE);
           }

           void ReanimateCultist()
           {
               if (_reanimationQueue.empty())
                   return;

               uint64 cultistGUID = _reanimationQueue.front();
               Creature* cultist = ObjectAccessor::GetCreature(*me, cultistGUID);
               _reanimationQueue.pop_front();
               if (!cultist)
                   return;

               Talk(SAY_ANIMATE_DEAD);
               DoCast(cultist, SPELL_DARK_MARTYRDOM_T);
           }

           void SpellHitTarget(Unit* target, SpellInfo const* spell)
           {
               if (spell->Id == SPELL_DARK_MARTYRDOM_T)
               {
                   Position pos;
                   target->GetPosition(&pos);
                   if (target->GetEntry() == NPC_CULT_FANATIC)
                       me->SummonCreature(NPC_REANIMATED_FANATIC, pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);
                   else
                       me->SummonCreature(NPC_REANIMATED_ADHERENT, pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);

                   if (TempSummon* summon = target->ToTempSummon())
                       summon->UnSummon();
               }
           }

           void EmpowerCultist()
           {
               if (summons.empty())
                   return;

               std::list<Creature*> temp;
               for (SummonList::iterator itr = summons.begin(); itr != summons.end(); ++itr)
                   if (Creature* cre = ObjectAccessor::GetCreature(*me, *itr))
                       if (cre->isAlive() && (cre->GetEntry() == NPC_CULT_FANATIC || cre->GetEntry() == NPC_CULT_ADHERENT))
                           temp.push_back(cre);

               // noone to empower
               if (temp.empty())
                   return;

               // select random cultist
               Creature* cultist = SelectRandomContainerElement(temp);
               DoCast(cultist, cultist->GetEntry() == NPC_CULT_FANATIC ? SPELL_DARK_TRANSFORMATION_T : SPELL_DARK_EMPOWERMENT_T, true);
               Talk(uint8(cultist->GetEntry() == NPC_CULT_FANATIC ? SAY_DARK_TRANSFORMATION : SAY_DARK_EMPOWERMENT));
           }

       private:
           uint64 _nextVengefulShadeTargetGUID;
           uint64 _darnavanGUID;
           std::deque<uint64> _reanimationQueue;
           uint32 _waveCounter;
           uint8 const _dominateMindCount;
           bool _introDone;
       };

       CreatureAI* GetAI(Creature* creature) const
       {
           return GetIcecrownCitadelAI<boss_lady_deathwhisperAI>(creature);
       }
};

 

 

Zkoušel jsem:

 

events.Reset();

Ale to nefungovalo.

Edited November 21, 2011 by Paran

[ariczek 170]

asi jsi se inspiroval spatne

 

priklad z funkce updateAI u lady z ICC:

 

case EVENT_P2_SUMMON_WAVE:
   SummonWaveP2();
   events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 45000, 0, PHASE_TWO);
   break;
case EVENT_P2_FROSTBOLT:
   DoCastVictim(SPELL_FROSTBOLT);
   events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 11000), 0, PHASE_TWO);
   break;

 

a priklad od tebe

 

case EVENT_FIRE_BLAST:
     DoCastAOE(FIRE_BLAST);                            
     break;

 

chybi ti tam ten sheduling dalsiho

[Paran 6]

asi jsi se inspiroval spatne

 

priklad z funkce updateAI u lady z ICC:

 

case EVENT_P2_SUMMON_WAVE:
   SummonWaveP2();
   events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 45000, 0, PHASE_TWO);
   break;
case EVENT_P2_FROSTBOLT:
   DoCastVictim(SPELL_FROSTBOLT);
   events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 11000), 0, PHASE_TWO);
   break;

 

a priklad od tebe

 

case EVENT_FIRE_BLAST:
     DoCastAOE(FIRE_BLAST);                            
     break;

 

chybi ti tam ten sheduling dalsiho

 

Jo takhle... no,to mě ani nenapadlo,díky moc. + Rep

[ariczek 170]

Pro úplnost dodám ještě druhou možnost... a to pomocí

// Reschedules closest event
 void RepeatEvent(uint32 time)

 

priklad pouziti je v boss_kelthuzad.cpp

 

case EVENT_WASTE:
 DoSummon(NPC_WASTE, Pos[RAND(0, 3, 6, 9)]);
 events.RepeatEvent(urand(2000, 5000));
 break;