src/mapData.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 "CAudio.h"
  23 #include "CGame.h"
  24 #include "CGameData.h"
  25 #include "CGraphics.h"
  26 #include "CMap.h"
  27 #include "CPersistant.h"
  28 #include "CPersistData.h"
  29 #include "CSwitch.h"
  30 #include "CTrain.h"
  31 #include "CSpawnPoint.h"
  32 #include "console/console.hpp"
  33 #include "gettext.hpp"
  34 #include "mapData.h"
  35
  36 void getMapTokens()
  37 {
  38         char skillLevel[10];
  39         char mapEntity[255];
  40         char string[10][1024];
  41         int param[10];
  42         bool allowAtSkillLevel = false;
  43
  44         bool previouslyCleared = false;
  45
  46         char *token = NULL;
  47
  48         Persistant *persistant = NULL;
  49         PersistData *persistData = NULL;
  50
  51         while (true)
  52         {
  53                 if (!previouslyCleared)
  54                 {
  55                         token = strtok(NULL, "\n");
  56                 }
  57                 else
  58                 {
  59                         persistData = (PersistData*)persistData->next;
  60
  61                         if (persistData == NULL)
  62                                 break;
  63
  64                         token = persistData->data;
  65                 }
  66
  67                 graphics.showLoading(1, 100);
  68                 graphics.delay(1);
  69
  70                 allowAtSkillLevel = false;
  71
  72                 sscanf(token, "%s", skillLevel);
  73
  74                 if ((strstr(skillLevel, "E")) && (game.skill == 0))
  75                 {
  76                         allowAtSkillLevel = true;
  77                 }
  78
  79                 if ((strstr(skillLevel, "M")) && (game.skill == 1))
  80                 {
  81                         allowAtSkillLevel = true;
  82                 }
  83
  84                 if ((strstr(skillLevel, "H")) && (game.skill >= 2))
  85                 {
  86                         allowAtSkillLevel = true;
  87                 }
  88
  89                 if ((strstr(skillLevel, "X")) && (game.skill == 3))
  90                 {
  91                         allowAtSkillLevel = true;
  92                 }
  93
  94                 // This is just for practice missions
  95                 if (game.skill == -1)
  96                         allowAtSkillLevel = true;
  97
  98                 // Ignore comments
  99                 if (strstr(skillLevel, "//"))
 100                         allowAtSkillLevel = false;
 101
 102                 if (strcmp("@EOF@", skillLevel) == 0)
 103                 {
 104                         break;
 105                 }
 106
 107                 if (allowAtSkillLevel)
 108                 {
 109                         sscanf(token, "%*s %s", mapEntity);
 110
 111                         if (strcmp("STAGENAME", mapEntity) == 0)
 112                         {
 113                                 sscanf(token, "%*s %*s %*c %[^\"] %*c", string[0]);
 114
 115                                 map.setName(string[0]);
 116                                 game.setStageName(string[0]);
 117                         }
 118                         else if (strcmp("PREVIOUSLY_VISITED", mapEntity) == 0)
 119                         {
 120                                 previouslyCleared = gameData.stagePreviouslyCleared(map.name);
 121
 122                                 if (previouslyCleared)
 123                                 {
 124                                         debug("pers", 2) << "Reading Persistance Data..." << std::endl;
 125                                         persistant = map.getPersistant(map.name);
 126                                         persistData = (PersistData*)persistant->dataList.getHead();
 127                                 }
 128                         }
 129                         else if (strcmp("TIMELIMIT", mapEntity) == 0)
 130                         {
 131                                 sscanf(token, "%*s %*s %d %d", &param[0], &param[1]);
 132                                 map.remainingMinutes = param[0];
 133                                 map.remainingSeconds = param[1];
 134                         }
 135                         else if (strcmp("TRAIN", mapEntity) == 0)
 136                         {
 137                                 sscanf(token, "%*s %*s %s %d %d %d %d %d %s %s", string[0], &param[0], &param[1], &param[2], &param[3], &param[4], string[1], string[2]);
 138                                 map.addTrain(string[0], param[0], param[1], param[2], param[3], param[4], engine.getValueOfDefine(string[1]), engine.getValueOfDefine(string[2]));
 139                         }
 140                         else if (strcmp("DOOR", mapEntity) == 0)
 141                         {
 142                                 sscanf(token, "%*s %*s %s %s %d %d %d %d %s", string[0], string[1], &param[0], &param[1], &param[2], &param[3], string[2]);
 143                                 map.addDoor(string[0], engine.getValueOfDefine(string[1]), param[0], param[1], param[2], param[3], engine.getValueOfDefine(string[2]));
 144                         }
 145                         else if (strcmp("SWITCH", mapEntity) == 0)
 146                         {
 147                                 sscanf(token, "%*s %*s %*c %[^\"] %*c %s %*c %[^\"] %*c %*c %[^\"] %*c %s %d %d %s", string[0], string[1], string[2], string[3], string[4], &param[0], &param[1], string[5]);
 148                                 map.addSwitch(string[0], string[1], string[2], string[3], engine.getValueOfDefine(string[4]), param[0], param[1], engine.getValueOfDefine(string[5]));
 149                         }
 150                         else if (strcmp("ITEM", mapEntity) == 0)
 151                         {
 152                                 sscanf(token, "%*s %*s %d %*c %[^\"] %*c %d %d %s", &param[0], string[0], &param[1], &param[2], string[1]);
 153
 154                                 addItem(param[0], string[0], param[1], param[2], string[1], 60, 1, 0, false);
 155
 156                                 if (param[0] >= ITEM_MISC)
 157                                 {
 158                                         map.totalItems++;
 159                                 }
 160                         }
 161                         else if (strcmp("OBSTACLE", mapEntity) == 0)
 162                         {
 163                                 sscanf(token, "%*s %*s %*c %[^\"] %*c %d %d %s", string[0], &param[0], &param[1], string[1]);
 164
 165                                 addObstacle(string[0], param[0], param[1], string[1]);
 166                         }
 167                         else if (strcmp("OBJECTIVE", mapEntity) == 0)
 168                         {
 169                                 sscanf(token, "%*s %*s %*c %[^\"] %*c %*c %[^\"] %*c %d %s", string[0], string[1], &param[0], string[2]);
 170
 171                                 map.addObjective(string[0], string[1], param[0], engine.getValueOfDefine(string[2]));
 172                         }
 173                         else if (strcmp("START", mapEntity) == 0)
 174                         {
 175                                 sscanf(token, "%*s %*s %d %d", &param[0], &param[1]);
 176
 177                                 player.place(param[0], param[1]);
 178
 179                                 game.setCheckPoint(param[0], param[1]);
 180                                 game.setObjectiveCheckPoint();
 181
 182                         }
 183                         else if (strcmp("ENEMY", mapEntity) == 0)
 184                         {
 185                                 if (!engine.devNoMonsters)
 186                                 {
 187                                         sscanf(token, "%*s %*s %*c %[^\"] %*c %d %d", string[0], &param[0], &param[1]);
 188
 189                                         if ((game.skill == 0) && (map.waterLevel != -1))
 190                                         {
 191                                                 addEnemy("Aqua Blob", param[0], param[1], 0);
 192                                         }
 193                                         else
 194                                         {
 195                                                 addEnemy(string[0], param[0], param[1], 0);
 196                                         }
 197                                 }
 198                         }
 199                         else if (strcmp("MIA", mapEntity) == 0)
 200                         {
 201                                 sscanf(token, "%*s %*s %*c %[^\"] %*c %d %d %s", string[0], &param[0], &param[1], string[1]);
 202                                 addMIA(string[0], param[0], param[1], engine.getValueOfDefine(string[1]));
 203                                 map.totalMIAs++;
 204                         }
 205                         else if (strcmp("REQUIREDMIAS", mapEntity) == 0)
 206                         {
 207                                 sscanf(token, "%*s %*s %d", &param[0]);
 208                                 map.requiredMIAs = param[0];
 209                         }
 210                         else if (strcmp("LINEDEF", mapEntity) == 0)
 211                         {
 212                                 sscanf(token, "%*s %*s %*c %[^\"] %*c %s %*c %[^\"] %*c %d %d %d %d %s", string[0], string[1], string[2], &param[0], &param[1], &param[2], &param[3], string[3]);
 213
 214                                 addLineDef(string[0], string[1], string[2], param[0], param[1], param[2], param[3], engine.getValueOfDefine(string[3]));
 215                         }
 216                         else if (strcmp("SPAWNPOINT", mapEntity) == 0)
 217                         {
 218                                 sscanf(token, "%*s %*s %s %d %d %s %s %d %d %s", string[0], &param[0], &param[1], string[1], string[2], &param[2], &param[3], string[3]);
 219                                 map.addSpawnPoint(string[0], param[0], param[1], engine.getValueOfDefine(string[1]), engine.getValueOfDefine(string[2]), param[2], param[3], engine.getValueOfDefine(string[3]));
 220                         }
 221                         else if (strcmp("SPAWNABLE_ENEMY", mapEntity) == 0)
 222                         {
 223                                 sscanf(token, "%*s %*s %*c %[^\"] %*c", string[0]);
 224                                 map.setAllowableEnemy(getDefinedEnemy(string[0]));
 225                         }
 226                         else if (strcmp("TELEPORTER", mapEntity) == 0)
 227                         {
 228                                 sscanf(token, "%*s %*s %s %d %d %d %d %s", string[0], &param[0], &param[1], &param[2], &param[3], string[1]);
 229                                 addTeleporter(string[0], param[0], param[1], param[2], param[3], engine.getValueOfDefine(string[1]));
 230                         }
 231                         else if (strcmp("TRAP", mapEntity) == 0)
 232                         {
 233                                 sscanf(token, "%*s %*s %s %s %d %d %d %d %d %d %d %d %s %s", string[0], string[1], &param[0], &param[1], &param[2], &param[3], &param[4], &param[5], &param[6], &param[7], string[2], string[3]);
 234                                 addTrap(string[0], engine.getValueOfDefine(string[1]), param[0], param[1], param[2], param[3], param[4], param[5], param[6], param[7], string[2], engine.getValueOfDefine(string[3]));
 235                         }
 236                         else if (strcmp("SPRITE", mapEntity) == 0)
 237                         {
 238                                 sscanf(token, "%*s %*s %[^\n\r]", string[0]);
 239                                 loadSprite(string[0]);
 240                         }
 241                         else if (strcmp("DEFENEMY", mapEntity) == 0)
 242                         {
 243                                 sscanf(token, "%*s %*s %[^\n\r]", string[0]);
 244                                 loadEnemy(string[0]);
 245                         }
 246                         else if (strcmp("TILESET", mapEntity) == 0)
 247                         {
 248                                 sscanf(token, "%*s %*s %s", string[0]);
 249                                 map.evalTileset(string[0]);
 250                                 graphics.loadMapTiles(string[0]);
 251                         }
 252                         else if (strcmp("CLIPPING", mapEntity) == 0)
 253                         {
 254                                 sscanf(token, "%*s %*s %d %d %d %d", &param[0], &param[1], &param[2], &param[3]);
 255                                 map.setClipping(param[0], param[1], param[2], param[3]);
 256                         }
 257                         else if (strcmp("AMBIENCE", mapEntity) == 0)
 258                         {
 259                                 sscanf(token, "%*s %*s %s", string[0]);
 260                                 if (!audio.loadSound(SND_AMBIANCE, string[0]))
 261                                         graphics.showErrorAndExit(ERR_FILE, string[0]);
 262                         }
 263                         else if (strcmp("WATERLEVEL", mapEntity) == 0)
 264                         {
 265                                 sscanf(token, "%*s %*s %d", &param[0]);
 266
 267                                 map.requiredWaterLevel = param[0];
 268
 269                                 if (!previouslyCleared)
 270                                 {
 271                                         map.waterLevel = param[0];
 272                                 }
 273                                 else
 274                                 {
 275                                         map.waterLevel = 281;
 276                                 }
 277
 278                                 if (game.skill == 0)
 279                                 {
 280                                         map.waterLevel = 281;
 281                                         map.requiredWaterLevel = 222;
 282                                 }
 283                         }
 284                         else if (strcmp("ALPHATILES", mapEntity) == 0)
 285                         {
 286                                 for (int i = 0 ; i < 15 ; i++)
 287                                         *token++;
 288
 289                                 while (true)
 290                                 {
 291                                         sscanf(token, "%d", &param[0]);
 292
 293                                         if (param[0] == -1)
 294                                                 break;
 295
 296                                         debug("misc", 3) << "Setting Alpha for Tile " << param[0] << std::endl;
 297
 298                                         SDL_SetAlpha(graphics.tile[param[0]], SDL_SRCALPHA|SDL_RLEACCEL, 128);
 299
 300                                         while (true)
 301                                         {
 302                                                 *token++;
 303
 304                                                 if (*token == ' ')
 305                                                         break;
 306                                         }
 307                                 }
 308                         }
 309                         else if (strcmp("BACKGROUND", mapEntity) == 0)
 310                         {
 311                                 sscanf(token, "%*s %*s %s", string[0]);
 312                                 graphics.loadBackground(string[0], true);
 313                         }
 314                         else if (strcmp("MUSIC", mapEntity) == 0)
 315                         {
 316                                 sscanf(token, "%*s %*s %s", string[0]);
 317                                 audio.loadMusic(string[0]);
 318                         }
 319                         else if (allowAtSkillLevel)
 320                         {
 321                                 graphics.showErrorAndExit(_("Symbol '%s' not recognised or not implemented in map data"), mapEntity);
 322                         }
 323                 }
 324                 else
 325                 {
 326                         //debug(("Ignoring Line: %s\n", token));
 327                 }
 328         }
 329
 330         /*
 331         We need to make sure the player doesn't appear in a wall that was previously
 332         destroyed. Things like this aren't stored so we will just remove a block they
 333         make have been "in"
 334         */
 335         if (previouslyCleared)
 336         {
 337                 int x = game.checkPointX;
 338                 int y = game.checkPointY;
 339
 340                 x = x >> BRICKSHIFT;
 341                 y = y >> BRICKSHIFT;
 342
 343                 if ((map.data[x][y] >= MAP_BREAKABLE) && (map.data[x][y] <= MAP_BREAKABLE2))
 344                 {
 345                         map.data[x][y] = MAP_AIR;
 346                 }
 347         }
 348 }
 349
 350 const char *getActiveState(bool active)
 351 {
 352         if (active)
 353         {
 354                 return "ACTIVE";
 355         }
 356
 357         return "INACTIVE";
 358 }
 359
 360 void createPersistantMapData()
 361 {
 362         if (!engine.loadDefines())
 363         {
 364                 graphics.showErrorAndExit(_("Could not load map define list '%s'"), "data/defines.h");
 365         }
 366
 367         Persistant *persistant = (Persistant*)map.createPersistant(map.name);
 368         persistant->clear();
 369
 370         if (perfectlyCompleted())
 371         {
 372                 debug("pers", 2) << "createPersistantMapData :: Perfect - Skipping" << std::endl;
 373                 return;
 374         }
 375
 376         char line[1024];
 377         strcpy(line, "");
 378
 379         char skill;
 380
 381         switch (game.skill)
 382         {
 383                 case 0:
 384                         skill = 'E';
 385                         break;
 386                 case 1:
 387                         skill = 'M';
 388                         break;
 389                 default:
 390                         skill = 'H';
 391                         break;
 392         }
 393
 394         sprintf(line, "%c START %d %d\n", skill, (int)game.checkPointX, (int)game.checkPointY);
 395         persistant->addLine(line);
 396
 397         Entity *ent;
 398         Switch *swt;
 399         Train *train;
 400         Trap *trap;
 401         Teleporter *teleporter;
 402         LineDef *lineDef;
 403         SpawnPoint *spawnPoint;
 404
 405         const char *define[3];
 406
 407         ent = (Entity*)map.enemyList.getHead();
 408
 409         while (ent->next != NULL)
 410         {
 411                 ent = (Entity*)ent->next;
 412                 sprintf(line, "%c ENEMY \"%s\" %d %d\n", skill, ent->name, (int)ent->x, (int)ent->y);
 413                 persistant->addLine(line);
 414         }
 415
 416         ent = (Entity*)map.itemList.getHead();
 417
 418         while (ent->next != NULL)
 419         {
 420                 ent = (Entity*)ent->next;
 421
 422                 // Don't save items that are dying...
 423                 if (ent->flags & ENT_DYING)
 424                 {
 425                         continue;
 426                 }
 427
 428                 sprintf(line, "%c ITEM %d \"%s\" %d %d %s\n", skill, ent->id, ent->name, (int)ent->x, (int)ent->y, ent->sprite[0]->name);
 429                 persistant->addLine(line);
 430         }
 431
 432         ent = (Entity*)map.obstacleList.getHead();
 433
 434         while (ent->next != NULL)
 435         {
 436                 ent = (Entity*)ent->next;
 437                 sprintf(line, "%c OBSTACLE \"%s\" %d %d %s\n", skill, ent->name, (int)ent->x, (int)ent->y, ent->sprite[0]->name);
 438                 persistant->addLine(line);
 439         }
 440
 441         swt = (Switch*)map.switchList.getHead();
 442
 443         while (swt->next != NULL)
 444         {
 445                 swt = (Switch*)swt->next;
 446                 define[0] = engine.getDefineOfValue("SWT_", swt->type);
 447                 define[1] = getActiveState(swt->activated);
 448
 449                 sprintf(line, "%c SWITCH \"%s\" %s \"%s\" \"%s\" %s %d %d %s\n", skill, swt->name, swt->linkName, swt->requiredObjectName, swt->activateMessage, define[0], (int)swt->x, (int)swt->y, define[1]);
 450
 451                 persistant->addLine(line);
 452         }
 453
 454         train = (Train*)map.trainList.getHead();
 455
 456         while (train->next != NULL)
 457         {
 458                 train = (Train*)train->next;
 459
 460                 if (train->type != TR_TRAIN)
 461                 {
 462                         if (train->type >= TR_SLIDEDOOR)
 463                         {
 464                                 define[0] = engine.getDefineOfValue("_SLIDE", train->type);
 465                         }
 466                         else
 467                         {
 468                                 define[0] = engine.getDefineOfValue("_DOO", train->type);
 469                         }
 470
 471                         define[1] = getActiveState(train->active);
 472                         sprintf(line, "%c DOOR %s %s %d %d %d %d %s\n", skill, train->name, define[0], train->startX, train->startY, train->endX, train->endY, define[1]);
 473                 }
 474                 else
 475                 {
 476                         define[0] = engine.getDefineOfValue("TR_A", train->waitAtStart);
 477                         define[1] = getActiveState(train->active);
 478                         sprintf(line, "%c TRAIN %s %d %d %d %d %d %s %s\n", skill, train->name, train->startX, train->startY, train->endX, train->endY, train->getPause(), define[0], define[1]);
 479                 }
 480
 481                 persistant->addLine(line);
 482         }
 483
 484         trap = (Trap*)map.trapList.getHead();
 485
 486         while (trap->next != NULL)
 487         {
 488                 trap = (Trap*)trap->next;
 489                 define[0] = engine.getDefineOfValue("TRAP_TYPE", trap->type);
 490                 define[1] = getActiveState(trap->active);
 491                 sprintf(line, "%c TRAP %s %s %d %d %d %d %d %d %d %d %s %s\n", skill, trap->name, define[0], (int)trap->damage, (int)trap->speed, (int)trap->startX, (int)trap->startY, (int)trap->endX, (int)trap->endY, (int)trap->waitTime[0], (int)trap->waitTime[1], trap->sprite->name, define[1]);
 492                 persistant->addLine(line);
 493         }
 494
 495         teleporter = (Teleporter*)map.teleportList.getHead();
 496
 497         while (teleporter->next != NULL)
 498         {
 499                 teleporter = (Teleporter*)teleporter->next;
 500                 define[0] = getActiveState(teleporter->active);
 501                 sprintf(line, "%c TELEPORTER %s %d %d %d %d %s\n", skill, teleporter->name, (int)teleporter->x, (int)teleporter->y, (int)teleporter->destX, (int)teleporter->destY, define[0]);
 502                 persistant->addLine(line);
 503         }
 504
 505         lineDef = (LineDef*)map.lineList.getHead();
 506
 507         while (lineDef->next != NULL)
 508         {
 509                 lineDef = (LineDef*)lineDef->next;
 510                 define[0] = getActiveState(lineDef->activated);
 511                 sprintf(line, "%c LINEDEF \"%s\" %s \"%s\" %d %d %d %d %s\n", skill, lineDef->name, lineDef->linkName, lineDef->activateMessage, (int)lineDef->x, (int)lineDef->y, (int)lineDef->width, (int)lineDef->height, define[0]);
 512                 persistant->addLine(line);
 513         }
 514
 515         spawnPoint = (SpawnPoint*)map.spawnList.getHead();
 516
 517         while (spawnPoint->next != NULL)
 518         {
 519                 spawnPoint = (SpawnPoint*)spawnPoint->next;
 520                 define[0] = engine.getDefineOfValue("SPW_", spawnPoint->spawnType);
 521
 522                 if (strstr(define[0], "HAZARD"))
 523                 {
 524                         define[1] = engine.getDefineOfValue("HAZARD_", spawnPoint->spawnSubType);
 525                 }
 526                 else
 527                 {
 528                         define[1] = engine.getDefineOfValue("SPW_", spawnPoint->spawnSubType);
 529                 }
 530
 531                 define[2] = getActiveState(spawnPoint->active);
 532                 sprintf(line, "%c SPAWNPOINT %s %d %d %s %s %d %d %s\n", skill, spawnPoint->name, (int)spawnPoint->x, (int)spawnPoint->y, define[0], define[1], (int)(spawnPoint->minInterval / 60), (int)(spawnPoint->maxInterval / 60), define[2]);
 533                 persistant->addLine(line);
 534         }
 535
 536         for (int i = 0 ; i < 10 ; i++)
 537         {
 538                 if (map.getSpawnableEnemy(i) != NULL)
 539                 {
 540                         sprintf(line, "%c SPAWNABLE_ENEMY \"%s\"\n", skill, map.getSpawnableEnemy(i));
 541                         persistant->addLine(line);
 542                 }
 543         }
 544
 545         if (map.waterLevel != -1)
 546         {
 547                 sprintf(line, "%c WATERLEVEL %d\n", skill, (int)map.waterLevel);
 548                 persistant->addLine(line);
 549         }
 550
 551         // We don't need this anymore. Remove it to free up some memory...
 552         engine.defineList.clear();
 553 }