src/finalBattle.cpp

   1 /*
   2 Copyright © 2004 Parallel Realities
   3 Copyright © 2007-2008 Kővágó Zoltán <DirtY.iCE.hu@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13
  14 See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 */
  21
  22 #include <cmath>
  23
  24 #include "CAudio.h"
  25 #include "CEngine.h"
  26 #include "CGame.h"
  27 #include "CGraphics.h"
  28 #include "CMap.h"
  29 #include "CMath.h"
  30 #include "CObjective.h"
  31 #include "console/console.hpp"
  32 #include "finalBattle.h"
  33
  34 void galdovMiniAttack();
  35 void galdovFinalFlee1();
  36 void blackDroidAttack();
  37
  38 // ************************ Black Droids for Part 2 *************************************
  39
  40 void blackDroidFire()
  41 {
  42         (self->x < player.x) ? self->face = 0 : self->face = 1;
  43
  44         if (!hasClearShot(self))
  45                 return;
  46
  47         self->setActionFinished(9);
  48         self->setThinkTime(2);
  49         self->think = &blackDroidFire;
  50
  51         addBullet((Entity*)self, 0, 0);
  52
  53         self->custom--;
  54         if (self->custom == 0)
  55         {
  56                 self->think = &blackDroidAttack;
  57         }
  58 }
  59
  60 void blackDroidDie()
  61 {
  62         self->health--;
  63         Math::removeBit(&self->flags, ENT_FLIES);
  64
  65         if (self->health < -10)
  66         {
  67                 if ((self->health % 3) == 0)
  68                 {
  69                         addExplosion(self->x, self->y, 35, self);
  70                         addSmokeAndFire(self, Math::rrand(-15, 15), Math::rrand(-15, 15), 2);
  71                 }
  72         }
  73
  74         if (self->health <= -60)
  75         {
  76                 if ((rand() % 2) == 0)
  77                 {
  78                         dropItems((int)self->x, (int)self->y);
  79                         dropItems((int)self->x, (int)self->y);
  80                 }
  81                 else
  82                 {
  83                         addItem(100, "Red Keycard", (int)self->x, (int)self->y, "RedKeyCard", 240, 1, ENT_DYING, true);
  84                 }
  85                 self->active = false;
  86                 self->place(9999, 9999);
  87         }
  88 }
  89
  90 void blackDroidChasePlayer()
  91 {
  92         self->think = &blackDroidAttack;
  93
  94         (self->x < player.x) ? self->face = 0 : self->face = 1;
  95
  96         float dx, dy;
  97
  98         Math::calculateSlope(player.x, player.y, self->x, self->y, &dx, &dy);
  99
 100         self->dx = (dx * 2);
 101         self->dy = (dy * 2);
 102
 103         self->setThinkTime(10);
 104         self->setActionFinished(10);
 105 }
 106
 107 void blackDroidMoveRandom()
 108 {
 109         (self->x < player.x) ? self->face = 0 : self->face = 1;
 110
 111         self->think = &blackDroidAttack;
 112
 113         self->dx = Math::rrand(-200, 200);
 114         self->dy = Math::rrand(-200, 200);
 115
 116         self->dx *= 0.01;
 117         self->dy *= 0.01;
 118
 119         self->setThinkTime(2);
 120         self->setActionFinished(Math::rrand(60, 90));
 121 }
 122
 123 void blackDroidAttack()
 124 {
 125         self->think = blackDroidAttack;
 126         self->setThinkTime(2);
 127         self->setActionFinished(2);
 128
 129         int r = rand() % 15;
 130
 131         if (r <= 2)
 132         {
 133                 self->think = &blackDroidFire;
 134                 self->setThinkTime(2);
 135                 self->setActionFinished(2);
 136                 self->custom = Math::rrand(2, 4) * game.skill;
 137         }
 138         else if (r < 5)
 139         {
 140                 self->think = &blackDroidChasePlayer;
 141                 self->setThinkTime(2);
 142                 self->setActionFinished(2);
 143         }
 144         else
 145         {
 146                 self->think = &blackDroidMoveRandom;
 147                 self->setThinkTime(2);
 148                 self->setActionFinished(2);
 149         }
 150 }
 151
 152 void galdovInitBlackDroids()
 153 {
 154         for (int i = 6 ; i < 10 ; i++)
 155         {
 156                 if (map.boss[i] == NULL)
 157                 {
 158                         map.boss[i] = new Boss();
 159                 }
 160                 debug("boss", 2) << "BlackDroid " << i << " init" << std::endl;
 161                 strcpy(map.boss[i]->name, "BlackDrod");
 162                 map.boss[i]->health = -90;
 163                 map.boss[i]->maxHealth = -90;
 164                 map.boss[i]->setSprites(graphics.getSprite("BlackDroidRight", true), graphics.getSprite("BlackDroidLeft", true), graphics.getSprite("BlackDroidDie", true));
 165                 map.boss[i]->currentWeapon = &weapon[WP_PLASMARIFLE];
 166                 map.boss[i]->face = 0;
 167                 map.boss[i]->active = false;
 168                 map.boss[i]->place(9999, 9999);
 169                 map.boss[i]->immune = 0;
 170                 map.boss[i]->setThinkTime(2);
 171                 map.boss[i]->think = &blackDroidAttack;
 172                 map.boss[i]->react = NULL;
 173                 map.boss[i]->die = &blackDroidDie;
 174                 map.boss[i]->setActionFinished(120);
 175                 Math::addBit(&map.boss[i]->flags, ENT_FLIES);
 176                 Math::addBit(&map.boss[i]->flags, ENT_AIMS);
 177                 Math::removeBit(&map.boss[i]->flags, ENT_FIRETRAIL);
 178         }
 179 }
 180
 181 // ************************ First part of final battle **********************************
 182
 183 void galdovFinalKeepAlive1()
 184 {
 185         map.boss[0]->health = 30 * game.skill;
 186 }
 187
 188 void galdovFinalPainThrow()
 189 {
 190         self->dx = -3;
 191         self->dy = -12;
 192
 193         self->think = &galdovFinalFlee1;
 194         self->setThinkTime(2);
 195         self->setActionFinished(140);
 196 }
 197
 198 void galdovFinalDropCrystal()
 199 {
 200         self->setThinkTime(2);
 201         self->setActionFinished(2);
 202
 203         int x = (int)player.x >> BRICKSHIFT;
 204         int y = (int)player.y >> BRICKSHIFT;
 205         x += Math::rrand(-2, 2);
 206         y += Math::rrand(-2, 2);
 207
 208         Math::limitInt(&x, 2, 62);
 209         Math::limitInt(&y, 2, 26);
 210
 211         if (map.data[x][y] == MAP_AIR)
 212         {
 213                 x = x << BRICKSHIFT;
 214                 y = y << BRICKSHIFT;
 215                 self->x = x;
 216                 self->y = y;
 217                 addTeleportParticles(self->x + 10, self->y + 10, 50, SND_TELEPORT2);
 218                 addItem(101, "Reality Crystal", (int)self->x, (int)self->y, "RealityCrystal", 100, 1, 0, true);
 219                 self->think = &galdovFinalPainThrow;
 220                 self->react = &galdovFinalKeepAlive1;
 221                 Math::removeBit(&self->flags, ENT_FLIES);
 222                 Math::removeBit(&self->flags, ENT_FIRETRAIL);
 223                 map.setMainBossPart(NULL);
 224                 map.boss[0]->health = 30 * game.skill;
 225                 map.boss[0]->setSprites(graphics.getSprite("GaldovPain", true), graphics.getSprite("GaldovPain", true), graphics.getSprite("GaldovPain", true));
 226                 engine.setInfoMessage("Galdov has dropped the crystal! Quick! Get it!!", 99, INFO_HINT);
 227                 audio.playSound(SND_BOSSCUSTOM2, CH_AMBIANCE);
 228         }
 229 }
 230
 231 void galdovFinalDie()
 232 {
 233         if (game.missionOverReason == MIS_INPROGRESS)
 234         {
 235                 game.missionOverReason = MIS_GAMECOMPLETE;
 236                 audio.stopMusic();
 237                 audio.playSound(SND_BOSSCUSTOM3, CH_AMBIANCE);
 238                 player.health = 10;
 239                 self->dx = 5;
 240                 self->dy = -6;
 241                 self->react = NULL;
 242                 Math::removeBit(&self->flags, ENT_FLIES);
 243                 Math::removeBit(&self->flags, ENT_FIRETRAIL);
 244         }
 245
 246         self->setActionFinished(1);
 247         self->setThinkTime(1);
 248
 249         self->health--;
 250
 251         if (self->health > -35)
 252                 return;
 253
 254         if (self->health == -99)
 255         {
 256                 checkObjectives(self->name, false);
 257         }
 258
 259         Math::wrapInt(&self->health, -99, -41);
 260
 261         if ((self->health % 3) == 0)
 262         {
 263                 self->setActionFinished(5);
 264                 self->setThinkTime(2);
 265
 266                 self->dx = Math::rrand(-5, 5);
 267                 self->dy = Math::rrand(-5, 5);
 268
 269                 addExplosion(self->x, self->y, 50, &player);
 270                 addSmokeAndFire(self, Math::rrand(-5, 5), Math::rrand(-5, 5), 2);
 271         }
 272 }
 273
 274 void galdovMiniFire()
 275 {
 276         (self->x < player.x) ? self->face = 0 : self->face = 1;
 277
 278         if (!hasClearShot(self))
 279                 return;
 280
 281         self->setActionFinished(9);
 282         self->setThinkTime(2);
 283         self->think = &galdovMiniFire;
 284
 285         addBullet((Entity*)self, 0, 0);
 286
 287         self->custom--;
 288         if (self->custom == 0)
 289         {
 290                 self->think = &galdovMiniAttack;
 291         }
 292 }
 293
 294 void galdovFinalTeleport()
 295 {
 296         self->setThinkTime(2);
 297         self->setActionFinished(2);
 298
 299         int x = (int)player.x >> BRICKSHIFT;
 300         int y = (int)player.y >> BRICKSHIFT;
 301         x += Math::rrand(-10, 10);
 302         y += Math::rrand(-10, 10);
 303
 304         Math::limitInt(&x, 2, 62);
 305         Math::limitInt(&y, 2, 26);
 306
 307         if (self == map.boss[0])
 308         {
 309                 if (self->health < 45 * game.skill)
 310                 {
 311                         Math::limitInt(&x, 23, 62);
 312                         Math::limitInt(&y, 42, 61);
 313                         self->currentWeapon = getRandomGaldovWeapon();
 314                 }
 315         }
 316
 317         if (map.data[x][y] == MAP_AIR)
 318         {
 319                 x = x << BRICKSHIFT;
 320                 y = y << BRICKSHIFT;
 321                 self->x = x;
 322                 self->y = y;
 323                 addTeleportParticles(self->x + 10, self->y + 10, 50, SND_TELEPORT2);
 324                 self->think = &galdovMiniAttack;
 325         }
 326 }
 327
 328 void galdovMiniChasePlayer()
 329 {
 330         (self->x < player.x) ? self->face = 0 : self->face = 1;
 331
 332         float dx, dy;
 333
 334         Math::calculateSlope(player.x, player.y, self->x, self->y, &dx, &dy);
 335
 336         self->dx = (dx * 2);
 337         self->dy = (dy * 2);
 338
 339         self->setThinkTime(10);
 340         self->setActionFinished(10);
 341         self->think = &galdovMiniAttack;
 342 }
 343
 344 void galdovMiniMoveRandom()
 345 {
 346         self->think = &galdovMiniAttack;
 347
 348         if (self->flags & ENT_FLIES)
 349         {
 350                 self->dx = Math::rrand(-200, 200);
 351                 self->dy = Math::rrand(-200, 200);
 352
 353                 self->dx *= 0.01;
 354                 self->dy *= 0.01;
 355
 356                 self->setThinkTime(2);
 357                 self->setActionFinished(Math::rrand(60, 90));
 358         }
 359         else
 360         {
 361                 self->dy = Math::rrand(-12, 0);
 362
 363                 (player.x < self->x) ? self->dx = -3 : self->dx = 3;
 364
 365                 self->think = &galdovMiniAttack;
 366                 self->setActionFinished(45);
 367         }
 368 }
 369
 370 void galdovMiniAttack()
 371 {
 372         if (player.health < 1)
 373         {
 374                 self->dx = self->dy = 0;
 375                 return;
 376         }
 377
 378         (self->x < player.x) ? self->face = 0 : self->face = 1;
 379
 380         self->think = &galdovMiniAttack;
 381         self->setThinkTime(2);
 382         self->setActionFinished(2);
 383
 384         int r = rand() % 100;
 385
 386         if (r < 10)
 387         {
 388                 self->think = &galdovMiniFire;
 389                 self->custom = Math::rrand(1, 8);
 390         }
 391         else if (r < 15)
 392         {
 393                 addTeleportParticles(self->x + 10, self->y + 10, 50, SND_TELEPORT2);
 394                 self->x = -9999;
 395                 self->y = -9999;
 396                 self->setActionFinished(120);
 397                 self->setThinkTime(2);
 398                 self->think = &galdovFinalTeleport;
 399         }
 400         else if (r < 80)
 401         {
 402                 self->think = &galdovMiniChasePlayer;
 403         }
 404         else if (r < 90)
 405         {
 406                 self->think = &galdovMiniMoveRandom;
 407         }
 408         else
 409         {
 410                 if ((self->flags & ENT_FLIES) && (rand() % 5) == 0)
 411                 {
 412                         Math::removeBit(&self->flags, ENT_FLIES);
 413                         Math::removeBit(&self->flags, ENT_FIRETRAIL);
 414                 }
 415                 else
 416                 {
 417                         Math::addBit(&self->flags, ENT_FLIES);
 418                         Math::addBit(&self->flags, ENT_FIRETRAIL);
 419                 }
 420         }
 421 }
 422
 423 void galdovMiniDie()
 424 {
 425         addExplosion(self->x, self->y, 5, self);
 426         dropItems((int)self->x, (int)self->y);
 427         self->setThinkTime(2);
 428         self->setActionFinished(2);
 429         self->active = false;
 430         self->place(9999, 9999);
 431
 432         // Don't kill it properly(!!)
 433         self->health = -1;
 434
 435         bool allDead = true;
 436
 437         for (int i = 1 ; i < 10 ; i++)
 438         {
 439                 if (map.boss[i]->health > 0)
 440                 {
 441                         allDead = false;
 442                 }
 443         }
 444
 445         if (allDead)
 446         {
 447                 map.boss[0]->think = &galdovFinalDropCrystal;
 448                 map.boss[0]->setThinkTime(2);
 449                 map.boss[0]->setActionFinished(2);
 450         }
 451 }
 452
 453 void galdovRejoin()
 454 {
 455         debug("boss", 2) << "galdovRejoin" << std::endl;
 456
 457         for (int i = 1 ; i < 10 ; i++)
 458         {
 459                 if (map.boss[i] != NULL)
 460                 {
 461                         addTeleportParticles(map.boss[i]->x + 4, map.boss[i]->y + 4, 75, -1);
 462
 463                         if ((rand() % (2 + (game.skill))) == 0)
 464                         {
 465                                 dropItems((int)map.boss[i]->x, (int)map.boss[i]->y);
 466                         }
 467
 468                         map.boss[i]->place(9999, 9999);
 469                         map.boss[i]->active = false;
 470                 }
 471         }
 472
 473         self->setThinkTime(2);
 474         self->setActionFinished(120);
 475         self->think = &galdovFinalTeleport;
 476         self->currentWeapon = getRandomGaldovWeapon();
 477
 478         audio.playSound(SND_BOSSCUSTOM1, CH_AMBIANCE);
 479
 480         map.setMainBossPart(map.boss[0]);
 481
 482         debug("boss", 2) << "galdovRejoin: Done" << std::endl;
 483 }
 484
 485 void galdovFinalMiniReact()
 486 {
 487         if (self->health > 0)
 488         {
 489                 map.setMainBossPart(self);
 490         }
 491         else
 492         {
 493                 map.setMainBossPart(NULL);
 494         }
 495 }
 496
 497 void galdovFinalSplit()
 498 {
 499         debug("boss", 2) << "galdovFinalSplit" << std::endl;
 500
 501         for (int i = 1 ; i < 10 ; i++)
 502         {
 503                 if (map.boss[i] == NULL)
 504                 {
 505                         map.boss[i] = new Boss();
 506                         strcpy(map.boss[i]->name, "MiniGaldov");
 507                         map.boss[i]->health = 10 * game.skill;
 508                         map.boss[i]->maxHealth = 10 * game.skill;
 509                 }
 510                 map.boss[i]->setSprites(graphics.getSprite("GaldovMiniRight", true), graphics.getSprite("GaldovMiniLeft", true), graphics.getSprite("GaldovMiniLeft", true));
 511                 map.boss[i]->currentWeapon = getRandomAimedWeapon();
 512                 map.boss[i]->face = 0;
 513                 map.boss[i]->active = true;
 514
 515                 if (map.boss[i]->health > 0)
 516                 {
 517                         map.boss[i]->dx = Math::rrand(-2, 2);
 518                         map.boss[i]->dy = Math::rrand(-2, 2);
 519                         map.boss[i]->x = map.boss[0]->x;
 520                         map.boss[i]->y = map.boss[0]->y;
 521                 }
 522                 else
 523                 {
 524                         map.boss[i]->active = false;
 525                 }
 526
 527                 map.boss[i]->immune = 0;
 528                 map.boss[i]->setThinkTime(2);
 529                 map.boss[i]->setActionFinished(120);
 530                 map.boss[i]->think = &galdovMiniAttack;
 531                 map.boss[i]->react = &galdovFinalMiniReact;
 532                 map.boss[i]->die = &galdovMiniDie;
 533                 Math::addBit(&map.boss[i]->flags, ENT_AIMS);
 534                 Math::addBit(&map.boss[i]->flags, ENT_FLIES);
 535                 Math::addBit(&map.boss[i]->flags, ENT_FIRETRAIL);
 536
 537                 addTeleportParticles(map.boss[i]->x + 10 + map.boss[i]->dx, map.boss[i]->y + 10 + map.boss[i]->dy, 75, -1);
 538         }
 539
 540         map.boss[0]->place(9999, 9999);
 541         map.boss[0]->setThinkTime(2);
 542         map.boss[0]->setActionFinished(Math::rrand(10, 15) * 60);
 543         map.boss[0]->think = &galdovRejoin;
 544         map.boss[0]->active = true;
 545
 546         audio.playSound(SND_BOSSCUSTOM1, CH_AMBIANCE);
 547         map.setMainBossPart(NULL);
 548
 549         debug("boss", 2) << "galdovFinalSplit: Done" << std::endl;
 550 }
 551
 552 void galdovFinalReact()
 553 {
 554         map.boss[0]->health = 45 * game.skill;
 555
 556         if ((rand() % 5) == 0)
 557         {
 558                 map.boss[0]->setThinkTime(2);
 559                 map.boss[0]->setActionFinished(2);
 560                 map.boss[0]->think = &galdovFinalSplit;
 561         }
 562 }
 563
 564 void galdovFinalInit()
 565 {
 566         debug("boss", 2) << "galdovFinalInit" << std::endl;
 567
 568         map.boss[0] = new Boss();
 569         strcpy(map.boss[0]->name, "Galdov");
 570         map.boss[0]->health = 45 * game.skill;
 571         map.boss[0]->maxHealth = 45 * game.skill;
 572         map.boss[0]->setSprites(graphics.getSprite("GaldovRight", true), graphics.getSprite("GaldovLeft", true), graphics.getSprite("GaldovDie", true));
 573         map.boss[0]->currentWeapon = &weapon[WP_AIMEDPISTOL];
 574         map.boss[0]->face = 0;
 575         map.boss[0]->active = true;
 576         map.boss[0]->x = 480;
 577         map.boss[0]->y = 576;
 578         map.boss[0]->immune = 0;
 579         map.boss[0]->setThinkTime(2);
 580         map.boss[0]->setActionFinished(2);
 581         map.boss[0]->think = &galdovMiniAttack;
 582         //map.boss[0]->think = &galdovFinalDropCrystal;
 583         map.boss[0]->react = &galdovFinalReact;
 584         map.boss[0]->die = &galdovFinalDie;
 585         Math::addBit(&map.boss[0]->flags, ENT_AIMS);
 586
 587         audio.loadSound(SND_BOSSCUSTOM1, "sound/galdovSplit.wav");
 588         audio.loadSound(SND_BOSSCUSTOM2, "sound/galdovPain.wav");
 589         audio.loadSound(SND_BOSSCUSTOM3, "sound/galdovDie.wav");
 590
 591         map.setMainBossPart(map.boss[0]);
 592
 593         debug("boss", 2) << "galdovFinalInit: Done" << std::endl;
 594 }
 595
 596 // ******************** Second part of Final Battle *********************************
 597
 598 void galdovFinalReact2()
 599 {
 600         if (self->health < 1)
 601                 return;
 602
 603         if ((rand() % 12) == 0)
 604         {
 605                 addTeleportParticles(self->x + (self->width / 2), self->y + (self->height / 2), 50, SND_TELEPORT3);
 606                 map.boss[0]->setThinkTime(2);
 607                 map.boss[0]->setActionFinished(2);
 608                 map.boss[0]->think = &galdovFinalTeleport;
 609         }
 610 }
 611
 612 void galdovFinalStandUp()
 613 {
 614         map.boss[0]->setSprites(graphics.getSprite("GaldovShieldRight", true), graphics.getSprite("GaldovShieldLeft", true), graphics.getSprite("GaldovShieldLeft", true));
 615         self->setThinkTime(2);
 616         self->setActionFinished(2);
 617         addTeleportParticles(self->x + (self->width / 2), self->y + (self->height / 2), 50, SND_TELEPORT3);
 618         self->think = &galdovFinalTeleport;
 619
 620         if (map.boss[0]->health <= 15 * game.skill)
 621         {
 622                 self->setSprites(graphics.getSprite("GaldovRight", true), graphics.getSprite("GaldovLeft", true), graphics.getSprite("GaldovDie", true));
 623                 Math::removeBit(&map.boss[0]->flags, ENT_IMMUNE);
 624                 map.boss[0]->react = &galdovFinalReact2;
 625         }
 626 }
 627
 628 void galdovFinalPainThrow2()
 629 {
 630         self->dx = -3;
 631         self->dy = -12;
 632
 633         self->think = &galdovFinalStandUp;
 634         self->setThinkTime(2);
 635         self->setActionFinished(90);
 636 }
 637
 638 void orbSeekGaldov()
 639 {
 640         (self->x < player.x) ? self->face = 0 : self->face = 1;
 641
 642         float dx, dy;
 643
 644         Math::calculateSlope(map.boss[0]->x, map.boss[0]->y, self->x, self->y, &dx, &dy);
 645
 646         self->dx = (dx * (1 + game.skill));
 647         self->dy = (dy * (1 + game.skill));
 648
 649         self->setThinkTime(2);
 650         self->setActionFinished(5);
 651         self->think = &orbSeekGaldov;
 652
 653         int distX = (int)fabs(map.boss[0]->x - self->x);
 654         int distY = (int)fabs(map.boss[0]->y - self->y);
 655
 656         distX *= distX;
 657         distY *= distY;
 658
 659         int distance = (int)sqrt(distX + distY);
 660
 661         if (distance <= 10)
 662         {
 663                 self->active = false;
 664                 self->setActionFinished(60);
 665                 self->setThinkTime(60);
 666                 addExplosion(self->x, self->y, 75, &player);
 667                 self->place(9999, 9999);
 668                 map.boss[0]->setSprites(graphics.getSprite("GaldovPain", true), graphics.getSprite("GaldovPain", true), graphics.getSprite("GaldovPain", true));
 669                 map.boss[0]->think = &galdovFinalPainThrow2;
 670                 map.boss[0]->health -= (3 * game.skill);
 671                 Math::removeBit(&map.boss[0]->flags, ENT_FLIES);
 672                 Math::removeBit(&map.boss[0]->flags, ENT_FIRETRAIL);
 673                 audio.playSound(SND_BOSSCUSTOM2, CH_AMBIANCE);
 674         }
 675 }
 676
 677 void galdovFinalShieldInit()
 678 {
 679         self->setActionFinished(60);
 680         self->setThinkTime(60);
 681         self->think = &galdovMiniAttack;
 682         self->react = NULL;
 683
 684         Math::addBit(&map.boss[0]->flags, ENT_IMMUNE);
 685
 686         for (int i = 1 ; i < 6 ; i++)
 687         {
 688                 if (map.boss[i] != NULL)
 689                 {
 690                         delete map.boss[i];
 691                 }
 692                 map.boss[i] = new Boss();
 693                 strcpy(map.boss[i]->name, "OrbBomb");
 694                 map.boss[i]->setSprites(graphics.getSprite("DroidOrb", true), graphics.getSprite("DroidOrb", true), graphics.getSprite("DroidOrb", true));
 695                 map.boss[i]->health = 999999;
 696                 map.boss[i]->maxHealth = 99999;
 697                 map.boss[i]->immune = 0;
 698                 Math::addBit(&map.boss[0]->flags, ENT_IMMUNE);
 699                 map.boss[i]->active = false;
 700                 map.boss[i]->setActionFinished(2);
 701                 map.boss[i]->setThinkTime(2);
 702                 map.boss[i]->think = &orbSeekGaldov;
 703                 map.boss[i]->react = NULL;
 704                 Math::addBit(&map.boss[i]->flags, ENT_FLIES);
 705         }
 706
 707         map.boss[1]->place(864, 1536);
 708         map.boss[2]->place(864, 1792);
 709         map.boss[3]->place(1856, 1792);
 710         map.boss[4]->place(1888, 1440);
 711         map.boss[5]->place(1408, 1472);
 712
 713         galdovInitBlackDroids();
 714 }
 715
 716 void galdovFinalWaitForObjective()
 717 {
 718         self->setActionFinished(120);
 719         self->setThinkTime(2);
 720
 721         Objective *objective = (Objective*)map.objectiveList.getHead();
 722
 723         while (objective->next != NULL)
 724         {
 725                 objective = (Objective*)objective->next;
 726
 727                 if (strstr(objective->target, "Reality"))
 728                 {
 729                         if (objective->completed)
 730                         {
 731                                 player.dx = 1000;
 732                                 player.dy = 1408;
 733                                 Math::addBit(&player.flags, ENT_TELEPORTING);
 734                                 self->think = &galdovFinalShieldInit;
 735                                 map.boss[0]->setSprites(graphics.getSprite("GaldovShieldRight", true), graphics.getSprite("GaldovShieldLeft", true), graphics.getSprite("GaldovShieldLeft", true));
 736                                 self->setActionFinished(2);
 737                                 self->setThinkTime(2);
 738                                 map.setMainBossPart(map.boss[0]);
 739                         }
 740                 }
 741         }
 742 }
 743
 744 void galdovFinalFlee1()
 745 {
 746         self->dx = 800;
 747         self->dy = 1408;
 748         addTeleportParticles(self->x + (self->width / 2), self->y + (self->height / 2), 50, SND_TELEPORT3);
 749         Math::addBit(&self->flags, ENT_TELEPORTING);
 750         Math::addBit(&self->flags, ENT_FLIES);
 751         Math::addBit(&self->flags, ENT_FIRETRAIL);
 752         self->think = &galdovFinalWaitForObjective;
 753         self->setActionFinished(2);
 754         self->setThinkTime(2);
 755 }