map.cpp

   1
   2 #include "nx.h"
   3 #include "map.h"
   4 #include "map.fdh"
   5
   6 stMap map;
   7
   8 MapRecord stages[MAX_STAGES];
   9 int num_stages;
  10
  11 #define MAX_BACKDROPS                   32
  12 NXSurface *backdrop[MAX_BACKDROPS];
  13
  14 // for FindObject--finding NPC's by ID2
  15 Object *ID2Lookup[65536];
  16
  17 unsigned char tilecode[MAX_TILES];                      // tile codes for every tile in current tileset
  18 unsigned int tileattr[MAX_TILES];                       // tile attribute bits for every tile in current tileset
  19 unsigned int tilekey[MAX_TILES];                        // mapping from tile codes -> tile attributes
  20
  21
  22 // load stage "stage_no", this entails loading the map (pxm), enemies (pxe), tileset (pbm),
  23 // tile attributes (pxa), and script (tsc).
  24 bool load_stage(int stage_no)
  25 {
  26 char stage[MAXPATHLEN];
  27 char fname[MAXPATHLEN];
  28
  29         stat(" >> Entering stage %d: '%s'.", stage_no, stages[stage_no].stagename);
  30         game.curmap = stage_no;         // do it now so onspawn events will have it
  31
  32         if (use_palette)
  33         {
  34                 palette_reset();
  35                 Sprites::FlushSheets();
  36                 map_flush_graphics();
  37         }
  38
  39         if (Tileset::Load(stages[stage_no].tileset))
  40                 return 1;
  41
  42         // get the base name of the stage without extension
  43         const char *mapname = stages[stage_no].filename;
  44         if (!strcmp(mapname, "lounge")) mapname = "Lounge";
  45         sprintf(stage, "%s/%s", stage_dir, mapname);
  46
  47         sprintf(fname, "%s.pxm", stage);
  48         if (load_map(fname)) return 1;
  49
  50         sprintf(fname, "%s/%s.pxa", stage_dir, tileset_names[stages[stage_no].tileset]);
  51         if (load_tileattr(fname)) return 1;
  52
  53         sprintf(fname, "%s.pxe", stage);
  54         if (load_entities(fname)) return 1;
  55
  56         sprintf(fname, "%s.tsc", stage);
  57         if (tsc_load(fname, SP_MAP) == -1) return 1;
  58
  59         map_set_backdrop(stages[stage_no].bg_no);
  60         map.scrolltype = stages[stage_no].scroll_type;
  61         map.motionpos = 0;
  62
  63         return 0;
  64 }
  65
  66 /*
  67 void c------------------------------() {}
  68 */
  69
  70 // load a PXM map
  71 bool load_map(const char *fname)
  72 {
  73 FILE *fp;
  74 int x, y;
  75
  76         fp = fileopen(fname, "rb");
  77         if (!fp)
  78         {
  79                 staterr("load_map: no such file: '%s'", fname);
  80                 return 1;
  81         }
  82
  83         if (!fverifystring(fp, "PXM"))
  84         {
  85                 staterr("load_map: invalid map format: '%s'", fname);
  86                 return 1;
  87         }
  88
  89         memset(&map, 0, sizeof(map));
  90
  91         fgetc(fp);
  92         map.xsize = fgeti(fp);
  93         map.ysize = fgeti(fp);
  94
  95         if (map.xsize > MAP_MAXSIZEX || map.ysize > MAP_MAXSIZEY)
  96         {
  97                 staterr("load_map: map is too large -- size %dx%d but max is %dx%d", map.xsize, map.ysize, MAP_MAXSIZEX, MAP_MAXSIZEY);
  98                 fclose(fp);
  99                 return 1;
 100         }
 101         else
 102         {
 103                 stat("load_map: level size %dx%d", map.xsize, map.ysize);
 104         }
 105
 106         for(y=0;y<map.ysize;y++)
 107         for(x=0;x<map.xsize;x++)
 108         {
 109                 map.tiles[x][y] = fgetc(fp);
 110         }
 111
 112         fclose(fp);
 113
 114         map.maxxscroll = (((map.xsize * TILE_W) - SCREEN_WIDTH) - 8) << CSF;
 115         map.maxyscroll = (((map.ysize * TILE_H) - SCREEN_HEIGHT) - 8) << CSF;
 116
 117         stat("load_map: '%s' loaded OK! - %dx%d", fname, map.xsize, map.ysize);
 118         return 0;
 119 }
 120
 121
 122 // load a PXE (entity list for a map)
 123 bool load_entities(const char *fname)
 124 {
 125 FILE *fp;
 126 int i;
 127 int nEntities;
 128
 129         // gotta destroy all objects before creating new ones
 130         Objects::DestroyAll(false);
 131         FloatText::ResetAll();
 132
 133         stat("load_entities: reading in %s", fname);
 134         // now we can load in the new objects
 135         fp = fileopen(fname, "rb");
 136         if (!fp)
 137         {
 138                 staterr("load_entities: no such file: '%s'", fname);
 139                 return 1;
 140         }
 141
 142         if (!fverifystring(fp, "PXE"))
 143         {
 144                 staterr("load_entities: not a PXE: '%s'", fname);
 145                 return 1;
 146         }
 147
 148         fgetc(fp);
 149         nEntities = fgetl(fp);
 150
 151         for(i=0;i<nEntities;i++)
 152         {
 153                 int x = fgeti(fp);
 154                 int y = fgeti(fp);
 155                 int id1 = fgeti(fp);
 156                 int id2 = fgeti(fp);
 157                 int type = fgeti(fp);
 158                 int flags = fgeti(fp);
 159
 160                 int dir = (flags & FLAG_FACES_RIGHT) ? RIGHT : LEFT;
 161
 162                 //lprintf(" %d:   [%d, %d]\t id1=%d\t id2=%d   Type %d   flags %04x\n", i, x, y, id1, id2, type, flags);
 163
 164                 // most maps have apparently garbage entities--invisible do-nothing objects??
 165                 // i dunno but no point in spawning those...
 166                 if (type || id1 || id2 || flags)
 167                 {
 168                         bool addobject = false;
 169
 170                         // check if object is dependent on a flag being set/not set
 171                         if (flags & FLAG_APPEAR_ON_FLAGID)
 172                         {
 173                                 if (game.flags[id1])
 174                                 {
 175                                         addobject = true;
 176                                         stat(" -- Appearing object %02d (%s) because flag %d is set", id2, DescribeObjectType(type), id1);
 177                                 }
 178                         }
 179                         else if (flags & FLAG_DISAPPEAR_ON_FLAGID)
 180                         {
 181                                 if (!game.flags[id1])
 182                                 {
 183                                         addobject = true;
 184                                 }
 185                                 else
 186                                 {
 187                                         stat(" -- Disappearing object %02d (%s) because flag %d is set", id2, DescribeObjectType(type), id1);
 188                                 }
 189                         }
 190                         else
 191                         {
 192                                 addobject = true;
 193                         }
 194
 195                         if (addobject)
 196                         {
 197                                 // hack for chests (can we do this elsewhere?)
 198                                 if (type == OBJ_CHEST_OPEN) y++;
 199
 200                                 Object *o = CreateObject((x * TILE_W) << CSF, \
 201                                                                                  (y * TILE_H) << CSF, type,
 202                                                                                  0, 0, dir, NULL, CF_NO_SPAWN_EVENT);
 203
 204                                 o->id1 = id1;
 205                                 o->id2 = id2;
 206                                 o->flags |= flags;
 207
 208                                 ID2Lookup[o->id2] = o;
 209
 210                                 // now that it's all set up, execute OnSpawn,
 211                                 // since we didn't do it in CreateObject.
 212                                 o->OnSpawn();
 213                         }
 214                 }
 215         }
 216
 217         //stat("load_entities: loaded %d objects", nEntities);
 218         fclose(fp);
 219         return 0;
 220 }
 221
 222 /*const int ta[] =
 223 { 0, TA_SOLID, TA_SOLID, TA_SOLID, TA_SOLID,
 224   TA_SLOPE_BACK1|TA_FOREGROUND, TA_SLOPE_BACK2|TA_FOREGROUND, TA_SLOPE_FWD1|TA_FOREGROUND, TA_SLOPE_FWD2|TA_FOREGROUND,
 225   TA_FOREGROUND, 0,0,0, TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND, 0, TA_SOLID, TA_SOLID, TA_FOREGROUND, TA_FOREGROUND,
 226   TA_SOLID,TA_SOLID,TA_SOLID,TA_SOLID,TA_FOREGROUND,0,0,0,TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,
 227   0,TA_SOLID,TA_FOREGROUND,TA_DESTROYABLE|TA_SOLID,TA_SOLID,TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,TA_SLOPE_CEIL_BACK1|TA_FOREGROUND,TA_SOLID,TA_SOLID,TA_SLOPE_CEIL_FWD2|TA_FOREGROUND,TA_SLOPE_FWD1|TA_FOREGROUND,TA_SLOPE_FWD2|TA_FOREGROUND,
 228   TA_FOREGROUND,TA_FOREGROUND,TA_SLOPE_CEIL_FWD1|TA_FOREGROUND,TA_SLOPE_CEIL_FWD2|TA_FOREGROUND,TA_SLOPE_CEIL_BACK1|TA_FOREGROUND,TA_SLOPE_CEIL_BACK2|TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,TA_FOREGROUND,0,0,TA_SOLID,TA_SOLID,TA_FOREGROUND,TA_SOLID,TA_SOLID,
 229   TA_SOLID,TA_SOLID,TA_FOREGROUND|TA_SLOPE_BACK1,TA_SLOPE_BACK2|TA_FOREGROUND,TA_SLOPE_FWD1|TA_FOREGROUND,TA_SLOPE_FWD2|TA_FOREGROUND,TA_SPIKES,TA_SPIKES,TA_SPIKES,TA_SPIKES,0,TA_SOLID,TA_SOLID,0,TA_SOLID,TA_SOLID,
 230   0,TA_SOLID,0,TA_SOLID,TA_SOLID,0,0,0,0,0,0,TA_SOLID,TA_SOLID,TA_SOLID,TA_SOLID,TA_SOLID,
 231   TA_SOLID,TA_FOREGROUND,TA_FOREGROUND,0,0,0,0,0,0,0,0,0,TA_SOLID,TA_SOLID,TA_SOLID,TA_SOLID
 232 };
 233         memset(tileattr, 0, sizeof(tileattr));
 234         memcpy(&tileattr, &ta, sizeof(ta));
 235 */
 236
 237 // loads a pxa (tileattr) file
 238 bool load_tileattr(const char *fname)
 239 {
 240 FILE *fp;
 241 int i;
 242 unsigned char tc;
 243
 244         map.nmotiontiles = 0;
 245
 246         stat("load_pxa: reading in %s", fname);
 247         fp = fileopen(fname, "rb");
 248         if (!fp)
 249         {
 250                 staterr("load_pxa: no such file: '%s'", fname);
 251                 return 1;
 252         }
 253
 254         for(i=0;i<256;i++)
 255         {
 256                 tc = fgetc(fp);
 257                 tilecode[i] = tc;
 258                 tileattr[i] = tilekey[tc];
 259                 //stat("Tile %02x   TC %02x    Attr %08x   tilekey[%02x] = %08x", i, tc, tileattr[i], tc, tilekey[tc]);
 260
 261                 if (tc == 0x43) // destroyable block - have to replace graphics
 262                 {
 263                         CopySpriteToTile(SPR_DESTROYABLE, i, 0, 0);
 264                 }
 265
 266                 // add water currents to animation list
 267                 if (tileattr[i] & TA_CURRENT)
 268                 {
 269                         map.motiontiles[map.nmotiontiles].tileno = i;
 270                         map.motiontiles[map.nmotiontiles].dir = CVTDir(tc & 3);
 271                         map.motiontiles[map.nmotiontiles].sprite = SPR_WATER_CURRENT;
 272
 273                         map.nmotiontiles++;
 274                         stat("Added tile %02x to animation list, tc=%02x", i, tc);
 275                 }
 276         }
 277
 278         fclose(fp);
 279         return 0;
 280 }
 281
 282 bool load_stages(void)
 283 {
 284 FILE *fp;
 285
 286         fp = fileopen("stage.dat", "rb");
 287         if (!fp)
 288         {
 289                 staterr("%s(%d): failed to open stage.dat", __FILE__, __LINE__);
 290                 num_stages = 0;
 291                 return 1;
 292         }
 293
 294         num_stages = fgetc(fp);
 295         for(int i=0;i<num_stages;i++)
 296                 fread(&stages[i], sizeof(MapRecord), 1, fp);
 297
 298         return 0;
 299 }
 300
 301
 302 bool initmapfirsttime(void)
 303 {
 304 FILE *fp;
 305 int i;
 306
 307         stat("initmapfirsttime: loading tilekey.dat.");
 308         if (!(fp = fileopen("tilekey.dat", "rb")))
 309         {
 310                 staterr("tilekey.dat is missing!");
 311                 return 1;
 312         }
 313
 314         for(i=0;i<256;i++)
 315                 tilekey[i] = fgetl(fp);
 316
 317         fclose(fp);
 318         return load_stages();
 319 }
 320
 321 void initmap(void)
 322 {
 323         map_focus(NULL);
 324         map.parscroll_x = map.parscroll_y = 0;
 325 }
 326
 327 /*
 328 void c------------------------------() {}
 329 */
 330
 331 // backdrop_no  - backdrop # to switch to
 332 void map_set_backdrop(int backdrop_no)
 333 {
 334         if (!LoadBackdropIfNeeded(backdrop_no))
 335                 map.backdrop = backdrop_no;
 336 }
 337
 338
 339 void map_draw_backdrop(void)
 340 {
 341 int x, y;
 342
 343         if (!backdrop[map.backdrop])
 344         {
 345                 LoadBackdropIfNeeded(map.backdrop);
 346                 if (!backdrop[map.backdrop])
 347                         return;
 348         }
 349
 350         switch(map.scrolltype)
 351         {
 352                 case BK_FIXED:
 353                         map.parscroll_x = 0;
 354                         map.parscroll_y = 0;
 355                 break;
 356
 357                 case BK_FOLLOWFG:
 358                         map.parscroll_x = (map.displayed_xscroll >> CSF);
 359                         map.parscroll_y = (map.displayed_yscroll >> CSF);
 360                 break;
 361
 362                 case BK_PARALLAX:
 363                         map.parscroll_y = (map.displayed_yscroll >> CSF) / 2;
 364                         map.parscroll_x = (map.displayed_xscroll >> CSF) / 2;
 365                 break;
 366
 367                 case BK_FASTLEFT:               // Ironhead
 368                         map.parscroll_x += 6;
 369                         map.parscroll_y = 0;
 370                 break;
 371
 372                 case BK_FASTLEFT_LAYERS:
 373                 case BK_FASTLEFT_LAYERS_NOFALLLEFT:
 374                 {
 375                         DrawFastLeftLayered();
 376                         return;
 377                 }
 378                 break;
 379
 380                 case BK_HIDE:
 381                 case BK_HIDE2:
 382                 case BK_HIDE3:
 383                 {
 384                         if (game.curmap == STAGE_KINGS)         // intro cutscene
 385                                 ClearScreen(BLACK);
 386                         else
 387                                 ClearScreen(DK_BLUE);
 388                 }
 389                 return;
 390
 391                 default:
 392                         map.parscroll_x = map.parscroll_y = 0;
 393                         staterr("map_draw_backdrop: unhandled map scrolling type %d", map.scrolltype);
 394                 break;
 395         }
 396
 397         map.parscroll_x %= backdrop[map.backdrop]->Width();
 398         map.parscroll_y %= backdrop[map.backdrop]->Height();
 399         int w = backdrop[map.backdrop]->Width();
 400         int h = backdrop[map.backdrop]->Height();
 401
 402         for(y=0;y<SCREEN_HEIGHT+map.parscroll_y; y+=h)
 403         {
 404                 for(x=0;x<SCREEN_WIDTH+map.parscroll_x; x+=w)
 405                 {
 406                         DrawSurface(backdrop[map.backdrop], x - map.parscroll_x, y - map.parscroll_y);
 407                 }
 408         }
 409 }
 410
 411 // blit OSide's BK_FASTLEFT_LAYERS
 412 static void DrawFastLeftLayered(void)
 413 {
 414 static const int layer_ys[] = { 80, 122, 145, 176, 240 };
 415 static const int move_spd[] = { 0,    1,   2,   4,   8 };
 416 const int nlayers = 5;
 417 int y1, y2;
 418 int i, x;
 419
 420         if (--map.parscroll_x <= -(SCREEN_WIDTH*2))
 421                 map.parscroll_x = 0;
 422
 423         y1 = x = 0;
 424         for(i=0;i<nlayers;i++)
 425         {
 426                 y2 = layer_ys[i];
 427
 428                 if (i)  // not the static moon layer?
 429                 {
 430                         x = (map.parscroll_x * move_spd[i]) >> 1;
 431                         x %= SCREEN_WIDTH;
 432                 }
 433
 434                 BlitPatternAcross(backdrop[map.backdrop], x, y1, y1, (y2-y1)+1);
 435                 y1 = (y2 + 1);
 436         }
 437 }
 438
 439
 440 // loads a backdrop into memory, if it hasn't already been loaded
 441 static bool LoadBackdropIfNeeded(int backdrop_no)
 442 {
 443 char fname[MAXPATHLEN];
 444
 445         // load backdrop now if it hasn't already been loaded
 446         if (!backdrop[backdrop_no])
 447         {
 448                 // use chromakey (transparency) on bkwater, all others don't
 449                 bool use_chromakey = (backdrop_no == 8);
 450
 451                 sprintf(fname, "%s/%s.pbm", data_dir, backdrop_names[backdrop_no]);
 452
 453                 backdrop[backdrop_no] = NXSurface::FromFile(fname, use_chromakey);
 454                 if (!backdrop[backdrop_no])
 455                 {
 456                         staterr("Failed to load backdrop '%s'", fname);
 457                         return 1;
 458                 }
 459         }
 460
 461         return 0;
 462 }
 463
 464 void map_flush_graphics()
 465 {
 466 int i;
 467
 468         for(i=0;i<MAX_BACKDROPS;i++)
 469         {
 470                 delete backdrop[i];
 471                 backdrop[i] = NULL;
 472         }
 473
 474         // re-copy star files
 475         for(i=0;i<256;i++)
 476         {
 477                 if (tilecode[i] == 0x43)
 478                 {
 479                         CopySpriteToTile(SPR_DESTROYABLE, i, 0, 0);
 480                 }
 481         }
 482 }
 483
 484
 485 /*
 486 void c------------------------------() {}
 487 */
 488
 489 // draw rising/falling water from eg Almond etc
 490 void map_drawwaterlevel(void)
 491 {
 492 // water_sfc: 16 tall at 0
 493 // just under: 16 tall at 32
 494 // main tile: 32 tall at 16 (yes, overlapping)
 495 int water_x, water_y;
 496
 497         if (!map.waterlevelobject)
 498                 return;
 499
 500         water_x = -(map.displayed_xscroll >> CSF);
 501         water_x %= SCREEN_WIDTH;
 502
 503         water_y = (map.waterlevelobject->y >> CSF) - (map.displayed_yscroll >> CSF);
 504
 505         // draw the surface and just under the surface
 506         BlitPatternAcross(backdrop[map.backdrop], water_x, water_y, 0, 16);
 507         water_y += 16;
 508
 509         BlitPatternAcross(backdrop[map.backdrop], water_x, water_y, 32, 16);
 510         water_y += 16;
 511
 512         // draw the rest of the pattern all the way down
 513         while(water_y < (SCREEN_HEIGHT-1))
 514         {
 515                 BlitPatternAcross(backdrop[map.backdrop], water_x, water_y, 16, 32);
 516                 water_y += 32;
 517         }
 518 }
 519
 520
 521 // draw the map.
 522 //      if foreground = TA_FOREGROUND, draws the foreground tile layer.
 523 //  if foreground = 0, draws backdrop and background tiles.
 524 void map_draw(uint8_t foreground)
 525 {
 526 int x, y;
 527 int mapx, mapy;
 528 int blit_x, blit_y, blit_x_start;
 529 int scroll_x, scroll_y;
 530
 531         scroll_x = (map.displayed_xscroll >> CSF);
 532         scroll_y = (map.displayed_yscroll >> CSF);
 533
 534         mapx = (scroll_x / TILE_W);
 535         mapy = (scroll_y / TILE_H);
 536
 537         blit_y = -(scroll_y % TILE_H);
 538         blit_x_start = -(scroll_x % TILE_W);
 539
 540         // MAP_DRAW_EXTRA_Y etc is 1 if resolution is changed to
 541         // something not a multiple of TILE_H.
 542         for(y=0; y <= (SCREEN_HEIGHT / TILE_H)+MAP_DRAW_EXTRA_Y; y++)
 543         {
 544                 blit_x = blit_x_start;
 545
 546                 for(x=0; x <= (SCREEN_WIDTH / TILE_W)+MAP_DRAW_EXTRA_X; x++)
 547                 {
 548                         int t = map.tiles[mapx+x][mapy+y];
 549                         if ((tileattr[t] & TA_FOREGROUND) == foreground)
 550                                 draw_tile(blit_x, blit_y, t);
 551
 552                         blit_x += TILE_W;
 553                 }
 554
 555                 blit_y += TILE_H;
 556         }
 557 }
 558
 559
 560 /*
 561 void c------------------------------() {}
 562 */
 563
 564 // map scrolling code
 565 void scroll_normal(void)
 566 {
 567 const int scroll_adj_rate = (0x2000 / map.scrollspeed);
 568
 569         // how many pixels to let player stray from the center of the screen
 570         // before we start scrolling. high numbers let him reach closer to the edges,
 571         // low numbers keep him real close to the center.
 572         #define P_VARY_FROM_CENTER                      (64 << CSF)
 573
 574         if (player->dir == LEFT)
 575         {
 576                 map.scrollcenter_x -= scroll_adj_rate;
 577                 if (map.scrollcenter_x < -P_VARY_FROM_CENTER)
 578                         map.scrollcenter_x = -P_VARY_FROM_CENTER;
 579         }
 580         else
 581         {
 582                 map.scrollcenter_x += scroll_adj_rate;
 583                 if (map.scrollcenter_x > P_VARY_FROM_CENTER)
 584                         map.scrollcenter_x = P_VARY_FROM_CENTER;
 585         }
 586
 587         // compute where the map "wants" to be
 588         map.target_x = (player->CenterX() + map.scrollcenter_x) - ((SCREEN_WIDTH / 2) << CSF);
 589
 590         // Y scrolling
 591         if (player->lookscroll == UP)
 592         {
 593                 map.scrollcenter_y -= scroll_adj_rate;
 594                 if (map.scrollcenter_y < -P_VARY_FROM_CENTER) map.scrollcenter_y = -P_VARY_FROM_CENTER;
 595         }
 596         else if (player->lookscroll == DOWN)
 597         {
 598                 map.scrollcenter_y += scroll_adj_rate;
 599                 if (map.scrollcenter_y > P_VARY_FROM_CENTER) map.scrollcenter_y = P_VARY_FROM_CENTER;
 600         }
 601         else
 602         {
 603                 if (map.scrollcenter_y <= -scroll_adj_rate)
 604                 {
 605                         map.scrollcenter_y += scroll_adj_rate;
 606                 }
 607                 else if (map.scrollcenter_y >= scroll_adj_rate)
 608                 {
 609                         map.scrollcenter_y -= scroll_adj_rate;
 610                 }
 611         }
 612
 613         map.target_y = (player->CenterY() + map.scrollcenter_y) - ((SCREEN_HEIGHT / 2) << CSF);
 614 }
 615
 616 void map_scroll_do(void)
 617 {
 618         bool doing_normal_scroll = false;
 619
 620         if (!map.scroll_locked)
 621         {
 622                 if (map.focus.has_target)
 623                 {       // FON command
 624                         // this check makes it so if we <FON on an object which
 625                         // gets destroyed, the scroll stays locked at the last known
 626                         // position of the object.
 627                         if (map.focus.target)
 628                         {
 629                                 Object *t = map.focus.target;
 630
 631                                 // Generally we want to focus on the center of the object, not it's UL corner.
 632                                 // But a few objects (Cage in mimiga village) have offset drawpoints
 633                                 // that affect the positioning of the scene. If the object has a drawpoint,
 634                                 // we'll assume it's in an appropriate position, otherwise, we'll try to find
 635                                 // the center ourselves.
 636                                 if (sprites[t->sprite].frame[t->frame].dir[t->dir].drawpoint.equ(0, 0))
 637                                 {
 638                                         map.target_x = map.focus.target->CenterX() - ((SCREEN_WIDTH / 2) << CSF);
 639                                         map.target_y = map.focus.target->CenterY() - ((SCREEN_HEIGHT / 2) << CSF);
 640                                 }
 641                                 else
 642                                 {
 643                                         map.target_x = map.focus.target->x - ((SCREEN_WIDTH / 2) << CSF);
 644                                         map.target_y = map.focus.target->y - ((SCREEN_HEIGHT / 2) << CSF);
 645                                 }
 646                         }
 647                 }
 648                 else
 649                 {
 650                         if (!player->hide)
 651                         {
 652                                 scroll_normal();
 653
 654                                 if (!inputs[DEBUG_MOVE_KEY] || !settings->enable_debug_keys)
 655                                         doing_normal_scroll = true;
 656                         }
 657                 }
 658         }
 659
 660         map.real_xscroll += (map.target_x - map.real_xscroll) / map.scrollspeed;
 661         map.real_yscroll += (map.target_y - map.real_yscroll) / map.scrollspeed;
 662
 663         map.displayed_xscroll = (map.real_xscroll + map.phase_adj);
 664         map.displayed_yscroll = map.real_yscroll;       // we don't compensate on Y, because player falls > 2 pixels per frame
 665
 666         if (doing_normal_scroll)
 667         {
 668                 run_phase_compensator();
 669                 //dump_phase_data();
 670         }
 671         else
 672         {
 673                 map.phase_adj -= MAP_PHASE_ADJ_SPEED;
 674                 if (map.phase_adj < 0) map.phase_adj = 0;
 675         }
 676
 677         map_sanitycheck();
 678
 679         // do quaketime after sanity check so quake works in
 680         // small levels like Shack.
 681         if (game.quaketime)
 682         {
 683                 if (!map.scroll_locked)
 684                 {
 685                         int pushx, pushy;
 686
 687                         if (game.megaquaketime)         // Ballos fight
 688                         {
 689                                 game.megaquaketime--;
 690                                 pushx = random(-5, 5) << CSF;
 691                                 pushy = random(-3, 3) << CSF;
 692                         }
 693                         else
 694                         {
 695                                 pushx = random(-1, 1) << CSF;
 696                                 pushy = random(-1, 1) << CSF;
 697                         }
 698
 699                         map.real_xscroll += pushx;
 700                         map.real_yscroll += pushy;
 701                         map.displayed_xscroll += pushx;
 702                         map.displayed_yscroll += pushy;
 703                 }
 704                 else
 705                 {
 706                         // quake after IronH battle...special case cause we don't
 707                         // want to show the walls of the arena.
 708                         int pushy = random(-0x500, 0x500);
 709
 710                         map.real_yscroll += pushy;
 711                         if (map.real_yscroll < 0) map.real_yscroll = 0;
 712                         if (map.real_yscroll > (15 << CSF)) map.real_yscroll = (15 << CSF);
 713
 714                         map.displayed_yscroll += pushy;
 715                         if (map.displayed_yscroll < 0) map.displayed_yscroll = 0;
 716                         if (map.displayed_yscroll > (15 << CSF)) map.displayed_yscroll = (15 << CSF);
 717                 }
 718
 719                 game.quaketime--;
 720         }
 721 }
 722
 723 // this attempts to prevent jitter most visible when the player is walking on a
 724 // long straight stretch. the jitter occurs because map.xscroll and player->x
 725 // tend to be out-of-phase, and thus cross over pixel boundaries at different times.
 726 // what we do here is try to tweak/fudge the displayed xscroll value by up to 512 subpixels
 727 // (1 real pixel), so that it crosses pixel boundaries on exactly the same frame as
 728 // the player does.
 729 void run_phase_compensator(void)
 730 {
 731         int displayed_phase_offs = (map.displayed_xscroll - player->x) % 512;
 732
 733         if (displayed_phase_offs != 0)
 734         {
 735                 int phase_offs = abs(map.real_xscroll - player->x) % 512;
 736                 //debug("%d", phase_offs);
 737
 738                 // move phase_adj towards phase_offs; phase_offs is how far
 739                 // out of sync we are with the player and so once we reach it
 740                 // we will compensating exactly.
 741                 if (map.phase_adj < phase_offs)
 742                 {
 743                         map.phase_adj += MAP_PHASE_ADJ_SPEED;
 744                         if (map.phase_adj > phase_offs)
 745                                 map.phase_adj = phase_offs;
 746                 }
 747                 else
 748                 {
 749                         map.phase_adj -= MAP_PHASE_ADJ_SPEED;
 750                         if (map.phase_adj < phase_offs)
 751                                 map.phase_adj = phase_offs;
 752                 }
 753         }
 754 }
 755
 756 // debug function
 757 void dump_phase_data()
 758 {
 759         int phase_offs = abs(map.real_xscroll - player->x) % 512;
 760         int final_phase = abs(map.displayed_xscroll - player->x) % 512;
 761         debug("phase_offs: %d", phase_offs);
 762         debug("");
 763         debug("real xscroll: %d", map.real_xscroll);
 764         debug("displayed xscroll: %d", map.displayed_xscroll);
 765         debug("difference: %d", map.real_xscroll - map.displayed_xscroll);
 766         debug("");
 767         debug("phase_adj: %d", map.phase_adj);
 768         debug("final_phase: %d", final_phase);
 769 }
 770
 771 /*
 772 void c------------------------------() {}
 773 */
 774
 775
 776 // scroll position sanity checking
 777 void map_sanitycheck(void)
 778 {
 779         #define MAP_BORDER_AMT          (8<<CSF)
 780         if (map.real_xscroll < MAP_BORDER_AMT) map.real_xscroll = MAP_BORDER_AMT;
 781         if (map.real_yscroll < MAP_BORDER_AMT) map.real_yscroll = MAP_BORDER_AMT;
 782         if (map.real_xscroll > map.maxxscroll) map.real_xscroll = map.maxxscroll;
 783         if (map.real_yscroll > map.maxyscroll) map.real_yscroll = map.maxyscroll;
 784
 785         if (map.displayed_xscroll < MAP_BORDER_AMT) map.displayed_xscroll = MAP_BORDER_AMT;
 786         if (map.displayed_yscroll < MAP_BORDER_AMT) map.displayed_yscroll = MAP_BORDER_AMT;
 787         if (map.displayed_xscroll > map.maxxscroll) map.displayed_xscroll = map.maxxscroll;
 788         if (map.displayed_yscroll > map.maxyscroll) map.displayed_yscroll = map.maxyscroll;
 789 }
 790
 791
 792 void map_scroll_jump(int x, int y)
 793 {
 794         map.target_x = x - ((SCREEN_WIDTH / 2) << CSF);
 795         map.target_y = y - ((SCREEN_HEIGHT / 2) << CSF);
 796         map.real_xscroll = map.target_x;
 797         map.real_yscroll = map.target_y;
 798
 799         map.displayed_xscroll = map.real_xscroll;
 800         map.displayed_yscroll = map.real_yscroll;
 801         map.phase_adj = 0;
 802
 803         map.scrollcenter_x = map.scrollcenter_y = 0;
 804         map_sanitycheck();
 805 }
 806
 807 // lock the scroll in it's current position. the target position will not change,
 808 // however if the scroll is moved off the target (really only a quake could do this)
 809 // the map will still seek it's old position.
 810 void map_scroll_lock(bool lockstate)
 811 {
 812         map.scroll_locked = lockstate;
 813         if (lockstate)
 814         {       // why do we do this?
 815                 map.real_xscroll = map.target_x;
 816                 map.real_yscroll = map.target_y;
 817         }
 818 }
 819
 820 // set the map focus and scroll speed.
 821 // if o is specified, focuses on that object.
 822 // if o is NULL, focuses on the player.
 823 void map_focus(Object *o, int spd)
 824 {
 825         map.focus.target = o;
 826         map.focus.has_target = (o != NULL);
 827
 828         map.scrollspeed = spd;
 829         map.scroll_locked = false;
 830 }
 831
 832 /*
 833 void c------------------------------() {}
 834 */
 835
 836 // change tile at x,y into newtile while optionally spawning smoke clouds and boomflash
 837 void map_ChangeTileWithSmoke(int x, int y, int newtile, int nclouds, bool boomflash, Object *push_behind)
 838 {
 839         if (x < 0 || y < 0 || x >= map.xsize || y >= map.ysize)
 840                 return;
 841
 842         map.tiles[x][y] = newtile;
 843
 844         int xa = ((x * TILE_W) + (TILE_W / 2)) << CSF;
 845         int ya = ((y * TILE_H) + (TILE_H / 2)) << CSF;
 846         SmokeXY(xa, ya, nclouds, TILE_W/2, TILE_H/2, push_behind);
 847
 848         if (boomflash)
 849                 effect(xa, ya, EFFECT_BOOMFLASH);
 850 }
 851
 852
 853
 854 const char *map_get_stage_name(int mapno)
 855 {
 856         if (mapno == STAGE_KINGS)
 857                 return "";//Studio Pixel Presents";
 858
 859         return stages[mapno].stagename;
 860 }
 861
 862 // show map name for "ticks" ticks
 863 void map_show_map_name()
 864 {
 865         game.mapname_x = (SCREEN_WIDTH / 2) - (GetFontWidth(map_get_stage_name(game.curmap), 0) / 2);
 866         game.showmapnametime = 120;
 867 }
 868
 869 void map_draw_map_name(void)
 870 {
 871         if (game.showmapnametime)
 872         {
 873                 font_draw(game.mapname_x, 84, map_get_stage_name(game.curmap), 0, &shadowfont);
 874                 game.showmapnametime--;
 875         }
 876 }
 877
 878
 879 // animate all motion tiles
 880 void AnimateMotionTiles(void)
 881 {
 882 int i;
 883 int x_off, y_off;
 884
 885         for(i=0;i<map.nmotiontiles;i++)
 886         {
 887                 switch(map.motiontiles[i].dir)
 888                 {
 889                         case LEFT: y_off = 0; x_off = map.motionpos; break;
 890                         case RIGHT: y_off = 0; x_off = (TILE_W - map.motionpos); break;
 891
 892                         case UP: x_off = 0; y_off = map.motionpos; break;
 893                         case DOWN: x_off = 0; y_off = (TILE_H - map.motionpos); break;
 894
 895                         default: x_off = y_off = 0; break;
 896                 }
 897
 898                 CopySpriteToTile(map.motiontiles[i].sprite, map.motiontiles[i].tileno, x_off, y_off);
 899         }
 900
 901         map.motionpos += 2;
 902         if (map.motionpos >= TILE_W) map.motionpos = 0;
 903 }
 904
 905
 906 // attempts to find an object with id2 matching the given value else returns NULL
 907 Object *FindObjectByID2(int id2)
 908 {
 909         Object *result = ID2Lookup[id2];
 910
 911         if (result)
 912                 staterr("FindObjectByID2: ID2 %04d found: type %s; coords: (%d, %d)", id2, DescribeObjectType(ID2Lookup[id2]->type), ID2Lookup[id2]->x>>CSF,ID2Lookup[id2]->y>>CSF);
 913         else
 914                 staterr("FindObjectByID2: no such object %04d", id2);
 915
 916         return result;
 917 }
 918