function RayCaster(canvas, w, h, z, level, player, inputBuffer) {
  
      this.QUAD_I = Math.PI * .5;
      this.QUAD_II = Math.PI;
      this.QUAD_III = Math.PI * 1.5;
      this.TO_RADS = Math.PI / 180;
      this.TO_DEGS = 180 / Math.PI;
      this.INFINITY = 10000;
      this.RES = { w:w, h:h, hh:h * .5 };
      this.FOV = 60 * this.TO_RADS;
      this.SLIVER_ARC = this.FOV / this.RES.w;
      this.TABLE_ENTRIES = Math.ceil(Math.PI * 2 / this.SLIVER_ARC);
  
      this.TABLE_INV_SIN;
      this.TABLE_INV_COS;
      this.TABLE_TAN;
      this.TABLE_INV_TAN;
      this.QUAD_BOUNDARIES;
      this.TABLE_VIEW_CORRECTION;
      this.TABLE_REFLECTANCE_LATITUDE;
      this.TABLE_REFLECTANCE_LONGITUDE;
           this.TABLE_HEX = [
                  '00','01','02','03','04','05','06','07','08','09','0a','0b','0c','0d','0e','0f',
                  '10','11','12','13','14','15','16','17','18','19','1a','1b','1c','1d','1e','1f',
                  '20','21','22','23','24','25','26','27','28','29','2a','2b','2c','2d','2e','2f',
                  '30','31','32','33','34','35','36','37','38','39','3a','3b','3c','3d','3e','3f',
                  '40','41','42','43','44','45','46','47','48','49','4a','4b','4c','4d','4e','4f',
                  '50','51','52','53','54','55','56','57','58','59','5a','5b','5c','5d','5e','5f',
                  '60','61','62','63','64','65','66','67','68','69','6a','6b','6c','6d','6e','6f',
                  '70','71','72','73','74','75','76','77','78','79','7a','7b','7c','7d','7e','7f',
                  '80','81','82','83','84','85','86','87','88','89','8a','8b','8c','8d','8e','8f',
                  '90','91','92','93','94','95','96','97','98','99','9a','9b','9c','9d','9e','9f',
                  'a0','a1','a2','a3','a4','a5','a6','a7','a8','a9','aa','ab','ac','ad','ae','af',
                  'b0','b1','b2','b3','b4','b5','b6','b7','b8','b9','ba','bb','bc','bd','be','bf',
                  'c0','c1','c2','c3','c4','c5','c6','c7','c8','c9','ca','cb','cc','cd','ce','cf',
                  'd0','d1','d2','d3','d4','d5','d6','d7','d8','d9','da','db','dc','dd','de','df',
                  'e0','e1','e2','e3','e4','e5','e6','e7','e8','e9','ea','eb','ec','ed','ee','ef',
                  'f0','f1','f2','f3','f4','f5','f6','f7','f8','f9','fa','fb','fc','fd','fe','ff'];
      this.PALETTE;
      this.CENTERLINE_SHIFT = 0;
  
      this.camera = { position: { _x:-1, _y:-1}, direction: 0 }
           this.idle = false;
           this.sliverWidth = z * 2;
      this.canvas = canvas;
           this.canvas.lineWidth = this.sliverWidth;
      this.level = level; //new Level();
      this.player = player; //new Player(8);
      this.keysPressed = inputBuffer;//new Array(false, false, false, false);
      
      this.update = function() {
                  if (!this.idle) {
                          this.blank(this.RES.w, this.RES.h, this.RES.hh, this.level.colors.sky, this.level.colors.ground);
                          this.cast();
                  }
                  this.processInput();
      }
      
      this.loadMap = function(m, x, y) {
          var parseOk = this.level.parseMap(m, x, y);
          if (parseOk) {
              this.buildPalette();
              this.camera.position._x = this.level.spawnPoint._x;
              this.camera.position._y = this.level.spawnPoint._y;
              this.camera.direction = 0;
              trace("player spawned at [" +this.camera.position._x +" " +this.camera.position._y +"]");
          }
          return parseOk;
      }
      
      this.cast = function() {
          var hit_latitude = { _x:0, _y:0, type:this.level.CELLTYPE_OPEN };
          var hit_longitude = { _x:0, _y:0, type:this.level.CELLTYPE_OPEN };
          var distance = { _x:0, _y:0 };
          var step = { _x:0, _y:0 };
          var mapScale = this.RES.h / this.level.dimension._y;
          var wallHeight = this.RES.h;
          
          var wallHalfHeight;
          var wallScale;
          var wallTop;
          var wallCenter;
          var wallBottom;
          
          var brightness;
          var rlu;
          var C;
          var sliverColor;
  
          // cast a ray for every sliver of our Field Of View (from -this.FOV/2 to this.FOV/2),
          // looking for both latitudinal (E-W) and longitudinal (N-S) intersections.
          // the closest intersection will determine how to render the sliver.
          var rayDirection = this.camera.direction - Math.round(this.RES.w * .5) + 1;
          if (rayDirection < 0) { rayDirection += this.TABLE_ENTRIES; }
          for (var currentSliver = 0; currentSliver < this.RES.w; currentSliver += this.sliverWidth) {
              rayDirection += this.sliverWidth;
              if (rayDirection >= this.TABLE_ENTRIES) { rayDirection = 0; }
              
              // look for intersections with latitudinal boundaries (running east-west)
              if (rayDirection >= this.QUAD_BOUNDARIES[0] && rayDirection < this.QUAD_BOUNDARIES[2]) {
                  this.cast_north(hit_latitude, distance, step, rayDirection);
              }
              else {
                  this.cast_south(hit_latitude, distance, step, rayDirection);
              }
              
              // look for intersections with longitudinal boundaries (running north-south)
              if (rayDirection >= this.QUAD_BOUNDARIES[1] && rayDirection < this.QUAD_BOUNDARIES[3]) {
                  this.cast_west(hit_longitude, distance, step, rayDirection);
              }
              else {
                  this.cast_east(hit_longitude, distance, step, rayDirection);
              }
          
              // compare distances and draw nearest intersection
              if (distance._x < distance._y) {
                  // draw a latitudinal wall sliver (east-west wall)
                  distance._x *= this.TABLE_VIEW_CORRECTION[currentSliver];
                  wallScale = this.level.CELL_SIZE / distance._x;
                  rlu = rayDirection - this.camera.direction;
                  if (rlu < 0) { rlu += this.TABLE_ENTRIES; }
                  else if (rlu >= this.TABLE_ENTRIES) { rlu -= this.TABLE_ENTRIES; }
                  brightness = 1 - Math.min(1, distance._x / this.level.viewExtent);
                  brightness *= this.TABLE_REFLECTANCE_LATITUDE[rlu];
                  C = this.PALETTE[hit_latitude.type];
                  sliverColor = '#' +
                                                         this.TABLE_HEX[ Math.round(C.r.delta * brightness + C.r.far) ] +
                                this.TABLE_HEX[ Math.round(C.g.delta * brightness + C.g.far) ] +
                                this.TABLE_HEX[ Math.round(C.b.delta * brightness + C.b.far) ];
              }
              else {
                  // draw a longitudinal wall sliver (north-south wall)
                  distance._y *= this.TABLE_VIEW_CORRECTION[currentSliver];
                  wallScale = this.level.CELL_SIZE / distance._y;
                  rlu = rayDirection - this.camera.direction;
                  if (rlu < 0) { rlu += this.TABLE_ENTRIES; }
                  else if (rlu >= this.TABLE_ENTRIES) { rlu -= this.TABLE_ENTRIES; }
                  brightness = 1 - Math.min(1, distance._y / this.level.viewExtent);
                  brightness *= this.TABLE_REFLECTANCE_LONGITUDE[rlu];
                  C = this.PALETTE[hit_longitude.type];
                  sliverColor = '#' +
                                                         this.TABLE_HEX[ Math.round(C.r.delta * brightness + C.r.far) ] +
                                this.TABLE_HEX[ Math.round(C.g.delta * brightness + C.g.far) ] +
                                this.TABLE_HEX[ Math.round(C.b.delta * brightness + C.b.far) ];
              }
              wallCenter = Math.round(this.RES.hh + this.CENTERLINE_SHIFT*wallScale);
              wallHalfHeight = (wallHeight * wallScale) >> 1;
              wallTop = Math.max(0, wallCenter - wallHalfHeight);
              wallBottom = Math.min(this.RES.h, wallCenter + wallHalfHeight);
              this.drawSliver(currentSliver, wallTop, wallBottom, sliverColor);
          }
          
      }
      
      this.cast_north = function(hit, distance, step, ray) {
          // casting northward (0 - 180 degrees), Y is increasing
          var cellBoundY = this.camera.position._y >> this.level.CELL_SIZE_SHIFT;
          hit._y = (cellBoundY+1) << this.level.CELL_SIZE_SHIFT;
          hit._x = this.camera.position._x + ((hit._y - this.camera.position._y) * this.TABLE_INV_TAN[ray]);
          step._x = this.level.CELL_SIZE * this.TABLE_INV_TAN[ray];
          step._y = this.level.CELL_SIZE;
          
          var casting = true;
          while (casting) {
              // is current hit point out of bounds?
              if ( (hit._x < 0) || (hit._x >= this.level.dimension._x) ) {
                  distance._x = this.INFINITY;
                  casting = false;
              }
              else {
                  // is there a wall at the cell boundary north of the hitpoint?
                  // walltype = this.level.map[row][col];
                  hit.type = this.level.map[((hit._y + this.level.CELL_HALF) >> this.level.CELL_SIZE_SHIFT)][(hit._x >> this.level.CELL_SIZE_SHIFT)];
                  if (hit.type != this.level.CELLTYPE_OPEN) {
                      distance._x = (hit._y - this.camera.position._y) * this.TABLE_INV_SIN[ray];
                      casting = false;
                  }
                  // if still in bounds but south of an empty cell, then cast further north
                  else {
                      hit._x += step._x;
                      hit._y += step._y;
                  }
              }
          }
      }
      
      this.cast_south = function(hit, distance, step, ray) {
          // casting southward (180 - 360 degrees), Y is decreasing
          var cellBoundY = this.camera.position._y >> this.level.CELL_SIZE_SHIFT;
          hit._y = cellBoundY << this.level.CELL_SIZE_SHIFT;
          hit._x = this.camera.position._x + ((hit._y - this.camera.position._y) * this.TABLE_INV_TAN[ray]);
          step._x = -this.level.CELL_SIZE * this.TABLE_INV_TAN[ray];
          step._y = -this.level.CELL_SIZE;
          
          var casting = true;
          while (casting) {
              // is current hit point out of bounds?
              if ( (hit._x < 0) || (hit._x >= this.level.dimension._x) ) {
                  distance._x = this.INFINITY;
                  casting = false;
              }
              else {
                  // is there a wall at the cell boundary south of the hitpoint?
                  // walltype = this.level.map[row][col];
                  hit.type = this.level.map[((hit._y - this.level.CELL_HALF) >> this.level.CELL_SIZE_SHIFT)][(hit._x >> this.level.CELL_SIZE_SHIFT)];
                  if (hit.type != this.level.CELLTYPE_OPEN) {
                      distance._x = (hit._y - this.camera.position._y) * this.TABLE_INV_SIN[ray];
                      casting = false;
                  }
                  // if still in bounds but north of an empty cell, then cast further south
                  else {
                      hit._x += step._x;
                      hit._y += step._y;
                  }
              }
          }
      }
      
      this.cast_west = function(hit, distance, step, ray) {
          // casting westward (90 - 270 degrees), X is decreasing
          var cellBoundX = this.camera.position._x >> this.level.CELL_SIZE_SHIFT;
          hit._x = cellBoundX << this.level.CELL_SIZE_SHIFT;
          hit._y = this.camera.position._y + ((hit._x - this.camera.position._x) * this.TABLE_TAN[ray]);
          step._x = -this.level.CELL_SIZE;
          step._y = -this.level.CELL_SIZE * this.TABLE_TAN[ray];
          
          var casting = true;
          while (casting) {
              // is current hit point out of bounds?
              if ( (hit._y < 0) || (hit._y >= this.level.dimension._y) ) {
                  distance._y = this.INFINITY;
                  casting = false;
              }
              else {
                  // is there a wall at the cell boundary west of the hitpoint?
                  // walltype = this.level.map[row][col];
                  hit.type = this.level.map[(hit._y >> this.level.CELL_SIZE_SHIFT)][((hit._x - this.level.CELL_HALF) >> this.level.CELL_SIZE_SHIFT)];
                  if (hit.type != this.level.CELLTYPE_OPEN) {
                      distance._y = (hit._x - this.camera.position._x) * this.TABLE_INV_COS[ray];
                      casting = false;
                  }
                  // if still in bounds but east of an empty cell, then cast further west
                  else {
                      hit._x += step._x;
                      hit._y += step._y;
                  }
              }
          }
      }
      
      this.cast_east = function(hit, distance, step, ray) {
          // casting eastward (0-90, 270-360 degrees), X is increasing
          var cellBoundX = this.camera.position._x >> this.level.CELL_SIZE_SHIFT;
          hit._x = (cellBoundX+1) << this.level.CELL_SIZE_SHIFT;
          hit._y = this.camera.position._y + ((hit._x - this.camera.position._x) * this.TABLE_TAN[ray]);
          step._x = this.level.CELL_SIZE;
          step._y = this.level.CELL_SIZE * this.TABLE_TAN[ray];
          
          var casting = true;
          while (casting) {
              // is current hit point out of bounds?
              if ( (hit._y < 0) || (hit._y >= this.level.dimension._y) ) {
                  distance._y = this.INFINITY;
                  casting = false;
              }
              else {
                  // is there a wall at the cell boundary east of the hitpoint?
                  // walltype = this.level.map[row][col];
                  hit.type = this.level.map[hit._y >> this.level.CELL_SIZE_SHIFT][(hit._x + this.level.CELL_HALF) >> this.level.CELL_SIZE_SHIFT];
                  if (hit.type != this.level.CELLTYPE_OPEN) {
                      distance._y = (hit._x - this.camera.position._x) * this.TABLE_INV_COS[ray];
                      casting = false;
                  }
                  // if still in bounds but west of an empty cell, then cast further east
                  else {
                      hit._x += step._x;
                      hit._y += step._y;
                  }
              }
          }
      }
      
      this.blank = function(w, h, hh, sky, ground) {
          // clear drawings from previous update (pen resets to [0, 0]),
                    this.canvas.clearRect(0, 0, w, h);
          // draw fresh background of sky and ground
                    this.canvas.fillStyle = sky;
                    this.canvas.fillRect(0, 0, w, hh);
                    this.canvas.fillStyle = ground;
                    this.canvas.fillRect(0, hh, w, h);
      }
      
      this.drawSliver = function(x, t, b, c) {
          // draw a vertical 1-pixel wide sliver of wall
                    var xc = x + this.sliverWidth * .5;
                    this.canvas.beginPath();
                    this.canvas.strokeStyle = c;
                    this.canvas.moveTo(xc, t);
                    this.canvas.lineTo(xc, b);
                    this.canvas.closePath();
                    this.canvas.stroke();
      }
      
      this.processInput = function() {
                   this.idle = true;
                   
          if (this.keysPressed.left) {
              // rotate this.camera counter-clockwise
                                  this.idle = false;
                                  trace('turning left');
              this.camera.direction -= this.player.speed.turn;
              if (this.camera.direction < 0) { this.camera.direction += this.TABLE_ENTRIES; }
          }
          if (this.keysPressed.right) {
              // rotate this.camera clockwise
                                  this.idle = false;
                                  trace('turning right');
              this.camera.direction += this.player.speed.turn;
              if (this.camera.direction >= this.TABLE_ENTRIES) { this.camera.direction -= this.TABLE_ENTRIES; }
          }
          if (this.keysPressed.up) {
              // ensure next step will take this.camera into empty cell
                                  this.idle = false;
                                  trace('moving forward');
              var newX = this.camera.position._x + this.player.speed.forward / this.TABLE_INV_COS[this.camera.direction];
              var newY = this.camera.position._y + this.player.speed.forward / this.TABLE_INV_SIN[this.camera.direction];
              var row = newY >> this.level.CELL_SIZE_SHIFT;
              var col = newX >> this.level.CELL_SIZE_SHIFT;
              if (this.level.map[row][col] == this.level.CELLTYPE_OPEN) {
                  this.camera.position._x = newX;
                  this.camera.position._y = newY;
              }
          }
          if (this.keysPressed.down) {
              // ensure next step will take this.camera into empty cell
                                  this.idle = false;
                                  trace('moving backward');
              var newX = this.camera.position._x - this.player.speed.backward / this.TABLE_INV_COS[this.camera.direction];
              var newY = this.camera.position._y - this.player.speed.backward / this.TABLE_INV_SIN[this.camera.direction];
              var row = newY >> this.level.CELL_SIZE_SHIFT;
              var col = newX >> this.level.CELL_SIZE_SHIFT;
              if (this.level.map[row][col] == this.level.CELLTYPE_OPEN) {
                  this.camera.position._x = newX;
                  this.camera.position._y = newY;
              }
          }
      }
  
      this.buildPalette = function() {
          // for each walltype color pair,
          // extract the r,g,b components for shading use later
          //
          // 24-bit color:
          //   rrrrrrrrggggggggbbbbbbbb
          // 24      16       8       0
          //
          // extraction:
          //   r = c >> 16              : shift out the green and blue
          //   g = (c & 0x00FF00) >> 8  : mask out the red, shift out the blue
          //   b = c & 0x0000FF         : mask out the red and green
          // combination:
          //   c = (r << 16) + (g << 8) + b  : shift the components into place and combine
          
          this.PALETTE = new Array();
          // the palette will be used to interp from dark to light (far to near),
          // so delta is set in this direction
          for (var i = 0; i < this.level.walltypes.length; i++) {
              // grab wallcolor near and wallcolor far
              var wcn = this.level.colors.wallsNear[i];
              var wcf = this.level.colors.wallsFar[i];
              
              // extract rgb components for near and far
              var rn = (wcn & 0xff0000) >> 16;
              var rf = (wcf & 0xff0000) >> 16;
              //var rn = wcn >> 16;
              //var rf = wcf >> 16;
              var gn = (wcn & 0x00ff00) >> 8;
              var gf = (wcf & 0x00ff00) >> 8;
              var bn = wcn & 0x0000ff;
              var bf = wcf & 0x0000ff;
              
              // assemble object and store in lookup table for use later
              var C = {
                  r : { near:rn, far:rf, delta:rn-rf},
                  g : { near:gn, far:gf, delta:gn-gf},
                  b : { near:bn, far:bf, delta:bn-bf}
              };
              this.PALETTE[i] = C;
          }
      }
      
      this.buildTables = function() {
          // precompute values for expensive math ops
          // we already know the field of view and horizontal screen res,
          // and thus the degrees of view spanned by a single sliver of res,
          // so we compute the trig values for enough slivers to cover 360 deg.
          
          // initialize the tables
          this.TABLE_INV_SIN = new Array();
          this.TABLE_INV_COS = new Array();
          this.TABLE_TAN = new Array();
          this.TABLE_INV_TAN = new Array();
          this.QUAD_BOUNDARIES = new Array();
          this.TABLE_REFLECTANCE_LATITUDE = new Array();
          this.TABLE_REFLECTANCE_LONGITUDE = new Array();
          
          // define some unit circle constants
          var PI_1over2 = Math.PI * 1 / 2; //  90 degrees
          var PI_1over1 = Math.PI * 1;     // 180 degrees
          var PI_3over2 = Math.PI * 3 / 2; // 270 degrees
          var PI_2over1 = Math.PI * 2;     // 360 degrees
          
          // walk around the unit circle, jotting down trig values along the way.
          // we need to look out for horizontal and vertical asymptotes, where tangent
          // goes to infinity, and substitute a grossly underestimated value that
          // won't break our calculations.
          // also, when we cross an asymptote, we'll record the index i
          // QUAD_
          var quadrant = 0;
          var angle = 0;
          for (var i = 0; i < this.TABLE_ENTRIES; i++) {
              var cosine = Math.cos(angle);
              var sine = Math.sin(angle);
              var absCosine = Math.abs(cosine);
              var absSine = Math.abs(sine);
              
              if (absCosine == 0 || absSine == 1) {
                  // 90 or 270 degrees
                  this.TABLE_TAN[i] = -this.INFINITY;
                  this.TABLE_INV_TAN[i] = 0;
                  if (quadrant == 1) { this.TABLE_INV_COS[i] = -this.INFINITY; }
                  else               { this.TABLE_INV_COS[i] = this.INFINITY; }
                  this.TABLE_INV_SIN[i] = 1 / sine;
                  this.QUAD_BOUNDARIES[quadrant] = i;
                  quadrant++;
              }
              else if (absCosine == 1 || absSine == 0) {
                  // 0 or 180 degrees
                  this.TABLE_TAN[i] = 0;
                  this.TABLE_INV_TAN[i] = this.INFINITY;
                  if (quadrant == 0) { this.TABLE_INV_SIN[i] = this.INFINITY; }
                  else               { this.TABLE_INV_SIN[i] = -this.INFINITY; }
                  this.TABLE_INV_COS[i] = 1 / cosine;
                  this.QUAD_BOUNDARIES[quadrant] = i;
                  quadrant++;
              }
              else {
                  // no asymptotes to worry about
                  this.TABLE_TAN[i] = sine / cosine;
                  this.TABLE_INV_TAN[i] = cosine / sine;
                  this.TABLE_INV_COS[i] = 1 / cosine;
                  this.TABLE_INV_SIN[i] = 1 / sine;
              }
              
              // for specular lighting,
              // precalculate the cosine of the angle between
              // every ray and the surface normal of:
              //   1) a latitudinal (horizontal) surface
              //   2) a longitudinal (vertical) surface
              // the calculation requires that the angle be [0,PI/2]
              var h = 0;
              var v = 0;
              switch (quadrant-1) {
                  case 0:
                  h = PI_1over2 - angle;
                  v = angle;
                  break;
                  
                  case 1:
                  h = angle - PI_1over2;
                  v = PI_1over1 - angle;
                  break;
                  
                  case 2:
                  h = PI_3over2 - angle;
                  v = angle - PI_1over1;
                  break;
                  
                  case 3:
                  h = angle - PI_3over2;
                  v = PI_2over1 - angle;
                  break;
              }
              this.TABLE_REFLECTANCE_LATITUDE[i]  = Math.sin( Math.min(PI_1over2, Math.max(0, h)) );
              this.TABLE_REFLECTANCE_LONGITUDE[i] = Math.cos( Math.min(PI_1over2, Math.max(0, v)) );
              
              angle += this.SLIVER_ARC;
          }
          
          // pre-compute view correction values for each sliver
          this.TABLE_VIEW_CORRECTION = new Array();
          var FOVangle = this.SLIVER_ARC * (-Math.round(this.FOV*.5));
          for (var sliver = 0; sliver < this.RES.w; sliver++) {
              this.TABLE_VIEW_CORRECTION[sliver] = Math.cos(FOVangle); // minimal fish-eye
              //this.TABLE_VIEW_CORRECTION[sliver] = 1 / Math.cos(FOVangle); // extra fish-eye! cool.
              FOVangle += this.SLIVER_ARC;
          }
      }
      
      this.buildTables();
      
  }