src/CMap.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 "CMap.h"
  23 #include "CObjective.h"
  24 #include "CParticle.h"
  25 #include "CSpawnPoint.h"
  26 #include "CSwitch.h"
  27 #include "CTrain.h"
  28 #include "console/console.hpp"
  29
  30 Map::Map()
  31 {
  32         clear();
  33
  34         for (int i = 0 ; i < 10 ; i++)
  35         {
  36                 boss[i] = NULL;
  37         }
  38 }
  39
  40
  41 void Map::clear()
  42 {
  43         fightingGaldov = false;
  44         bossNextThink = 0;
  45
  46         foundItems = totalItems = 0;
  47         foundMIAs = totalMIAs = 0;
  48         requiredMIAs = 0;
  49
  50         limitLeft = limitUp = 0;
  51         limitRight = ((MAPWIDTH - 40) * BRICKSIZE);
  52         limitDown = ((MAPHEIGHT - 30) * BRICKSIZE);
  53
  54         strcpy(name, "");
  55
  56         for (int x = 0 ; x < MAPWIDTH ; x++)
  57                 for (int y = 0 ; y < MAPHEIGHT ; y++)
  58                         data[x][y] = 0;
  59
  60         for (int i = 0 ; i < 10 ; i++)
  61                 allowableEnemy[i] = NULL;
  62
  63         maxAllowableEnemies = 0;
  64
  65         trainList.clear();
  66         itemList.clear();
  67         bulletList.clear();
  68         enemyList.clear();
  69         miaList.clear();
  70         obstacleList.clear();
  71         particleList.clear();
  72         switchList.clear();
  73         spawnList.clear();
  74         effectList.clear();
  75         objectiveList.clear();
  76         teleportList.clear();
  77         lineList.clear();
  78         trapList.clear();
  79
  80         remainingMinutes = 0;
  81         remainingSeconds = 0;
  82
  83         waterLevel = requiredWaterLevel = -1;
  84         isBossMission = false;
  85         isIceLevel = false;
  86         isBlizzardLevel = false;
  87         isCavesTileset = false;
  88         isGrasslandsTileset = false;
  89         bossNextThink = 0;
  90         mainBossPart = NULL;
  91         doBossLevelAction = NULL;
  92         bossEnergyMeterBit = 0;
  93
  94         for (int i = 0 ; i < 10 ; i++)
  95         {
  96                 if (boss[i] != NULL)
  97                 {
  98                         delete boss[i];
  99                 }
 100                 boss[i] = NULL;
 101         }
 102
 103         windPower = windChangeTime = 0;
 104 }
 105
 106 void Map::destroy()
 107 {
 108         clear();
 109
 110         persistantList.clear();
 111 }
 112
 113 bool Map::isPracticeMission()
 114 {
 115         if (strstr(name, "Practice"))
 116                 return true;
 117
 118         return false;
 119 }
 120
 121 bool Map::isSolid(int x, int y)
 122 {
 123         if ((data[x][y] >= MAP_BREAKABLE) && (data[x][y] < MAP_DECORATION))
 124         {
 125                 return true;
 126         }
 127
 128         return false;
 129 }
 130
 131 bool Map::isBreakable(int x, int y)
 132 {
 133         if ((data[x][y] >= MAP_BREAKABLE) && (data[x][y] <= MAP_BREAKABLE2))
 134         {
 135                 return true;
 136         }
 137
 138         return false;
 139 }
 140
 141 bool Map::isNoReset(int x, int y)
 142 {
 143         if ((data[x][y] >= MAP_NORESET) && (data[x][y] < MAP_DECORATION))
 144         {
 145                 return true;
 146         }
 147
 148         return false;
 149 }
 150
 151 bool Map::isLiquid(int x, int y)
 152 {
 153         if (data[x][y] == 0)
 154         {
 155                 return false;
 156         }
 157         else if ((data[x][y] >= MAP_WATER) && (data[x][y] <= MAP_LAVA))
 158         {
 159                 return true;
 160         }
 161         else if ((data[x][y] >= MAP_WATERANIM) && (data[x][y] <= MAP_LAVAANIM))
 162         {
 163                 return true;
 164         }
 165
 166         return false;
 167 }
 168
 169 bool Map::isTopLayer(int x, int y)
 170 {
 171         if (data[x][y] >= MAP_TOPLAYER)
 172         {
 173                 return true;
 174         }
 175
 176         return false;
 177 }
 178
 179 Persistant *Map::getPersistant(char *name)
 180 {
 181         Persistant *p = (Persistant*)persistantList.getHead();
 182
 183         while (p->next != NULL)
 184         {
 185                 p = (Persistant*)p->next;
 186
 187                 if (strcmp(p->stageName, name) == 0)
 188                 {
 189                         return p;
 190                 }
 191         }
 192
 193         return NULL;
 194 }
 195
 196 Persistant *Map::createPersistant(char *name)
 197 {
 198         Persistant *p = (Persistant*)persistantList.getHead();
 199
 200         while (p->next != NULL)
 201         {
 202                 p = (Persistant*)p->next;
 203
 204                 if (strcmp(p->stageName, name) == 0)
 205                 {
 206                         return p;
 207                 }
 208         }
 209
 210         debug("pers", 1) << "Creating '" << name << "' in persistance list..." << std::endl;
 211
 212         p = new Persistant();
 213         p->setName(name);
 214
 215         persistantList.add(p);
 216
 217         return p;
 218 }
 219
 220 void Map::destroyPersistant(char *name)
 221 {
 222         Persistant *p = (Persistant*)persistantList.getHead();
 223
 224         while (p->next != NULL)
 225         {
 226                 p = (Persistant*)p->next;
 227
 228                 if (strcmp(p->stageName, name) == 0)
 229                 {
 230                         strcpy(p->stageName, "@none@");
 231                         p->clear();
 232                         return;
 233                 }
 234         }
 235 }
 236
 237 void Map::setName(char *name)
 238 {
 239         strcpy(this->name, name);
 240
 241         if (strstr(name, "BioMech"))
 242         {
 243                 isBossMission = true;
 244         }
 245
 246         if (strcmp(name, "Galdov") == 0)
 247         {
 248                 isBossMission = true;
 249         }
 250
 251         if (strcmp(name, "Final Battle") == 0)
 252         {
 253                 isBossMission = true;
 254         }
 255
 256         if (strstr(name, "Ice"))
 257         {
 258                 isIceLevel = true;
 259         }
 260
 261         if (strstr(name, "Arctic"))
 262         {
 263                 isIceLevel = true;
 264                 isBlizzardLevel = true;
 265         }
 266 }
 267
 268 void Map::setClipping(int limitLeft, int limitRight, int limitUp, int limitDown)
 269 {
 270         if (limitLeft != -1) this->limitLeft = limitLeft;
 271         if (limitRight != -1) this->limitRight = limitRight;
 272         if (limitUp != -1) this->limitUp = limitUp;
 273         if (limitDown != -1) this->limitDown = limitDown;
 274 }
 275
 276 void Map::addTrain(char *name, int startX, int startY, int endX, int endY, int pause, bool atStart, bool active)
 277 {
 278         Train *train = new Train();
 279         train->setName(name);
 280         train->type = TR_TRAIN;
 281         train->set(startX, startY, endX, endY, pause, atStart);
 282         train->active = active;
 283
 284         train->width = 64;
 285         train->height = 16;
 286
 287         if (pause == 0)
 288         {
 289                 warning << "Train with 0 wait time added '" << name << "' (" << startX << ":" << startY << ")" << std::endl;
 290         }
 291
 292         trainList.add(train);
 293 }
 294
 295 void Map::addDoor(char *name, int type, int startX, int startY, int endX, int endY, bool active)
 296 {
 297         Train *train = new Train();
 298         train->setName(name);
 299
 300         train->type = type;
 301
 302         train->set(startX, startY, endX, endY, 0, false);
 303         train->active = active;
 304
 305         if (type < TR_SLIDEDOOR)
 306         {
 307                 train->width = 16;
 308                 train->height = 64;
 309         }
 310         else
 311         {
 312                 train->width = 64;
 313                 train->height = 16;
 314         }
 315
 316         trainList.add(train);
 317 }
 318
 319 void Map::addSwitch(char *name, char *linkName, char *requiredObjectName, char *activateMessage, int type, int x, int y, bool activated)
 320 {
 321         Switch *swt = new Switch();
 322         swt->set(name, linkName, requiredObjectName, activateMessage, type, x, y, activated);
 323
 324         switchList.add(swt);
 325 }
 326
 327 void Map::addItem(Entity *item)
 328 {
 329         itemList.add(item);
 330 }
 331
 332 void Map::addBullet(Entity *bullet)
 333 {
 334         bulletList.add(bullet);
 335 }
 336
 337 void Map::addParticle(float x, float y, float dx, float dy, int health, int color, Sprite *sprite, int flags)
 338 {
 339         Particle *particle = new Particle();
 340         particle->set(x, y, dx, dy, color, health, flags);
 341         particle->setSprite(sprite);
 342
 343         particleList.add(particle);
 344 }
 345
 346 void Map::addEnemy(Entity *enemy)
 347 {
 348         enemyList.add(enemy);
 349 }
 350
 351 void Map::addMIA(Entity *mia)
 352 {
 353         miaList.add(mia);
 354 }
 355
 356 void Map::addObstacle(Entity *obstacle)
 357 {
 358         obstacleList.add(obstacle);
 359 }
 360
 361 void Map::addSpawnPoint(char *name, int x, int y, int type, int subtype, int min, int max, bool active)
 362 {
 363         SpawnPoint *spawnPoint = new SpawnPoint();
 364         spawnPoint->create(name, x, y, type, subtype, min, max, active);
 365
 366         spawnList.add(spawnPoint);
 367 }
 368
 369 void Map::addEffect(Effect *effect)
 370 {
 371         effectList.add(effect);
 372 }
 373
 374 void Map::addObjective(char *description, char *target, int targetValue, bool required)
 375 {
 376         Objective *objective = new Objective(description, target, targetValue, required);
 377
 378         objectiveList.add(objective);
 379 }
 380
 381 void Map::addTeleporter(Teleporter *teleporter)
 382 {
 383         teleportList.add(teleporter);
 384 }
 385
 386 void Map::addLineDef(LineDef *lineDef)
 387 {
 388         lineList.add(lineDef);
 389 }
 390
 391 void Map::addTrap(Trap *trap)
 392 {
 393         trapList.add(trap);
 394 }
 395
 396 void Map::evalTileset(char *baseDir)
 397 {
 398         if (strstr(baseDir, "caves"))
 399         {
 400                 isCavesTileset = true;
 401         }
 402         else if (strstr(baseDir, "grasslands"))
 403         {
 404                 isGrasslandsTileset = true;
 405         }
 406 }
 407
 408 void Map::killAllEnemies()
 409 {
 410         Entity *enemy = (Entity*)enemyList.getHead()->next;
 411
 412         while (enemy != NULL)
 413         {
 414                 enemy->health = -1;
 415
 416                 enemy = (Entity*)enemy->next;
 417         }
 418 }
 419
 420 void Map::setAllowableEnemy(Entity *enemy)
 421 {
 422         for (int i = 0 ; i < 10 ; i++)
 423         {
 424                 if (allowableEnemy[i] == NULL)
 425                 {
 426                         allowableEnemy[i] = enemy;
 427                         maxAllowableEnemies = i + 1;
 428                         return;
 429                 }
 430         }
 431
 432         warning << "Can't add anymore spawnable enemies to list!" << std::endl;
 433 }
 434
 435 char *Map::getSpawnableEnemy(int i)
 436 {
 437         if (allowableEnemy[i] == NULL)
 438                 return NULL;
 439
 440         return allowableEnemy[i]->name;
 441 }
 442
 443 char *Map::getSpawnableEnemy()
 444 {
 445         if (maxAllowableEnemies == 0)
 446         {
 447                 printf("ERROR: No enemy spawn list defined for map '%s'!! Please report this Error!\n", name);
 448                 exit(1);
 449         }
 450
 451         return allowableEnemy[rand() % maxAllowableEnemies]->name;
 452 }
 453
 454 void Map::getRandomEntityPosition(int *x, int *y)
 455 {
 456         Entity *ent = (Entity*)miaList.getHead();
 457
 458         while (ent->next != NULL)
 459         {
 460                 ent = (Entity*)ent->next;
 461
 462                 if ((rand() % 5) == 0)
 463                 {
 464                         *x = (int)ent->x;
 465                         *y = (int)ent->y;
 466                         return;
 467                 }
 468         }
 469
 470         ent = (Entity*)enemyList.getHead();
 471
 472         while (ent->next != NULL)
 473         {
 474                 ent = (Entity*)ent->next;
 475
 476                 if ((rand() % 5) == 0)
 477                 {
 478                         *x = (int)ent->x;
 479                         *y = (int)ent->y;
 480                         return;
 481                 }
 482         }
 483
 484         ent = (Entity*)itemList.getHead();
 485
 486         while (ent->next != NULL)
 487         {
 488                 ent = (Entity*)ent->next;
 489
 490                 if ((rand() % 5) == 0)
 491                 {
 492                         *x = (int)ent->x;
 493                         *y = (int)ent->y;
 494                         return;
 495                 }
 496         }
 497 }
 498
 499 void Map::setMainBossPart(Boss *boss)
 500 {
 501         mainBossPart = boss;
 502
 503         if (mainBossPart != NULL)
 504         {
 505                 bossEnergyMeterBit = 200;
 506                 bossEnergyMeterBit /= boss->maxHealth;
 507         }
 508 }