src/mapEditor.cpp

   1 /*
   2 Copyright (C) 2004 Parallel Realities
   3 Copyright (C) 2007 Kővágó Zoltán
   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 "mapEditor.h"
  23 #include "physfs/physfs.hpp"
  24
  25 void drawMap(int mapX, int mapY)
  26 {
  27         SDL_Rect r;
  28         int tile = 0;
  29
  30         map.offsetX = mapX*32;
  31         map.offsetY = mapY*32;
  32
  33         int xtimes = (graphics.width / 32) + (graphics.width % 32 ? 2 : 1);
  34         int ytimes = (graphics.height / 32) + (graphics.width % 32 ? 2 : 1);
  35
  36         int mapx = map.offsetX >> BRICKSHIFT;
  37         int mapy = map.offsetY >> BRICKSHIFT;
  38
  39         for (int x = 0 ; (x < xtimes) && ((mapx+x) < MAPWIDTH) ; x++)
  40         {
  41                 for (int y = 0 ; (y < ytimes) && ((mapy + y) < MAPHEIGHT) ; y++)
  42                 {
  43                         r.x = x * BRICKSIZE;
  44                         r.y = y * BRICKSIZE;
  45                         r.w = r.h = BRICKSIZE - 1;
  46
  47                         tile = map.data[x + mapX][y + mapY];
  48
  49                         if (tile == MAP_WATERANIM)
  50                         {
  51                                 tile = graphics.getWaterAnim();
  52                         }
  53
  54                         if (tile > 0)
  55                         {
  56                                 graphics.blit(graphics.tile[tile], r.x, r.y, graphics.screen, false);
  57
  58                                 if ((tile >= MAP_NORESET) && (tile < MAP_DECORATION))
  59                                 {
  60                                         graphics.drawRect(r.x, r.y, 32, 4, graphics.yellow, graphics.screen);
  61                                 }
  62                         }
  63                 }
  64         }
  65 }
  66
  67 void showMap(int *mapX, int *mapY)
  68 {
  69         SDL_FillRect(graphics.screen, NULL, graphics.black);
  70
  71         engine.keyState[SDLK_SPACE] = 0;
  72         int moveTimer = 0;
  73
  74         while (true)
  75         {
  76                 graphics.updateScreen();
  77                 engine.getInput();
  78
  79                 if (engine.keyState[SDLK_SPACE])
  80                         break;
  81
  82                 for (int x = 0 ; x < MAPWIDTH ; x++)
  83                 {
  84                         for (int y = 0 ; y < MAPHEIGHT ; y++)
  85                         {
  86                                 switch (map.data[x][y])
  87                                 {
  88                                         case 0:
  89                                                 graphics.putPixel(x, y, 9, graphics.screen);
  90                                                 break;
  91                                         case 1:
  92                                                 graphics.putPixel(x, y,graphics.blue, graphics.screen);
  93                                                 break;
  94                                         case 2:
  95                                                 graphics.putPixel(x, y, graphics.green, graphics.screen);
  96                                                 break;
  97                                         case 3:
  98                                                 graphics.putPixel(x, y, graphics.red, graphics.screen);
  99                                                 break;
 100                                         default:
 101                                                 graphics.putPixel(x, y, graphics.white, graphics.screen);
 102                                                 break;
 103                                 }
 104                         }
 105                 }
 106
 107                 if (moveTimer == 0)
 108                 {
 109                         if (engine.keyState[SDLK_LEFT])
 110                                 *mapX -= 1;
 111
 112                         if (engine.keyState[SDLK_RIGHT])
 113                                 *mapX += 1;
 114
 115                         if (engine.keyState[SDLK_UP])
 116                                 *mapY -= 1;
 117
 118                         if (engine.keyState[SDLK_DOWN])
 119                                 *mapY += 1;
 120                 }
 121
 122                 moveTimer--;
 123                 Math::limitInt(&moveTimer, 0, 60);
 124
 125                 graphics.drawRect(*mapX, *mapY, graphics.width/32, 1, graphics.green, graphics.screen);
 126                 graphics.drawRect(*mapX, *mapY, 1, graphics.height/32, graphics.green, graphics.screen);
 127                 graphics.drawRect(*mapX, *mapY + graphics.height/32, graphics.width/32, 1, graphics.green, graphics.screen);
 128                 graphics.drawRect(*mapX + graphics.width/32, *mapY, 1, graphics.height/32, graphics.green, graphics.screen);
 129
 130                 SDL_Delay(16);
 131         }
 132
 133         engine.keyState[SDLK_SPACE] = 0;
 134 }
 135
 136 int nextBlock(int current, int dir)
 137 {
 138         if ((current + dir) > 255)
 139                 return current;
 140
 141         if ((current + dir) < 0)
 142                 return current;
 143
 144         int wanted = current;
 145
 146         while (true)
 147         {
 148                 wanted += dir;
 149
 150                 if (wanted < 0) return current;
 151                 if (wanted > 255) return current;
 152
 153                 if (graphics.tile[wanted])
 154                         return wanted;
 155         }
 156 }
 157
 158 void drawEnemies()
 159 {
 160         Entity *enemy = (Entity*)map.enemyList.getHead();
 161
 162         int x, y, absX, absY;
 163
 164         while (enemy->next != NULL)
 165         {
 166                 enemy = (Entity*)enemy->next;
 167
 168                 if (enemy->owner != enemy)
 169                 {
 170                         enemy->face = enemy->owner->face;
 171                         (enemy->face == 0) ? enemy->x = enemy->owner->x + enemy->tx : enemy->x = enemy->owner->x + -enemy->tx;
 172                         enemy->y = enemy->owner->y + enemy->ty;
 173                 }
 174
 175                 x = (int)(enemy->x - map.offsetX);
 176                 y = (int)(enemy->y - map.offsetY);
 177
 178                 absX = abs(x);
 179                 absY = abs(y);
 180
 181                 if ((absX < (graphics.width + 160)) && (absY < (graphics.height + 120)))
 182                 {
 183                         graphics.blit(enemy->getFaceImage(), x, y, graphics.screen, false);
 184                         enemy->animate();
 185
 186                         if ((!(enemy->flags & ENT_WEIGHTLESS)) && (!(enemy->flags & ENT_FLIES)) && (!(enemy->flags & ENT_SWIMS)))
 187                                 enemy->applyGravity();
 188                 }
 189         }
 190 }
 191
 192 void deleteEnemy(int x, int y)
 193 {
 194         x *= BRICKSIZE;
 195         y *= BRICKSIZE;
 196
 197         Entity *enemy = (Entity*)map.enemyList.getHead();
 198         Entity *previous = enemy;
 199
 200         while (enemy->next != NULL)
 201         {
 202                 enemy = (Entity*)enemy->next;
 203
 204                 if ((enemy->x == x) && (enemy->y == y))
 205                 {
 206                         map.enemyList.remove(previous, enemy);
 207                         enemy = previous;
 208                 }
 209                 else
 210                 {
 211                         previous = enemy;
 212                 }
 213         }
 214 }
 215
 216 void saveMap(char *name)
 217 {
 218         Entity *enemy = (Entity*)map.enemyList.getHead();
 219         String *str;
 220
 221         PhysFS::OStream os(name);
 222
 223         for (int y = 0 ; y < MAPHEIGHT ; y++)
 224         {
 225                 for (int x = 0 ; x < MAPWIDTH ; x++)
 226                 {
 227                         os << (int) map.data[x][y] << " ";
 228                 }
 229                 os << std::endl;
 230         }
 231
 232         str = stringHead->next;
 233         while (str != NULL)
 234         {
 235                 os << str->string;
 236                 str = str->next;
 237         }
 238
 239         while (enemy->next != NULL)
 240         {
 241                 enemy = (Entity*)enemy->next;
 242                 os << "EMH ENEMY \"" << enemy->name << "\" " << enemy->x << " " << enemy->y << std::endl;
 243         }
 244
 245         os << "@EOF@" << std::endl;
 246
 247         printf("Saved %s (%d)\n", name, SDL_GetTicks());
 248 }
 249
 250 void collectMapData()
 251 {
 252         PhysFS::IStream is(game.mapName);
 253
 254         char string[1024];
 255         String *str;
 256
 257         for (int y = 0 ; y < 300 ; y++)
 258         {
 259                 is.ignore(102400, '\n');
 260         }
 261
 262         while (is.good())
 263         {
 264                 is.getline(string, 1022);
 265                 for (int i = 0; i < 1024; i++)
 266                         if (string[i] == 0)
 267                         {
 268                                 string[i] = '\n';
 269                                 string[i+1] = '\0';
 270                                 break;
 271                         }
 272
 273                 printf("Read: %s", string);
 274
 275                 if (strstr(string, "@EOF@"))
 276                         break;
 277
 278                 if (!strstr(string, " ENEMY \""))
 279                 {
 280                         str = new String;
 281                         strcpy(str->string, string);
 282                         stringTail->next = str;
 283                         stringTail = str;
 284                 }
 285
 286                 if (strstr(string, "TILESET gfx/ancient"))
 287                 {
 288                         for (int x = 0 ; x < MAPWIDTH ; x++)
 289                         {
 290                                 for (int y = 0 ; y < MAPHEIGHT ; y++)
 291                                 {
 292                                         if ((map.data[x][y] >= 9) && (map.data[x][y] <= 20) && ((rand() % 2) == 0))
 293                                                 map.data[x][y] = Math::rrand(9, 20);
 294                                 }
 295                         }
 296                 }
 297
 298                 if (strstr(string, "TILESET gfx/caves"))
 299                 {
 300                         for (int x = 0 ; x < MAPWIDTH ; x++)
 301                         {
 302                                 for (int y = 0 ; y < MAPHEIGHT ; y++)
 303                                 {
 304                                         if ((map.data[x][y] >= 9) && (map.data[x][y] <= 20))
 305                                                 map.data[x][y] = Math::rrand(9, 12);
 306                                 }
 307                         }
 308                 }
 309         }
 310
 311 }
 312
 313 void newMap(char *name)
 314 {
 315         PhysFS::OStream os(name);
 316
 317         for (int y = 0 ; y < MAPHEIGHT ; y++)
 318         {
 319                 for (int x = 0 ; x < MAPWIDTH ; x++)
 320                 {
 321                         os << map.data[x][y] << " ";
 322                 }
 323                 os << std::endl;
 324         }
 325
 326         os << "EMH STAGENAME \"unnamed\"" << std::endl;
 327
 328         os << "EMH TILESET gfx/grasslands" << std::endl;
 329         os << "EMH BACKGROUND gfx/grasslands/stone.jpg" << std::endl;
 330         os << "EMH MUSIC music/viking.mod" << std::endl;
 331         os << "EMH ALPHATITLES 1 2 3 200 201 202 203 204 244 245 246 -1" << std::endl;
 332         os << "EMH START 10 10" << std::endl;
 333
 334         os << "@EOF@" << std::endl;
 335 }
 336
 337 void addTileDecoration()
 338 {
 339         printf("Adding Tile Decoration...\n");
 340
 341         for (int y = 1 ; y < MAPHEIGHT ; y++)
 342         {
 343                 for (int x = 0 ; x < MAPWIDTH ; x++)
 344                 {
 345                         if ((map.data[x][y] == 9) && (map.data[x][y - 1] == MAP_AIR))
 346                         {
 347                                 if (rand() % 4)
 348                                         map.data[x][y - 1] = 241;
 349                         }
 350                 }
 351         }
 352
 353         for (int y = 0 ; y < MAPHEIGHT ; y++)
 354         {
 355                 for (int x = 0 ; x < MAPWIDTH ; x++)
 356                 {
 357                         if (map.data[x][y] == 241)
 358                         {
 359                                 if ((rand() % 3) == 0)
 360                                         map.data[x][y] = 242;
 361                         }
 362                 }
 363         }
 364
 365         engine.keyState[SDLK_F1] = 0;
 366 }
 367
 368 void fillHorizontal(int block, int x, int y)
 369 {
 370         bool moveLeft = true;
 371         bool moveRight = true;
 372         bool ok = true;
 373
 374         int left = x;
 375         int right = x;
 376
 377         if (map.data[x][y] == 0)
 378         {
 379                 map.data[x][y] = block;
 380
 381                 while (ok)
 382                 {
 383                         if (moveLeft)
 384                         {
 385                                 left--;
 386                                 if (left < 0)
 387                                 {
 388                                         left = 0;
 389                                 }
 390                         }
 391
 392                         if (map.data[left][y] == 0)
 393                         {
 394                                 map.data[left][y] = block;
 395                         }
 396                         else
 397                         {
 398                                 moveLeft = false;
 399                         }
 400
 401                         if (moveRight)
 402                         {
 403                                 right++;
 404
 405                                 if (right >= MAPWIDTH)
 406                                 {
 407                                         right = MAPWIDTH - 1;
 408                                 }
 409                         }
 410
 411                         if (map.data[right][y] == 0)
 412                         {
 413                                 map.data[right][y] = block;
 414                         }
 415                         else
 416                         {
 417                                 moveRight = false;
 418                         }
 419
 420                         if ((!moveLeft) && (!moveRight))
 421                         {
 422                                 ok = false;
 423                         }
 424                 }
 425         }
 426 }
 427
 428 int main(int argc, char *argv[])
 429 {
 430         if (argc != 2)
 431         {
 432                 printf("Usage: mapeditor <filename>\n\n");
 433                 exit(1);
 434         }
 435
 436         atexit(cleanup);
 437
 438         engine.useAudio = 0;
 439
 440         initSystem(argv[0]);
 441
 442         if (!PhysFS::instance->FileExists(argv[1]))
 443                 newMap(argv[1]);
 444
 445         game.setMapName(argv[1]);
 446
 447         loadResources();
 448
 449         collectMapData();
 450
 451         int mapX, mapY, allowMove, x, y;
 452         mapX = mapY = allowMove = x = y = 0;
 453
 454         int editing = 0;
 455         int currentMonster = 0;
 456         int currentItem = 0;
 457         int currentBlock = 1;
 458
 459         SDL_Rect r;
 460
 461         int MOVESPEED = 5;
 462
 463         char string[255];
 464
 465         unsigned int frameLimit = SDL_GetTicks() + 16;
 466
 467         while (true)
 468         {
 469                 engine.getInput();
 470                 engine.doPause();
 471                 engine.doFrameLoop();
 472
 473                 graphics.updateScreen();
 474                 graphics.animateSprites();
 475                 graphics.drawBackground();
 476
 477                 engine.setPlayerPosition((mapX * 32) + 320, (mapY * 32) + 240, map.limitLeft, map.limitRight, map.limitUp, map.limitDown);
 478
 479                 drawMap(mapX, mapY);
 480                 doTrains();
 481                 doSwitches();
 482                 doItems();
 483                 doBullets();
 484                 doMIAs();
 485                 drawEnemies();
 486                 doObstacles();
 487                 doEffects();
 488                 doParticles();
 489                 doTeleporters();
 490                 doLineDefs();
 491                 doTraps();
 492
 493                 x = engine.getMouseX();
 494                 y = engine.getMouseY();
 495
 496                 x /= BRICKSIZE;
 497                 y /= BRICKSIZE;
 498
 499                 r.x = x * BRICKSIZE;
 500                 r.y = y * BRICKSIZE;
 501                 r.w = BRICKSIZE;
 502                 r.h = BRICKSIZE;
 503
 504                 switch (editing)
 505                 {
 506                         case 0:
 507                                 graphics.drawRect(r.x - 1, r.y - 1, 34, 1, graphics.yellow, graphics.screen);
 508                                 graphics.drawRect(r.x - 1, r.y - 1, 1, 34, graphics.yellow, graphics.screen);
 509                                 graphics.drawRect(r.x + 32, r.y - 1, 1, 34, graphics.yellow, graphics.screen);
 510                                 graphics.drawRect(r.x - 1, r.y + 32, 34, 1, graphics.yellow, graphics.screen);
 511                                 graphics.blit(graphics.tile[currentBlock], r.x, r.y, graphics.screen, false);
 512                                 if (engine.mouseLeft)
 513                                         map.data[mapX + x][mapY + y] = currentBlock;
 514                                 break;
 515                         case 1:
 516                                 graphics.blit(defEnemy[currentMonster].getFaceImage(), r.x, r.y, graphics.screen, false);
 517                                 if (engine.mouseLeft)
 518                                 {
 519                                         addEnemy(defEnemy[currentMonster].name, (mapX + x) * BRICKSIZE, (mapY + y) * BRICKSIZE, 0);
 520                                         engine.mouseLeft = 0;
 521                                 }
 522                                 break;
 523                         case 2:
 524                                 graphics.blit(defItem[currentItem].getFaceImage(), r.x, r.y, graphics.screen, false);
 525                                 if (engine.mouseLeft)
 526                                 {
 527                                         addItem(defItem[currentItem].id, defItem[currentItem].name, (mapX + x) * BRICKSIZE, (mapY + y) * BRICKSIZE, defItem[currentItem].sprite[0]->name, 0, defItem[currentItem].value, 0, true);
 528                                         engine.mouseLeft = 0;
 529                                 }
 530                                 break;
 531                 }
 532
 533                 if (engine.mouseRight)
 534                 {
 535                         if (editing == 0) map.data[mapX + x][mapY + y] = MAP_AIR;
 536                         if (editing == 1) deleteEnemy(mapX + x, mapY + y);
 537                 }
 538
 539                 allowMove--;
 540                 if (allowMove < 1) allowMove = 0;
 541
 542                 if (allowMove == 0)
 543                 {
 544                         if (engine.keyState[SDLK_UP]) {mapY--; allowMove = MOVESPEED;}
 545                         if (engine.keyState[SDLK_DOWN]) {mapY++; allowMove = MOVESPEED;}
 546                         if (engine.keyState[SDLK_LEFT]) {mapX--; allowMove = MOVESPEED;}
 547                         if (engine.keyState[SDLK_RIGHT]) {mapX++; allowMove = MOVESPEED;}
 548
 549                         if (engine.keyState[SDLK_PAGEDOWN]) {mapY += 10; allowMove = MOVESPEED;}
 550                         if (engine.keyState[SDLK_PAGEUP]) {mapY -= 10; allowMove = MOVESPEED;}
 551
 552                         if (engine.keyState[SDLK_1]) editing = 0;
 553                         if (engine.keyState[SDLK_2]) editing = 1;
 554                         if (engine.keyState[SDLK_3]) editing = 2;
 555
 556                         if (engine.keyState[SDLK_0]) fillHorizontal(currentBlock, mapX + x, mapY + y);
 557
 558                         if (engine.keyState[SDLK_F1]) addTileDecoration();
 559
 560                         if (engine.keyState[SDLK_ESCAPE]) break;
 561                 }
 562
 563                 if (engine.keyState[SDLK_PERIOD])
 564                 {
 565                         switch (editing)
 566                         {
 567                                 case 0:
 568                                         currentBlock = nextBlock(currentBlock, 1);
 569                                         break;
 570                                 case 1:
 571                                         currentMonster++;
 572                                         break;
 573                                 case 2:
 574                                         currentItem++;
 575                                         break;
 576                         }
 577
 578                         engine.keyState[SDLK_PERIOD] = 0;
 579                 }
 580
 581                 if (engine.keyState[SDLK_COMMA])
 582                 {
 583                         switch (editing)
 584                         {
 585                                 case 0:
 586                                         currentBlock = nextBlock(currentBlock, -1);
 587                                         break;
 588                                 case 1:
 589                                         currentMonster--;
 590                                         break;
 591                                 case 2:
 592                                         currentItem--;
 593                                         break;
 594                         }
 595
 596                         engine.keyState[SDLK_COMMA] = 0;
 597                 }
 598
 599                 Math::limitInt(&currentMonster, 0, MAX_ENEMIES - 1);
 600                 Math::limitInt(&currentItem, 0, MAX_ITEMS - 1);
 601
 602                 if (defEnemy[currentMonster].sprite[0] == NULL)
 603                         currentMonster = 0;
 604
 605                 if (defItem[currentItem].sprite[0] == NULL)
 606                         currentItem = 0;
 607
 608                 if (engine.keyState[SDLK_SPACE]) {showMap(&mapX, &mapY);}
 609
 610                 if (engine.keyState[SDLK_s]) {saveMap(game.mapName); engine.keyState[SDLK_s] = 0;}
 611
 612                 if (mapX < 0) mapX = 0;
 613                 if (mapY < 0) mapY = 0;
 614                 if (mapX > MAPWIDTH - 40) mapX = MAPWIDTH - 40;
 615                 if (mapY > MAPHEIGHT - 30) mapY = MAPHEIGHT - 30;
 616
 617                 if (editing == 0)
 618                         sprintf(string, "Index : %d:%d ; Screen %d:%d ; Tile %d", mapX + x, mapY + y, (mapX + x) * BRICKSIZE, (mapY + y) * BRICKSIZE, currentBlock);
 619                 else if (editing == 1)
 620                         sprintf(string, "Index : %d:%d ; Screen %d:%d ; %s", mapX + x, mapY + y, (mapX + x) * BRICKSIZE, (mapY + y) * BRICKSIZE, defEnemy[currentMonster].name);
 621                 else if (editing == 2)
 622                         sprintf(string, "Index : %d:%d ; Screen %d:%d ; %s", mapX + x, mapY + y, (mapX + x) * BRICKSIZE, (mapY + y) * BRICKSIZE,
 623 defItem[currentItem].name);
 624
 625                 r.x = 0;
 626                 r.w = graphics.width;
 627                 r.h = 20;
 628
 629                 if (mapY < MAPHEIGHT - 30)
 630                         r.y = graphics.height - 20;
 631                 else
 632                         r.y = 0;
 633
 634                 SDL_FillRect(graphics.screen, &r, graphics.black);
 635
 636                 graphics.drawString(string, bx + 320, r.y + 5, true, graphics.screen);
 637
 638                 engine.delay(frameLimit);
 639                 frameLimit = SDL_GetTicks() + 16;
 640         }
 641
 642         String *str = stringHead->next;
 643         String *str2;
 644         while (str != NULL)
 645         {
 646                 str2 = str;
 647                 printf("Deleting %s", str->string);
 648                 str = str->next;
 649                 delete str2;
 650         }
 651
 652         return 0;
 653 }