added Moloch (author of YASM mod) to copyrights in source files

[k8vacspelynky.git] / pxcdtest.vc

/**************************************************************************
 *    This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 3
 *  of the License, or (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 **************************************************************************/
import 'Video';
import 'Sprites';


// ////////////////////////////////////////////////////////////////////////// //
class Main : Object;

SpriteStore sprStore;
BackTileStore bgtileStore;

SpriteImage[2] spr;
int[2] frms;

int spr0x, spr0y;
bool dumpCheck;


void sprInit () {
  //spr[0] = sprStore['sDuckLeft'];
  //spr[0] = sprStore['sSkull'];
  //spr[0] = sprStore['sGoldIdol'];
  //frms[0] = 0;
  spr[0] = sprStore['sMagmz'];
  frms[0] = 0;

  spr[1] = sprStore['sExplosionMask'];
  frms[1] = 3;
  /*
  spr[1] = sprStore['sDuckLeft'];
  frms[1] = 0;
  spr[1] = sprStore['sMagma'];
  frms[1] = 0;
  */
}


bool isInEllipse (int px, int py, int x0, int y0, int x1, int y1) {
  if (x1 < x0 || y1 < y0) return false;
  if (px < x0 || py < y0 || px > x1 || py > y1) return false;
  int ewdt = (x1-x0+1);
  int ehgt = (y1-y0+1);
  float _xRadius = ewdt/2.0;
  float _yRadius = ehgt/2.0;
  if (_xRadius <= 0.0 || _yRadius <= 0.0) return false;
  float cx = x0+_xRadius;
  float cy = y0+_yRadius;
  /* This is a more general form of the circle equation
   *
   * X^2/a^2 + Y^2/b^2 <= 1
   */
  float normx = px+0.5-cx;
  float normy = py+0.5-cy;
  //Point normalized = new Point(px - center.X, py - center.Y);
  return ((normx*normx)/(_xRadius*_xRadius)+(normy*normy)/(_yRadius*_yRadius) <= 1.0);
}


void testEllipse () {
  int x0 = 20, y0 = 200;
  int x1 = 90, y1 = 220;
  foreach (int py; y0..y1+1) {
    foreach (int px; x0..x1+1) {
      if (isInEllipse(px, py, x0, y0, x1, y1)) {
        Video.fillRect(px, py, 1, 1);
      }
    }
  }
  Video.color = 0xff_7f_00;
  Video.drawRect(x0-1, y0-1, x1-x0+3, y1-y0+3);
}


void drawMask (SpriteFrame frm, int x0, int y0, int scale, int col) {
  if (!frm) return;
  /*
  Video.color = 0x7f_ff_ff_00;
  foreach (int y; 0..frm.height) {
    foreach (int x; 0..frm.width) {
      if (frm.getMaskPixel(x, y)) {
        Video.color = 0x3f_ff_ff_00;
      } else {
        Video.color = 0xcf_ff_ff_00;
      }
      Video.fillRect(x0+x*scale, y0+y*scale, scale, scale);
    }
  }
  */
  CollisionMask cm = CollisionMask.Create(frm, false);
  foreach (int y; 0..cm.height) {
    foreach (int ix; 0..cm.width) {
      int v = cm.mask[ix, y];
      foreach (int dx; 0..32) {
        if (col == -666) {
          // missed collision: red
          Video.color = (v < 0 ? 0x3f_ff_00_00 : 0xcf_ff_00_00);
        } else if (col == -999) {
          // superfluous collision: blue
          Video.color = (v < 0 ? 0x3f_00_00_ff : 0xcf_00_00_ff);
        } else if (col <= 0) {
          // no collision: yellow
          Video.color = (v < 0 ? 0x3f_ff_ff_00 : 0xcf_ff_ff_00);
        } else if (col > 0) {
          // collision: green
          Video.color = (v < 0 ? 0x3f_00_ff_00 : 0xcf_00_ff_00);
        }
        Video.fillRect(x0+(ix*32+dx)*scale, y0+y*scale, scale, scale);
        v <<= 1;
      }
    }
  }
  delete cm;
}


void sprTestRender () {
  Video.color = 0xff_ff_ff;
  Video.clearScreen();

  //writeln(!!spr[0]);
  auto frm0 = spr[0].frames[frms[0]];
  auto frm1 = spr[1].frames[frms[1]];

  frm0.tex.blitAt(10, 10, 2);
  frm1.tex.blitAt(10, 100, 2);

  int x1 = 200;
  int y1 = 150;

  auto cm0 = CollisionMask.Create(frm0, false, dumpCheck);
  auto cm1 = CollisionMask.Create(frm1, false, dumpCheck);
  //bool collided = cm1.colCheck(cm0, spr0x/2-x1/2, spr0y/2-y1/2);
  bool collided = cm0.colCheck(cm1, x1/2-spr0x/2, y1/2-spr0y/2);
  delete cm1;
  delete cm0;
  dumpCheck = false;

  bool slowCol = frm1.pixelCheck(frm0, spr0x/2-x1/2, spr0y/2-y1/2);

  drawMask(frm0, spr0x, spr0y, 2, (slowCol == collided ? (collided ? 1 : 0) : (slowCol ? -666 : -999)));
  drawMask(frm1, x1, y1, 2, -1);

  Video.color = 0xff_ff_ff;
  testEllipse();
}


// ////////////////////////////////////////////////////////////////////////// //
final void onDraw () {
  if (Video.frameTime == 0) {
    Video.requestRefresh();
  }

  sprTestRender();
}


// ////////////////////////////////////////////////////////////////////////// //
int escCount;


final void onEvent (ref event_t evt) {
  if (evt.type == ev_closequery) { Video.requestQuit(); return; }

  if (evt.type == ev_winfocus) {
    if (!evt.focused) escCount = 0;
    return;
  }

  if (evt.type == ev_keyup && evt.keycode != K_ESCAPE) escCount = 0;

  if (evt.type == ev_keyup && evt.keycode == K_ESCAPE) {
    if (++escCount == 2) Video.requestQuit();
    return;
  }

  if (evt.type == ev_mouse) {
    //writeln("!!!! x=", evt.x, "; y=", evt.y);
    spr0x = (evt.x&~1)-16*3;
    spr0y = (evt.y&~1)-16*3;
    return;
  }

  if (evt.type == ev_keydown && evt.keycode == K_d) { dumpCheck = true; return; }
}


final void runIn () {
  Video.frameTime = 0; // unlimited FPS

  sprStore = SpawnObject(SpriteStore);
  sprStore.bDumpLoaded = false;

  bgtileStore = SpawnObject(BackTileStore);
  bgtileStore.bDumpLoaded = false;

  sprInit();

  Video.swapInterval = 1;
  //Video.openScreen("Spelunky/VaVoom C", GameLevel::TilesWidth*16, GameLevel::TilesHeight*16);
  Video.openScreen("Spelunky/VaVoom C", 320*3, 240*3);
  Video.runEventLoop();
  Video.closeScreen();
}


// ////////////////////////////////////////////////////////////////////////// //
void main () {
  appSetName("k8spelunky");
  runIn();
}