src/map.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 "CEngine.h"
  24 #include "CGame.h"
  25 #include "CGraphics.h"
  26 #include "CMath.h"
  27 #include "CMap.h"
  28 #include "CRadarBlip.h"
  29 #include "CTrain.h"
  30 #include "gettext.hpp"
  31 #include "map.h"
  32
  33 void doOffsets()
  34 {
  35         map.offsetX = (int)(engine.playerPosX) - bx;
  36         map.offsetY = (int)(engine.playerPosY) - by;
  37
  38         Math::limitInt(&(map.offsetX), 0, ((MAPWIDTH - 40) * BRICKSIZE));
  39         Math::limitInt(&(map.offsetY), 0, ((MAPHEIGHT - 30) * BRICKSIZE));
  40 }
  41
  42
  43 void drawMap()
  44 {
  45         SDL_Rect r;
  46
  47         int mapx = map.offsetX >> BRICKSHIFT;
  48         int mapy = map.offsetY >> BRICKSHIFT;
  49         int brick = 0;
  50
  51         int xtimes = (graphics.width / 32) + (graphics.width % 32 ? 2 : 1);
  52         int ytimes = (graphics.height / 32) + (graphics.width % 32 ? 2 : 1);
  53
  54         for (int x = 0; (x < xtimes) && ((mapx + x) < MAPWIDTH); x++)
  55         {
  56                 for (int y = 0; (y < ytimes) && ((mapy + y) < MAPHEIGHT); y++)
  57                 {
  58                         brick = map.data[mapx + x][mapy + y];
  59
  60                         r.x = ((x * BRICKSIZE) - (map.offsetX & BRICKSIZE - 1));
  61                         r.y = ((y * BRICKSIZE) - (map.offsetY & BRICKSIZE - 1));
  62                         r.w = r.h = BRICKSIZE;
  63
  64                         if ((brick >= MAP_BREAKABLE) && (brick < MAP_WATERANIM))
  65                         {
  66                                 graphics.blit(graphics.tile[brick], r.x, r.y, graphics.screen, false);
  67
  68                                 /// DEBUG ???
  69                                 if ((brick >= MAP_NORESET) && (brick < MAP_DECORATION))
  70                                 {
  71                                         graphics.drawRect(r.x, r.y, 32, 4, graphics.yellow, graphics.screen);
  72                                 }
  73                         }
  74                 }
  75         }
  76 }
  77
  78 void drawMapTopLayer()
  79 {
  80         SDL_Rect r;
  81
  82         int offsetX = map.offsetX;
  83         int offsetY = map.offsetY;
  84
  85         Math::limitInt(&offsetX, 0, ((MAPWIDTH - 40) * BRICKSIZE));
  86         Math::limitInt(&offsetY, 0, ((MAPHEIGHT - 30) * BRICKSIZE));
  87
  88         int mapx = offsetX >> BRICKSHIFT;
  89         int mapy = offsetY >> BRICKSHIFT;
  90
  91         int brick;
  92
  93         int xtimes = (graphics.width / 32) + (graphics.width % 32 ? 2 : 1);
  94         int ytimes = (graphics.height / 32) + (graphics.width % 32 ? 2 : 1);
  95
  96         for (int x = 0; (x < xtimes) && ((mapx + x) < MAPWIDTH); x++)
  97         {
  98                 for (int y = 0; (y < ytimes) && ((mapy + y) < MAPHEIGHT); y++)
  99                 {
 100                         r.x = ((x * BRICKSIZE) - (offsetX & BRICKSIZE - 1));
 101                         r.y = ((y * BRICKSIZE) - (offsetY & BRICKSIZE - 1));
 102                         r.w = r.h = BRICKSIZE;
 103
 104                         brick = map.data[mapx + x][mapy + y];
 105
 106                         if (brick == 0)
 107                         {
 108                                 continue;
 109                         }
 110
 111                         if ((brick < MAP_BREAKABLE) || (brick >= MAP_WATERANIM))
 112                         {
 113                                 if (brick == MAP_WATER)
 114                                 {
 115                                         if (map.data[mapx + x][mapy + y + 1] >= MAP_BREAKABLE)
 116                                         {
 117                                                 addBubble((mapx + x) * BRICKSIZE, (mapy + y) * BRICKSIZE);
 118                                         }
 119                                 }
 120
 121                                 if (brick == MAP_WATERANIM)
 122                                 {
 123                                         brick = graphics.getWaterAnim();
 124                                 }
 125                                 else if (brick == MAP_SLIME)
 126                                 {
 127                                         brick = graphics.getSlimeAnim();
 128                                 }
 129                                 else if ((brick >= MAP_LAVAANIM) && (brick < MAP_TOPLAYER))
 130                                 {
 131                                         map.data[mapx + x][mapy + y] = graphics.getLavaAnim(brick);
 132                                         brick = map.data[mapx + x][mapy + y];
 133                                 }
 134
 135                                 graphics.blit(graphics.tile[brick], r.x, r.y, graphics.screen, false);
 136                         }
 137                 }
 138         }
 139 }
 140
 141 void addBlips(List *blipList, int mapX, int mapY, int type)
 142 {
 143         Sprite *blipType;
 144         Entity *ent;
 145
 146         switch (type)
 147         {
 148                 case 1:
 149                         blipType = graphics.getSprite("MIAArrow", true);
 150                         ent = (Entity*)map.miaList.getHead();
 151                         break;
 152                 case 2:
 153                         blipType = graphics.getSprite("ItemArrow", true);
 154                         ent = (Entity*)map.itemList.getHead();
 155                         break;
 156                 case 3:
 157                         blipType = graphics.getSprite("EnemyArrow", true);
 158                         ent = (Entity*)map.enemyList.getHead();
 159                         break;
 160                 default:
 161                         return;
 162         }
 163
 164         RadarBlip *blip;
 165         int x, y;
 166
 167         while (ent->next != NULL)
 168         {
 169                 ent = (Entity*)ent->next;
 170
 171                 if (ent->health <= 0)
 172                         continue;
 173
 174                 if (type == 3)
 175                 {
 176                         if (!requiredEnemy(ent->name))
 177                         {
 178                                 continue;
 179                         }
 180                 }
 181
 182                 // Items
 183                 if (type == 2)
 184                 {
 185                         if ((ent->id < ITEM_MISC) || (ent->id == ITEM_MISC_INVISIBLE))
 186                         {
 187                                 continue;
 188                         }
 189                 }
 190
 191                 x = (int)(ent->x + ent->width) >> BRICKSHIFT;
 192                 y = (int)(ent->y + ent->height) >> BRICKSHIFT;
 193
 194                 x -= mapX;
 195                 y -= mapY;
 196
 197                 x = (160) + (x * 5);
 198                 y = (120) + (y * 5);
 199
 200                 if ((x >= 165) && (y >= 125) && (x <= 475) && (y <= 355))
 201                 {
 202                         blip = new RadarBlip();
 203                         blip->set(x, y, type);
 204                         blipList->add (blip);
 205                 }
 206                 else
 207                 {
 208                         if (y < 125)
 209                                 graphics.blit(blipType->image[0], bx + 220 + (type * 50), by + 100, graphics.screen, true);
 210                         if (x > 475)
 211                                 graphics.blit(blipType->image[1], bx + 510, by + 140 + (type * 50), graphics.screen, true);
 212                         if (y > 355)
 213                                 graphics.blit(blipType->image[2], bx + 220 + (type * 50), by + 380, graphics.screen, true);
 214                         if (x < 165)
 215                                 graphics.blit(blipType->image[3], bx + 125, by + 140 + (type * 50), graphics.screen, true);
 216                 }
 217         }
 218 }
 219
 220 void addMiniMapDoors(SDL_Surface *panel, int mapX, int mapY)
 221 {
 222         Train *train = (Train*)map.trainList.getHead();
 223
 224         int x, y;
 225         int width, height, color;
 226
 227         while (train->next != NULL)
 228         {
 229                 train = (Train*)train->next;
 230
 231                 width = 5;
 232                 height = 5;
 233                 color = graphics.white;
 234
 235                 x = (int)train->x >> BRICKSHIFT;
 236
 237                 y = (int)train->y >> BRICKSHIFT;
 238
 239                 if ((x >= mapX) && (x <= mapX + 64) && (y >= mapY) && (y <= mapY + 48))
 240                 {
 241                         x -= mapX;
 242                         y -= mapY;
 243
 244                         if (train->type == TR_TRAIN)
 245                         {
 246                                 width = 10;
 247                         }
 248                         else if ((train->type >= TR_SLIDEDOOR) && (train->type <= TR_BRONZE_SLIDEDOOR))
 249                         {
 250                                 width = 10;
 251                         }
 252                         else
 253                         {
 254                                 height = 10;
 255                         }
 256
 257                         switch (train->type)
 258                         {
 259                                 case TR_GOLD_DOOR:
 260                                 case TR_GOLD_SLIDEDOOR:
 261                                         color = graphics.yellow;
 262                                         break;
 263
 264                                 case TR_SILVER_DOOR:
 265                                 case TR_SILVER_SLIDEDOOR:
 266                                         color = graphics.grey;
 267                                         break;
 268
 269                                 case TR_BRONZE_DOOR:
 270                                 case TR_BRONZE_SLIDEDOOR:
 271                                         color = SDL_MapRGB(graphics.screen->format, 0xff, 0x99, 0x00);
 272                                         break;
 273
 274                                 case TR_DOOR:
 275                                 case TR_LOCKED_DOOR:
 276                                 case TR_LOCKED_SLIDEDOOR:
 277                                         color = SDL_MapRGB(graphics.screen->format, 0xff, 0x00, 0xff);
 278                                         break;
 279                         }
 280
 281                         graphics.drawRect(x * 5, y * 5, width, height, color, panel);
 282                 }
 283         }
 284 }
 285
 286 void showMap(int centerX, int centerY)
 287 {
 288         char string[100];
 289         int x1, y1, x2, y2;
 290
 291         x1 = centerX - 32;
 292         x2 = centerX + 32;
 293         y1 = centerY - 24;
 294         y2 = centerY + 24;
 295
 296         int minX = (map.limitLeft >> BRICKSHIFT);
 297         int maxX = (map.limitRight >> BRICKSHIFT) - 44;
 298         int minY = (map.limitUp >> BRICKSHIFT);
 299         int maxY = (map.limitDown >> BRICKSHIFT) - 33;
 300
 301         Math::limitInt(&x1, minX, maxX);
 302         Math::limitInt(&x2, minX, maxX);
 303         Math::limitInt(&y1, minY, maxY);
 304         Math::limitInt(&y2, minY, maxY);
 305
 306         SDL_FillRect(graphics.screen, NULL, graphics.black);
 307         graphics.updateScreen();
 308
 309         SDL_Surface *panel = graphics.createSurface(320, 240);
 310         SDL_Surface *background = graphics.loadImage("gfx/main/mapBackground.png");
 311         SDL_SetAlpha(background, SDL_SRCALPHA|SDL_RLEACCEL, 128);
 312
 313         graphics.blit(background, 0, 0, panel, false);
 314
 315         int color = graphics.black;
 316
 317         for (int y = 0 ; y < 48 ; y++)
 318         {
 319                 for (int x = 0 ; x < 64 ; x++)
 320                 {
 321                         if (map.data[x1 + x][y1 + y] == MAP_WATER)
 322                         {
 323                                 graphics.drawRect(x * 5, y * 5, 5, 5, graphics.blue, panel);
 324                         }
 325                 }
 326         }
 327
 328         addMiniMapDoors(panel, x1, y1);
 329
 330         for (int y = 0 ; y < 48 ; y++)
 331         {
 332                 for (int x = 0 ; x < 64 ; x++)
 333                 {
 334                         color = -1;
 335
 336                         if (map.data[x1 + x][y1 + y] == MAP_AIR)
 337                         {
 338                                 color = -1;
 339                         }
 340                         else if (map.data[x1 + x][y1 + y] == MAP_WATER)
 341                         {
 342                                 color = -1;
 343                         }
 344                         else if (map.data[x1 + x][y1 + y] == MAP_SLIME)
 345                         {
 346                                 color = graphics.green;
 347                         }
 348                         else if (map.data[x1 + x][y1 + y] == MAP_LAVA)
 349                         {
 350                                 color = graphics.red;
 351                         }
 352                         else if (map.data[x1 + x][y1 + y] >= MAP_DECORATION)
 353                         {
 354                                 color = -1;
 355
 356                                 if (map.data[x1 + x][y1 + y - 1] == MAP_WATER)
 357                                 {
 358                                         color = graphics.blue;
 359                                 }
 360                                 else if (map.data[x1 + x][y1 + y + 1] == MAP_WATER)
 361                                 {
 362                                         color = graphics.blue;
 363                                 }
 364                         }
 365                         else if (map.data[x1 + x][y1 + y] < MAP_WATERANIM)
 366                         {
 367                                 color = graphics.darkGreen;
 368                         }
 369
 370                         if (color > -1)
 371                         {
 372                                 graphics.drawRect(x * 5, y * 5, 5, 5, color, panel);
 373                         }
 374                 }
 375         }
 376
 377         SDL_Surface * tmp_bckg = graphics.background;
 378         graphics.background = background;
 379         graphics.drawBackground();
 380         graphics.background = tmp_bckg;
 381         SDL_FreeSurface(background);
 382
 383         List blipList;
 384
 385         RadarBlip *blip = new RadarBlip();
 386         blip->set(160 + ((centerX - x1) * 5), 120 + ((centerY - y1) * 5), 0);
 387         blipList.add(blip);
 388
 389         addBlips(&blipList, x1, y1, 1);
 390         addBlips(&blipList, x1, y1, 2);
 391         addBlips(&blipList, x1, y1, 3);
 392
 393         Sprite *enemySignal = graphics.getSprite("EnemySignal", true);
 394         Sprite *miaSignal = graphics.getSprite("MIASignal", true);
 395         Sprite *bobSignal = graphics.getSprite("BobSignal", true);
 396         Sprite *itemSignal = graphics.getSprite("ItemSignal", true);
 397
 398         graphics.setFontColor(0xff, 0xff, 0xff, 0x00, 0x00, 0x00);
 399         graphics.setFontSize(3);
 400         graphics.drawString(game.stageName, bx + 320, by + 30, TXT_CENTERED, graphics.screen);
 401
 402         graphics.setFontSize(0);
 403
 404         graphics.drawRect(bx + 160, by + 414, 7, 7, graphics.yellow, graphics.white, graphics.screen);
 405         graphics.drawString(_("MIAs"), bx + 175, by + 410, TXT_LEFT, graphics.screen);
 406
 407         graphics.drawRect(bx + 290, by + 414, 7, 7, graphics.blue, graphics.white, graphics.screen);
 408         graphics.drawString(_("Items"), bx + 320, by + 417, TXT_CENTERED, graphics.screen);
 409
 410         graphics.drawRect(bx + 415, by + 414, 7, 7, graphics.red, graphics.white, graphics.screen);
 411         graphics.drawString(_("Enemies"), bx + 480, by + 410, TXT_RIGHT, graphics.screen);
 412
 413         graphics.setFontSize(1);
 414         sprintf(string, "%s - %.2d:%.2d:%.2d", _("Mission Time").c_str(), game.currentMissionHours, game.currentMissionMinutes, game.currentMissionSeconds);
 415         graphics.drawString(string, bx + 320, by + 60, TXT_CENTERED, graphics.screen);
 416         graphics.drawString(_("Press Button to Continue..."), bx + 320, by + 450, TXT_CENTERED, graphics.screen);
 417
 418         engine.flushInput();
 419         engine.clearInput();
 420
 421         while (true)
 422         {
 423                 engine.getInput();
 424                 graphics.updateScreen();
 425                 graphics.animateSprites();
 426
 427                 graphics.drawRect(bx + 160, by + 120, 320, 240, graphics.black, graphics.white, graphics.screen);
 428                 graphics.blit(panel, bx + 160, by + 120, graphics.screen, false);
 429
 430                 if ((engine.isKey(KEY_MAP)) || (engine.isKey(KEY_PAUSE)) || (engine.keyState[SDLK_ESCAPE]))
 431                 {
 432                         break;
 433                 }
 434
 435                 blip = (RadarBlip*)blipList.getHead();
 436
 437                 while (blip->next != NULL)
 438                 {
 439                         blip = (RadarBlip*)blip->next;
 440
 441                         switch (blip->type)
 442                         {
 443                                 case 0:
 444                                         graphics.blit(bobSignal->getCurrentFrame(), bx + blip->x, by + blip->y, graphics.screen, true);
 445                                         break;
 446                                 case 1:
 447                                         graphics.blit(miaSignal->getCurrentFrame(), bx + blip->x, by + blip->y, graphics.screen, true);
 448                                         break;
 449                                 case 2:
 450                                         graphics.blit(itemSignal->getCurrentFrame(), bx + blip->x, by + blip->y, graphics.screen, true);
 451                                         break;
 452                                 case 3:
 453                                         graphics.blit(enemySignal->getCurrentFrame(), bx + blip->x, by + blip->y, graphics.screen, true);
 454                                         break;
 455                         }
 456                 }
 457
 458                 SDL_Delay(16);
 459         }
 460
 461         blipList.clear();
 462
 463         SDL_FillRect(graphics.screen, NULL, graphics.black);
 464         graphics.updateScreen();
 465
 466         engine.flushInput();
 467         engine.clearInput();
 468 }
 469
 470 void evaluateMapAttribute(Entity *ent, int mapAttribute)
 471 {
 472         switch (mapAttribute)
 473         {
 474                 case MAP_AIR_WALL_1:
 475                 case MAP_AIR_WALL_2:
 476                 case MAP_AIR_WALL_3:
 477                 case MAP_AIR_CEILING_1:
 478                         mapAttribute = MAP_AIR;
 479                         break;
 480                 case MAP_AIR_WALL_4:
 481                         if (map.isCavesTileset)
 482                         {
 483                                 mapAttribute = MAP_AIR;
 484                         }
 485                         break;
 486                 case MAP_AIR_CEILING_2:
 487                         if (map.isGrasslandsTileset)
 488                         {
 489                                 mapAttribute = MAP_AIR;
 490                         }
 491                         else if (map.isCavesTileset)
 492                         {
 493                                 mapAttribute = MAP_WATER;
 494                         }
 495                         break;
 496                 case MAP_WATER_WALL:
 497                         if (map.isCavesTileset)
 498                         {
 499                                 mapAttribute = MAP_WATER;
 500                         }
 501                         break;
 502         }
 503
 504         switch (mapAttribute)
 505         {
 506                 case MAP_AIR:
 507                         if ((ent->environment != ENV_AIR) && (!(ent->flags & ENT_INANIMATE)))
 508                         {
 509                                 if (!(ent->flags & ENT_SWIMS))
 510                                 {
 511                                         if (ent->dy < 0)
 512                                         {
 513                                                 ent->dy = PLAYER_JUMP_SPEED;
 514                                         }
 515
 516                                         if (ent == &player)
 517                                         {
 518                                                 if ((ent == &player) && ((game.hasAquaLung) || (engine.cheatExtras)))
 519                                                 {
 520                                                         player.setSprites(graphics.getSprite("BobRight", true), graphics.getSprite("BobLeft", true), graphics.getSprite("BobSpin", true));
 521                                                 }
 522                                         }
 523
 524                                         ent->environment = ENV_AIR;
 525
 526                                         if (ent->dy < 0)
 527                                         {
 528                                                 audio.playSound(SND_WATEROUT, CH_TOUCH);
 529                                         }
 530
 531                                         ent->checkEnvironment();
 532                                 }
 533                         }
 534                         ent->falling = true;
 535                 case MAP_SOLID:
 536                         break;
 537                 case MAP_WATER:
 538                 case MAP_SLIME:
 539                 case MAP_LAVA:
 540
 541                         ent->falling = false;
 542
 543                         if (ent->environment == ENV_AIR)
 544                         {
 545                                 audio.playSound(SND_WATERIN, CH_TOUCH);
 546                                 if ((mapAttribute == MAP_SLIME) || (mapAttribute == MAP_LAVA))
 547                                         ent->thinktime = 1;
 548                         }
 549
 550                         // On ice levels water is harmful (because it's very very cold!)
 551                         if ((map.isIceLevel) && (mapAttribute == MAP_WATER))
 552                         {
 553                                 mapAttribute = MAP_LAVA;
 554                                 ent->thinktime = 1;
 555                         }
 556
 557                         if (mapAttribute == MAP_WATER)
 558                         {
 559                                 ent->environment = ENV_WATER;
 560                                 if ((ent == &player) && ((game.hasAquaLung) || (engine.cheatExtras)))
 561                                 {
 562                                         player.setSprites(graphics.getSprite("AquaBobRight", true), graphics.getSprite("AquaBobLeft", true), graphics.getSprite("AquaBobSpin", true));
 563                                 }
 564                         }
 565                         else if (mapAttribute == MAP_SLIME)
 566                         {
 567                                 ent->environment = ENV_SLIME;
 568                         }
 569                         else if (mapAttribute == MAP_LAVA)
 570                         {
 571                                 ent->environment = ENV_LAVA;
 572                         }
 573                         break;
 574         }
 575 }
 576
 577 void raiseWaterLevel()
 578 {
 579         if (map.waterLevel == map.requiredWaterLevel)
 580         {
 581                 return;
 582         }
 583
 584         int y = (int)map.waterLevel;
 585
 586         if ((int)map.waterLevel != map.requiredWaterLevel)
 587         {
 588                 for (int x = 0 ; x < MAPWIDTH ; x++)
 589                 {
 590                         if ((map.data[x][y] == MAP_AIR) || (map.isLiquid(x, y)))
 591                         {
 592                                 map.data[x][y] = MAP_WATER;
 593                         }
 594
 595                         if ((map.data[x][y] >= MAP_DECORATION) && (map.data[x][y] <= MAP_WATERANIM))
 596                         {
 597                                 map.data[x][y] = MAP_WATER;
 598                         }
 599
 600                         if (map.data[x][y] >= MAP_TOPLAYER)
 601                         {
 602                                 map.data[x][y] = MAP_WATER;
 603                         }
 604
 605                         if (map.data[x][y - 1] >= MAP_TOPLAYER)
 606                         {
 607                                 map.data[x][y] = MAP_WATER;
 608                         }
 609
 610                         if ((map.data[x][y - 1] == MAP_AIR) || (map.isLiquid(x, y - 1)))
 611                         {
 612                                 map.data[x][y - 1] = MAP_WATERANIM;
 613                         }
 614
 615                         if ((map.data[x][y - 1] >= MAP_DECORATION) && (map.data[x][y - 1] <= MAP_WATERANIM))
 616                         {
 617                                 map.data[x][y - 1] = MAP_WATERANIM;
 618                         }
 619                 }
 620
 621                 map.waterLevel -= 0.1;
 622
 623                 int x = (int)(player.x + player.dx) >> BRICKSHIFT;
 624                 int y = (int)(player.y + player.height - 1) >> BRICKSHIFT;
 625
 626                 int mapAttribute = map.data[x][y];
 627
 628                 if ((mapAttribute == MAP_WATER) && (player.environment == MAP_AIR))
 629                 {
 630                         evaluateMapAttribute(&player, mapAttribute);
 631                 }
 632         }
 633 }
 634
 635 void doWind()
 636 {
 637         map.windChangeTime--;
 638
 639         if (map.windChangeTime <= 0)
 640         {
 641                 map.windPower = 0;
 642
 643                 if (Math::rrand(0, 1) == 0)
 644                         map.windPower = Math::rrand(-3, 3);
 645
 646                 // change wind time
 647                 map.windChangeTime = Math::rrand(60, 600);
 648         }
 649
 650         addWindParticles();
 651 }
 652
 653 void parseMapDataLine(char *line, int y)
 654 {
 655         int tileIndex = 0;
 656         int x = 0;
 657
 658         while (true)
 659         {
 660                 sscanf(line, "%d", &tileIndex);
 661
 662                 map.data[x][y] = tileIndex;
 663
 664                 while (true)
 665                 {
 666                         *line++;
 667
 668                         if (*line == ' ')
 669                                 break;
 670                 }
 671
 672                 x++;
 673
 674                 if (x == MAPWIDTH)
 675                         break;
 676         }
 677 }
 678
 679 bool loadMapData(char *filename)
 680 {
 681         map.clear();
 682
 683         if (!engine.loadData(filename))
 684                 graphics.showErrorAndExit(_("The requested map '%s' was not found."), filename);
 685
 686         char *token = strtok((char*)engine.dataBuffer, "\n");
 687         parseMapDataLine(token, 0);
 688
 689         int y = 1;
 690
 691         while (true)
 692         {
 693                 token = strtok(NULL, "\n");
 694
 695                 parseMapDataLine(token, y);
 696
 697                 y++;
 698                 if (y == MAPHEIGHT)
 699                         break;
 700         }
 701
 702         getMapTokens();
 703
 704         adjustObjectives();
 705         initMIAPhrases();
 706
 707         return true;
 708 }