API tools faq
paste
Advertisement
nevadies

Untitled

nevadies
Oct 2nd, 2014
187
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.29 KB | None | 0 0
raw download clone embed print report
  1. #include "ScriptPCH.h"
  2. #include "ScriptedCreature.h"
  3. #include "ObjectMgr.h"
  4. #include "Group.h"
  5. #include "Creature.h"
  6.  
  7. //ZOMBIE GAME
  8. int8 GroupMembersDead = 0;
  9. //current number of zombies spawned so far
  10. int8 zombiesSpawned = 0;
  11. //what round in the game you are on
  12. int8 zombieRound = 0;
  13. //how many waves of zombies per round
  14. int8 zombieWaves = 0;
  15. //the number of waves already spawned
  16. int8 zombieWavesCount = 0;
  17. //the number of zombies to be spawned per wave
  18. int8 zombieSpawnPerWave = 0;
  19. //stores how many players are in the group
  20. int8 zombieGroupMembers = 0;
  21. //stores number of zombies spawn per each person
  22. int8 ZOMBIES_PER_PERSON = 3;
  23. int8 MaxRounds = 5;
  24. int8 inProgress = 0;
  25. bool inZombieGame;
  26. bool zombie_inUse = false;
  27. char chrmsg[200];
  28. Player* ZGLeader;
  29. Group* playerGroup;
  30. //README
  31. /* SET THE MAP, X, Y, Z LOCATIONS, CREATE CREATURES AND SET SCRIPT NAMES. CREATE GAME OBJECT FOR CHEST(s) */
  32.  
  33. //chest gps loc
  34. float CHEST_X = -480.702f;
  35. float CHEST_Y = 95.216f;
  36. float CHEST_Z = -189.73f;
  37. float CHEST_O = 6.2455f;
  38. //creatures
  39. WorldLocation POS_MINIGAME_START(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  40. WorldLocation POS_NPC_START_GAME(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  41. WorldLocation POS_NPC_NEXT_WAVE(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  42. WorldLocation POS_NPC_END_GAME(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  43. WorldLocation POS_NPC_END_ROUND(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  44. WorldLocation POS_NPC_WAIT_FOR_LOOT(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  45. WorldLocation POS_NPC_RESET(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  46. //teles
  47. WorldLocation POS_TELE_MALL(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  48. WorldLocation POS_TELE_REVIVE(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  49.  
  50. //enemy spawn loc
  51. WorldLocation POS_ENEMY_SPAWN(109, -480.702f, 95.216f, -189.73f, 6.2455f);
  52.  
  53. enum zombie_minigame_DATA
  54. {
  55. //ZOMBIE GAME NPC IDS
  56. MG_NPC_START_GAME = 500800,
  57. MG_NPC_START_NEXT_WAVE = 500801,
  58. MG_NPC_START_NEXT_ROUND = 500802,
  59. MG_NPC_WAIT_FOR_END_ROUND = 500803,
  60. MG_NPC_WAIT_FOR_CHEST_LOOT = 500804,
  61. MG_NPC_END_GAME = 500805,
  62. //ENEMIES
  63. ZOMBIE_ENEMY = 500806,
  64. //CHEST GAME OBJECT ID
  65. CHEST = 12,
  66. };
  67.  
  68. bool closeGossipNotify(Player *player, std::string message)
  69. {
  70. player->PlayerTalkClass->SendCloseGossip();
  71. player->GetSession()->SendNotification(message.c_str());
  72. return true;
  73. }
  74.  
  75. class zombie_minigame_master : public CreatureScript
  76. {
  77. public:
  78. zombie_minigame_master() : CreatureScript("zombie_minigame_master") { }
  79.  
  80. bool OnGossipHello(Player* player, Creature* creature)
  81. {
  82. if (player->isInCombat())
  83. {
  84. return closeGossipNotify(player, "You can't start the zombie MiniGame while being in combat.");
  85. }
  86.  
  87. if (!player->GetGroup() || player->GetGroup() == NULL)
  88. {
  89. return closeGossipNotify(player, "You must be the group leader in a party/raid with 5 or at least 2 players");
  90. }
  91.  
  92. Group* grp = player->GetGroup();
  93.  
  94. if (grp->GetMembersCount() > 5 || grp->GetMembersCount() < 2)
  95. {
  96. return closeGossipNotify(player, "You must be the group leader in a party/raid with 5 or at least 2 players");
  97. }
  98.  
  99. if (grp->GetLeaderGUID() != player->GetGUID())
  100. {
  101. return closeGossipNotify(player, "Only the party leader can activate the Zombie MiniGame!");
  102. }
  103.  
  104. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, "Teleport me to the Zombie Rush MiniGame!", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
  105. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "No thanks.", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
  106. player->PlayerTalkClass->SendGossipMenu(1, creature->GetGUID());
  107. return true;
  108. }
  109.  
  110. bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction)
  111. {
  112. player->PlayerTalkClass->ClearMenus();
  113. Group* grp = player->GetGroup();
  114. switch (uiAction)
  115. {
  116. case GOSSIP_ACTION_INFO_DEF + 1:
  117. {
  118. if (inZombieGame == true)
  119. {
  120. return closeGossipNotify(player, "A game is currently in progress!");
  121. }
  122. inZombieGame = true;//game is true new groups can not join until MiniGame is over!
  123. grp->ConvertToRaid();
  124. player->TeleportTo(POS_MINIGAME_START);
  125. zombie_inUse = true;
  126. break;
  127. }
  128. case GOSSIP_ACTION_INFO_DEF + 2:
  129. {
  130. player->PlayerTalkClass->SendCloseGossip();
  131. break;
  132. }
  133. }
  134. return true;
  135. }
  136. };
  137.  
  138. class zombie_minigame_ender : public CreatureScript
  139. {
  140. public:
  141. zombie_minigame_ender() : CreatureScript("zombie_minigame_ender") { }
  142.  
  143. bool OnGossipHello(Player* player, Creature* creature)
  144. {
  145. if (!player)
  146. return false;
  147. if (!player->GetGroup())
  148. return false;
  149. if (player->GetGroup() == NULL)
  150. return false;
  151. if (!creature)
  152. return false;
  153.  
  154. if (player->GetGroup()->GetLeaderGUID() == player->GetGUID())
  155. {
  156. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, "End the Zombie MiniGame!", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
  157. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Nevermind.", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
  158. player->PlayerTalkClass->SendGossipMenu(1, creature->GetGUID());
  159. }
  160. return true;
  161. }
  162.  
  163. bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction)
  164. {
  165. player->PlayerTalkClass->ClearMenus();
  166. Group* grp = player->GetGroup();
  167. switch (uiAction)
  168. {
  169. case GOSSIP_ACTION_INFO_DEF + 1:
  170. {
  171. creature->MonsterYell("The group leader ended the zombie rush minigame!", 0, 0);
  172. inProgress = 1;
  173. creature->SummonCreature(MG_NPC_END_GAME, POS_NPC_END_GAME, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1 * 1000);
  174. player->PlayerTalkClass->SendCloseGossip();
  175. break;
  176. }
  177. case GOSSIP_ACTION_INFO_DEF + 2:
  178. {
  179. player->PlayerTalkClass->SendCloseGossip();
  180. break;
  181. }
  182. }
  183. return true;
  184. }
  185. };
  186.  
  187. class zombie_minigame_controller : public CreatureScript
  188. {
  189. public:
  190. zombie_minigame_controller() : CreatureScript("zombie_minigame_controller") { }
  191.  
  192. bool OnGossipHello(Player* player, Creature* creature)
  193. {
  194. if (!player->GetGroup())
  195. return false;
  196. if (player->GetGroup() == NULL)
  197. return false;
  198.  
  199. if ((player->GetGroup()->GetMembersCount() <= 5 && player->GetGroup()->GetMembersCount() >= 2) && player->GetGroup()->GetLeaderGUID() == player->GetGUID())
  200. {
  201. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_INTERACT_1, "Summon group to the Zombie Rush MiniGame!", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
  202. if (player->GetGroup()->GetLeaderGUID() == player->GetGUID())
  203. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, "Start the Game!", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
  204. player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Nevermind", GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);
  205. player->PlayerTalkClass->SendGossipMenu(1, creature->GetGUID());
  206. }
  207. return true;
  208. }
  209.  
  210. bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction)
  211. {
  212.  
  213. player->PlayerTalkClass->ClearMenus();
  214. Group* grp = player->GetGroup();
  215. zombie_inUse = true;
  216. if (grp){
  217. GroupReference* grpRef = grp->GetFirstMember();
  218. if (grp->GetLeaderGUID() == player->GetGUID())
  219. GroupReference grpRef = player->GetGroupRef();
  220.  
  221. switch (uiAction)
  222. {
  223. case GOSSIP_ACTION_INFO_DEF + 1:
  224. {
  225. for (grpRef; grpRef != NULL; grpRef = grpRef->next())
  226. {
  227. Player* groupMember = grpRef->getSource();
  228. ChatHandler(player->GetSession()).PSendSysMessage("Sending summon request to...");
  229. if (!groupMember)
  230. continue;
  231. if (groupMember->GetGUID() == player->GetGUID())
  232. break;
  233. player->SetSelection(groupMember->GetGUID());
  234. player->CastSpell(groupMember, 7720, true);
  235. ChatHandler(player->GetSession()).PSendSysMessage("%s", groupMember->GetName());
  236. }
  237. break;
  238. }
  239. case GOSSIP_ACTION_INFO_DEF + 2:
  240. {
  241. creature->MonsterYell("Round 1 starts in 30 seconds!", 0, 0);
  242. /* spawn MG_NPC_START_GAME to despawn after 30 seconds and start the game */
  243. creature->SummonCreature(MG_NPC_START_GAME, POS_NPC_START_GAME, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1 * 1000);
  244. /* the main NPC will not be seen again by the group so teleport him away */
  245. creature->UpdatePosition(POS_NPC_RESET, true);
  246. break;
  247. }
  248. case GOSSIP_ACTION_INFO_DEF + 3:
  249. {
  250. creature->MonsterYell("The group leader ended the zombie rush minigame!", 0, 0);
  251. creature->SummonCreature(MG_NPC_END_GAME, POS_NPC_END_GAME, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 500);
  252. break;
  253. }
  254. }
  255. }
  256. player->PlayerTalkClass->SendCloseGossip();
  257. return true;
  258. }
  259.  
  260. struct zombie_minigame_controllerAI : public ScriptedAI
  261. {
  262. zombie_minigame_controllerAI(Creature* c) : ScriptedAI(c), Summons(me) {}
  263.  
  264. SummonList Summons;
  265.  
  266. void JustSummoned(Creature* summon)
  267. {
  268. if (summon)
  269. {
  270. uint32 entry = summon->GetEntry();
  271. Summons.Summon(summon);
  272. //
  273. if (entry >= MG_NPC_START_GAME && entry <= MG_NPC_WAIT_FOR_END_ROUND || entry == MG_NPC_WAIT_FOR_CHEST_LOOT || entry == MG_NPC_END_GAME)
  274. {
  275.  
  276. }
  277. else
  278. {
  279. Player* SelNearestPlr = summon->SelectNearestPlayer(240.0f);
  280. if (SelNearestPlr)
  281. summon->Attack(SelNearestPlr, false);
  282. else
  283. {
  284. /* cant find a player to select */
  285. }
  286. }
  287. }
  288. }
  289.  
  290. void SummonedCreatureDespawn(Creature* summon)
  291. {
  292. uint32 summonID = summon->GetEntry();
  293. if (summonID == MG_NPC_START_GAME)
  294. {
  295. inProgress = 0;
  296. if (inProgress == 1)
  297. {
  298. char msg[200];
  299. sprintf(msg, "Game Ended or not in progress! Resetting Game!");
  300. me->MonsterYell(msg, 0, 0);
  301. ResetZombieGame();
  302. return;
  303. }
  304. /*New Game, reset everything. */
  305. ResetZombieGame();
  306. inProgress = 0;
  307. me->SetVisible(false);
  308. Player* SelNearestPlr = me->SelectNearestPlayer(240.0f);
  309. if (!SelNearestPlr)
  310. {
  311. ResetZombieGame();
  312. me->MonsterYell("No Player!", 0, 0); return;
  313. }
  314. if (SelNearestPlr == NULL)
  315. {
  316. ResetZombieGame();
  317. me->MonsterYell("No Player!", 0, 0); return;
  318. }
  319. if (!SelNearestPlr->GetGroup())
  320. {
  321. ResetZombieGame();
  322. me->MonsterYell("No Group", 0, 0); return;
  323. }
  324. if (SelNearestPlr->GetGroup() == NULL)
  325. {
  326. ResetZombieGame();
  327. me->MonsterYell("No Group!", 0, 0); return;
  328. }
  329. if (playerGroup = SelNearestPlr->GetGroup())
  330. {
  331. zombieGroupMembers = playerGroup->GetMembersCount();
  332. if (ZGLeader = sObjectAccessor->FindPlayer(playerGroup->GetLeaderGUID()))
  333. {
  334. }
  335. else
  336. {
  337. ResetZombieGame();
  338. me->MonsterYell("No Group!", 0, 0); return;
  339. }
  340. }
  341. else
  342. {
  343. ResetZombieGame();
  344. me->MonsterYell("No Group!", 0, 0); return;
  345. }
  346.  
  347. /* Set the ZombieGame to true so they cant keep starting the game */
  348. inZombieGame = true;
  349.  
  350. //me->MonsterYell("Round 1 is starting now!", 0, 0);
  351. //sendMessageToGroup("Round 1 is starting now!");
  352. me->MonsterYell("If you die anytime during the MiniGame you will be respawned at the end of the round! If the entire party dies you will be teleported to the mall.", 0, 0);
  353. /* NPC_START_NEXT_WAVE is despanwed when the next wave of zombies is to be sent */
  354. me->SummonCreature(MG_NPC_START_NEXT_WAVE, POS_NPC_NEXT_WAVE, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30 * 1000);
  355. }
  356. //No one in game
  357. if (inZombieGame == false)
  358. {
  359. ResetZombieGame();
  360. return;
  361. }
  362. //Game not in progress or Ended, reset.
  363. if (inProgress == 1)
  364. {
  365. me->MonsterYell("Game Ended/Not in Progress, reset!", 0, 0);
  366. ResetZombieGame();
  367. return;
  368. }
  369. //No Group, End game, reset.
  370. if (!ZGLeader->GetGroup())
  371. {
  372. me->MonsterYell("No Group Found!", 0, 0);
  373. ResetZombieGame();
  374. return;
  375. }
  376. if (!ZGLeader)
  377. {
  378. me->MonsterYell("No Group Leader Found!", 0, 0);
  379. ResetZombieGame();
  380. return;
  381. }
  382.  
  383. switch (summonID)
  384. {
  385. case MG_NPC_WAIT_FOR_END_ROUND:
  386. {
  387. //End MiniGame
  388. if (inProgress == 1)
  389. {
  390. sprintf(chrmsg, "Game ended or not in progress! Resetting game!");
  391. me->MonsterYell(chrmsg, 0, 0);
  392. ResetZombieGame();
  393. return;
  394. }
  395. //revive group & reset if group failed game.
  396. reviveGroup();
  397. //All Enemy NPCS killed, Continue Game.
  398. if (zombiesSpawned < 1)
  399. {
  400. sprintf(chrmsg, "All enemies killed continuing game!");
  401. me->MonsterYell(chrmsg, 0, 0);
  402. zombiesSpawned = 0;
  403. /* NPC_START_NEXT_WAVE is despanwed when the next wave of zombies is to be sent */
  404. me->SummonCreature(MG_NPC_START_NEXT_WAVE, POS_NPC_NEXT_WAVE, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1 * 1000);
  405. }
  406. else
  407. {
  408. sprintf(chrmsg, "You must kill all enemies to continue the game!");
  409. me->MonsterYell(chrmsg, 0, 0);
  410. me->SummonCreature(MG_NPC_WAIT_FOR_END_ROUND, POS_NPC_END_ROUND, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30 * 1000);
  411. break;
  412. }
  413. break;
  414. }
  415. /* called when a wave of zombies needs to be spawned */
  416. case MG_NPC_START_NEXT_WAVE:
  417. {
  418. me->SetVisible(false);//Set npc to invisible /* Players may only summon new/existing group memebers during the end of a round.*/
  419. if (inProgress == 1)
  420. {
  421. sprintf(chrmsg, "Game Ended or not in progress! Resetting game!");
  422. me->MonsterYell(chrmsg, 0, 0);
  423. ResetZombieGame();
  424. return;
  425. }
  426. //check if zombies are still alive, if so spawn wait for end of round npc.
  427. if (zombiesSpawned > 0)
  428. {
  429. sprintf(chrmsg, "Waiting for all creatures to be slain to resume the game!");
  430. me->MonsterYell(chrmsg, 0, 0);
  431. me->SummonCreature(MG_NPC_WAIT_FOR_END_ROUND, POS_NPC_END_ROUND, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30 * 1000);
  432. return;
  433. }
  434. // wave check
  435. if (zombieWavesCount <= getNumberOfWaves())
  436. {
  437. //spawn
  438. sprintf(chrmsg, "Wave %u has spawned!", zombieWavesCount);
  439. me->MonsterYell(chrmsg, 0, 0);
  440. sendMessageToGroup(chrmsg);
  441. /* calc how many waves of zombies to send */
  442. zombieWaves = getNumberOfWaves();
  443. /* calc how many zombies per wave */
  444. zombieSpawnPerWave = getZombieSpawnCountPerWave();
  445. //
  446. spawnZombies(me, zombieSpawnPerWave);
  447. zombieWavesCount += 1;
  448. //
  449. me->SummonCreature(MG_NPC_START_NEXT_WAVE, POS_NPC_NEXT_WAVE, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 20 * 1000);
  450. }
  451. else
  452. {
  453. //spawn
  454. sprintf(chrmsg, "Round %u Chest has spawned! You have 60 seconds to loot & prepare.", zombieRound);
  455. //round cleared +1
  456. zombieRound += 1;
  457. me->MonsterYell(chrmsg, 0, 0);
  458. sendMessageToGroup(chrmsg);
  459. if (zombieRound <= 5)
  460. {
  461. me->SummonCreature(MG_NPC_WAIT_FOR_CHEST_LOOT, POS_NPC_WAIT_FOR_LOOT, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30 * 1000);
  462. me->SummonGameObject(CHEST, CHEST_X, CHEST_Y, CHEST_Z, CHEST_O, TEMPSUMMON_TIMED_DESPAWN, 60 * 1000, 0, 0, 0);
  463. }
  464. //revice group & check if group failed game.
  465. reviveGroup();
  466. //resurrect dead players
  467. }
  468. break;
  469. }
  470. case MG_NPC_WAIT_FOR_CHEST_LOOT:
  471. {
  472. if (inProgress == 1)
  473. {//End Game
  474. char msg[200];
  475. sprintf(msg, "Game Ended or not in progress! Resetting MiniGame!");
  476. me->MonsterYell(msg, 0, 0);
  477. ResetZombieGame();
  478. return;
  479. }
  480. if (zombieRound <= MaxRounds)
  481. {//Continue Game
  482. sprintf(chrmsg, "Round %u is starting!", zombieRound);
  483. me->MonsterYell(chrmsg, 0, 0);
  484. sendMessageToGroup(chrmsg);
  485. me->SetVisible(false);/* Disallow players from summoning while a round is in progress. */
  486. zombieWaves = getNumberOfWaves(); /* calc how many waves of zombies to send */
  487. zombieSpawnPerWave = getZombieSpawnCountPerWave(); /* calc how many zombies per wave */
  488. zombieWavesCount = 1;//reset current wave
  489. sprintf(chrmsg, "30 Seconds left to loot chests & prepare! The next wave starts in 30 seconds!");
  490. me->MonsterYell(chrmsg, 0, 0);
  491. sendMessageToGroup(chrmsg);
  492. me->SummonCreature(MG_NPC_START_NEXT_WAVE, POS_NPC_START_GAME, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30 * 1000);
  493. }
  494. else{
  495. me->SummonCreature(MG_NPC_END_GAME, POS_NPC_END_GAME, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 3 * 1000);
  496. }
  497. break;
  498. }
  499. case MG_NPC_END_GAME:
  500. {
  501. sprintf(chrmsg, "The Game Has Ended.");
  502. me->MonsterYell(chrmsg, 0, 0);
  503. sendMessageToGroup(chrmsg);
  504. inProgress = 0;//0 - Inactive
  505. ResetZombieGame();
  506. me->SetVisible(true);
  507. break;
  508. }
  509. default:
  510. if (summonID == ZOMBIE_ENEMY)
  511. sprintf(chrmsg, "Zombie Killed.");
  512. me->MonsterYell(chrmsg, 0, 0);
  513. sendMessageToGroup(chrmsg);
  514. break;
  515. }
  516. }
  517.  
  518. bool sendMessageToGroup(const char *message)
  519. {
  520. if (!ZGLeader->GetGroup())
  521. return true;
  522. if (ZGLeader->GetGroup() == NULL)
  523. return true;
  524. if (!playerGroup)
  525. return true;
  526.  
  527. Player* GroupMember;
  528. const Group::MemberSlotList members = playerGroup->GetMemberSlots();
  529. for (Group::member_citerator itr = members.begin(); itr != members.end(); ++itr)
  530. {
  531. GroupMember = (Unit::GetPlayer(*me, itr->guid));
  532. if (GroupMember && GroupMember->GetSession())
  533. {
  534. if (!GroupMember)
  535. continue;
  536. GroupMember->GetSession()->SendAreaTriggerMessage(message);
  537. }
  538. }
  539. return true;
  540. }
  541.  
  542. //reset revive
  543. void resetRevive() { GroupMembersDead = 0; }
  544.  
  545. void reviveGroup()
  546. {
  547. GroupReference* grpRef = playerGroup->GetFirstMember();
  548. for (grpRef; grpRef != NULL; grpRef = grpRef->next())
  549. {
  550. Player* groupMember = grpRef->getSource();
  551. if (!groupMember)
  552. continue;
  553.  
  554. //get players name
  555. std::string plrname = groupMember->GetName();
  556. char chrmsg[200];
  557.  
  558. //we use instanced maps so unless area ids are needed no need to change
  559. Map * pMap = me->ToCreature()->GetMap();
  560. int32 memberscount = 0;
  561. int32 membersDead = 0;
  562. if (pMap)
  563. {
  564. Map::PlayerList const &Players = pMap->GetPlayers();
  565. for (Map::PlayerList::const_iterator itr = Players.begin(); itr != Players.end(); ++itr)
  566. {
  567. if (Player * pPlayer = itr->getSource())
  568. {
  569. //update mebers count.
  570. memberscount += 1;
  571. //Check if they are alive.
  572. if (!pPlayer->isAlive())
  573. membersDead += 1;
  574. }
  575. }
  576. }
  577.  
  578. //yell group count
  579. sprintf(chrmsg, "Group Members = %u!", memberscount);
  580. me->MonsterYell(chrmsg, 0, 0);
  581. //yell dead count
  582. sprintf(chrmsg, "Group Members Dead = %u!", membersDead);
  583. me->MonsterYell(chrmsg, 0, 0);
  584.  
  585. if (membersDead == memberscount)
  586. {//end game, players defeated
  587. sprintf(chrmsg, "The entire group has died! Resetting game! Teleporting losers to mall!");
  588. me->MonsterYell(chrmsg, 0, 0);
  589. sendMessageToGroup(chrmsg);
  590. RevivePlayers();
  591. TeleGroupToMall();
  592. ResetZombieGame();
  593. }
  594. if (membersDead >= 1 && zombiesSpawned <= 0)
  595. {//revive players
  596. RevivePlayers();
  597. membersDead = 0;
  598. sprintf(chrmsg, "Round %u cleared! Dead players revived!", zombieRound);
  599. me->MonsterYell(chrmsg, 0, 0);
  600. }
  601. }
  602. }
  603.  
  604. void TeleGroupToMall()
  605. {//Teleport players to defined location
  606. Map * pMap = me->ToCreature()->GetMap();
  607. if (pMap)
  608. {
  609. Map::PlayerList const &Players = pMap->GetPlayers();
  610. for (Map::PlayerList::const_iterator itr = Players.begin(); itr != Players.end(); ++itr)
  611. {
  612. if (Player * pPlayer = itr->getSource())
  613. {
  614. if (pPlayer)
  615. {
  616. pPlayer->ResurrectPlayer(100, false);
  617. pPlayer->TeleportTo(POS_TELE_MALL);//steps
  618. }
  619. }
  620. }
  621. }
  622. }
  623.  
  624. void RevivePlayers()
  625. {//revive players
  626. Map * pMap = me->ToCreature()->GetMap();
  627. char chrmsg[200];
  628. if (pMap)
  629. {
  630. Map::PlayerList const &Players = pMap->GetPlayers();
  631. for (Map::PlayerList::const_iterator itr = Players.begin(); itr != Players.end(); ++itr)
  632. {
  633. if (Player * pPlayer = itr->getSource())
  634. {
  635. //Check if they are dead.
  636. if (!pPlayer->isAlive())
  637. {
  638. std::string plrname = pPlayer->GetName();
  639. sprintf(chrmsg, "%s Revived!.", plrname.c_str());
  640. me->MonsterYell(chrmsg, 0, 0);
  641. pPlayer->ResurrectPlayer(100, false);
  642. pPlayer->TeleportTo(POS_TELE_REVIVE);
  643. }
  644. }
  645. }//reset revive counter
  646. resetRevive();
  647. }
  648. }
  649.  
  650. void spawnZombies(Creature* creature, uint32 count)
  651. {
  652. zombiesSpawned = zombiesSpawned + count;
  653. for (uint32 i = 1; i <= count; i++)
  654. {
  655. creature->SummonCreature(ZOMBIE_ENEMY, POS_ENEMY_SPAWN);
  656. }
  657. }
  658.  
  659. int getZombieSpawnCountPerWave()
  660. {
  661. return (zombieGroupMembers * ZOMBIES_PER_PERSON);
  662. }
  663.  
  664. int getNumberOfWaves()
  665. {
  666. if (zombieRound >= 50)
  667. return 7;
  668. if (zombieRound >= 40)
  669. return 6;
  670. if (zombieRound >= 30)
  671. return 5;
  672. if (zombieRound >= 20)
  673. return 4;
  674. if (zombieRound <= 10)
  675. return 3;
  676. }
  677.  
  678. int getZombieSpawnCount(Creature* creature)
  679. {
  680. return (zombieGroupMembers * ZOMBIES_PER_PERSON);
  681. }
  682.  
  683. void CleanupNPCS()
  684. {
  685. //Cleanup NPC'S
  686. std::list<Creature*> zombie_enemy;
  687. zombie_enemy.clear();
  688.  
  689. GetCreatureListWithEntryInGrid(zombie_enemy, me, ZOMBIE_ENEMY, 240.0f);
  690. for (auto itr : zombie_enemy)
  691. {
  692. if (!itr)
  693. continue;
  694.  
  695. if (itr->isSummon())
  696. itr->ForcedDespawn();
  697. }
  698. }
  699.  
  700. bool ResetZombieGame()
  701. {//reset the minigame
  702. CleanupNPCS();
  703. //player checks
  704. playerGroup = NULL;
  705. ZGLeader = NULL;
  706. //control npc updates
  707. me->UpdatePosition(POS_NPC_RESET, true);
  708. me->SetVisible(true);
  709. me->Respawn();
  710. //ZOMBIES game settings
  711. inZombieGame = false;
  712. inProgress = 0;
  713. zombiesSpawned = 0;
  714. zombieRound = 1;
  715. zombieWaves = 3;
  716. zombieWavesCount = 1;
  717. zombieSpawnPerWave = 0;
  718. zombieGroupMembers = 0;
  719. ZOMBIES_PER_PERSON = 3;
  720. return true;
  721. }
  722. };
  723.  
  724. CreatureAI* GetAI(Creature* creature) const
  725. {
  726. return new zombie_minigame_controllerAI(creature);
  727. }
  728. };
  729.  
  730. /*-----------------------
  731. Zombie Enemy Minigame AI
  732. ----------------------*/
  733.  
  734. class MiniGame_Zombie : public CreatureScript
  735. {
  736. public:
  737. MiniGame_Zombie() : CreatureScript("MiniGame_Zombie") { }
  738.  
  739. struct MiniGame_ZombieAI : public ScriptedAI
  740. {
  741. MiniGame_ZombieAI(Creature* c) : ScriptedAI(c) {}
  742.  
  743. void JustDied(Unit* killer)
  744. {
  745. zombiesSpawned -= 1;
  746.  
  747. if (me)
  748. me->DespawnOrUnsummon();
  749. }
  750. };
  751.  
  752. CreatureAI* GetAI(Creature* creature) const
  753. {
  754. return new MiniGame_ZombieAI(creature);
  755. }
  756. };
  757.  
  758. void AddSC_Zombie_Mini_Game()
  759. {
  760. new zombie_minigame_master();
  761. new zombie_minigame_ender();
  762. new zombie_minigame_controller();
  763. new MiniGame_Zombie();
  764. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!