// For all the browsers coming from a good home, we are doing it via CSS.
if (pacMan.useCss) {
  el.style.backgroundImage = 'url(files/sprite.png)';
  el.style.backgroundPosition = (-x) + 'px ' + (-y) + 'px';
  el.style.backgroundRepeat = 'no-repeat';
} else {
  // For old Internet Explorers with CSS background reloading bug, we put
  // an image inside an element, and move it around.
  el.style.overflow = 'hidden';
  var style = 'display: block; position: relative; ' +
              'left: ' + (-x) + 'px; top: ' + (-y) + 'px';
  el.innerHTML = '<img style="' + style +
                 '" src="files/sprite.png">';
}

if (useCssTransforms) {
  if (use3DTransforms) {
    layerEls[i].style[cssTransformName] =
        'translate3d(' + posX + 'px, ' +  posY + 'px, 0)';
  } else {
    layerEls[i].style[cssTransformName] =
        'translate(' + posX + 'px, ' +  posY + 'px)';
  }
} else {
  layerEls[i].style.left = posX + 'px';
  layerEls[i].style.top = posY + 'px';
}

onload="window.lol&&lol();setTimeout(function(){var h=0,v=1,
f=document.getElementById('fall'),i=setInterval(function(){
if(f){var r=parseInt(f.style.right)+h,b=parseInt(f.style.bottom)-v;
f.style.right=r+'px';f.style.bottom=b+'px';if(b>-210){v+=2}else
{h=(v>9)?v*0.1:0;v*=(v>9)?-0.3:0}}},25);google.rein&&google.rein.push(
function(){clearInterval(i);h=0;v=1})},2000)"

// For some reason, creating an <object> in DOM failed in IE. We need
// to put it in separate iframe to use document.write. The frame also
// needs to be a certain size for IE to use it.
pacMan.flashIframe = document.createElement('iframe');
pacMan.flashIframe.name = 'pm-sound';
pacMan.flashIframe.style.position = 'absolute';
pacMan.flashIframe.style.top = '-150px';
pacMan.flashIframe.style.border = 0;
pacMan.flashIframe.style.width = '100px';
pacMan.flashIframe.style.height = '100px';
document.body.appendChild(pacMan.flashIframe);

pacMan.flashIframeDoc = pacMan.flashIframe.contentDocument;
if (pacMan.flashIframeDoc == undefined || pacMan.flashIframeDoc == null) {
  pacMan.flashIframeDoc = pacMan.flashIframe.contentWindow.document;
}

/**
 * Add handlers for touch events. We support swiping to move on machines
 * that have that capability.
 */
pacMan.registerTouch = function() {
  document.body.addEventListener('touchstart', pacMan.handleTouchStart,
      true);
  pacMan.canvasEl.addEventListener('touchstart', pacMan.handleTouchStart,
      true);
};

var MOZ_ORIENTATION_SCALE_FACTOR = 57;
var IOS_ORIENTATION_SCALE_FACTOR = 2;

...

scoped_listen(window, 'deviceorientation', handleDeviceOrientation);
scoped_listen(window, 'MozOrientation', handleDeviceOrientation);
scoped_listen(window, 'devicemotion', handleDeviceOrientation);

...

var orientationX =
    event.gamma ||
    (event.x * MOZ_ORIENTATION_SCALE_FACTOR) ||
    (iosX * IOS_ORIENTATION_SCALE_FACTOR);
var orientationY =
    event.beta ||
    (event.y * MOZ_ORIENTATION_SCALE_FACTOR) ||
    (iosY * IOS_ORIENTATION_SCALE_FACTOR);

/**
 * Allowed framerates. The game will start with the first one (90fps) and
 * scale down if it determines the computer is too slow.
 * @const
 */
var PM_ALLOWED_FPS = [90, 45, 30];
  
/**
 * (Re)initialize the main tick timer. The tick timer ticks 90 times per
 * seconds and keeps the game alive.
 */
pacMan.initializeTickTimer = function() {
  window.clearInterval(pacMan.tickTimer);

  // We're starting with 90fps, but the game can decrease it to 45fps or
  // even 30fps if necessary.
  pacMan.fps = PM_ALLOWED_FPS[pacMan.fpsChoice];
  pacMan.tickInterval = 1000 / pacMan.fps;

  // This is 1 for 90fps, 2 for 45fps and 3 for 30fps. It means how often
  // the game logic will be updated compared to screen update.
  pacMan.tickMultiplier = PM_TARGET_FPS / pacMan.fps;

  ...

function startMainTimer() {
  if (!mainTimerActive) {
    mainTimerActive = true;
    mainTimerId = window.setInterval(tick, TICK_TIME);
    dormantTicks = 0;
  }
}

...

if (horDormant && vertDormant) {
  dormantTicks++;
  if (dormantTicks > DORMANT_TICK_TIMEOUT) {
    stopMainTimer();
  }
} else {
  dormantTicks = 0;
}  

google.doodle['hover'] = function(e) {
  if (allowHover_) {
    allowHover_ = false;
    window.setTimeout(function() { allowHover_ = true; }, 50);
  }
  
  ...
}

/**
 * Pac-Man and Ms. Pac-Man (but not ghost) are allowed to "corner." If the
 * direction is changed in advance of intersection, a couple pixels (3 or 4)
 * close to the middle of it are taken diagonally, allowing to gain extra
 * distance when ghosts chase you.
 */
PacManActor.prototype.handleCornering = function() {
  var tilePos = this.tilePos;
  
  ...

  if (this.pos[0] >= minPos[0] && this.pos[0] <= maxPos[0] &&
      this.pos[1] >= minPos[1] && this.pos[1] <= maxPos[1]) {
    var movement = PM_MOVEMENTS[this.nextDir];

    // The corner increment is stored temporarily in posDelta and added to
    // the proper position only after cornering ends.
    this.posDelta[movement.axis] += movement.increment;
  }
};  

{
  ghostSpeed: .95, ghostTunnelSpeed: .5,
  playerSpeed: 1, dotEatingSpeed: .87,
  ghostFrightSpeed: .6, playerFrightSpeed: 1, dotEatingFrightSpeed: .87,
  elroyDotsLeftPart1: 50, elroySpeedPart1: 1,
  elroyDotsLeftPart2: 25, elroySpeedPart2: 1.05,
  frightTime: 5, frightBlinkCount: 5,
  fruit: 4, fruitScore: 700,
  ghostModeSwitchTimes: [5, 20, 5, 20, 5, 1037, 1 / 60, 1],
  penForceTime: 3, penLeavingLimits: [0, 0, 0, 0]
},

/**
 * Show the "kill screen" instead of level 256. The original Pac-Man had
 * a bug that corrupted that level, making it look funny and impossible to
 * finish. We're trying to procedurally generate a similarly looking level,
 * although we're not making it playable.
 */
pacMan.killScreen = function() {
  // Makes sure it always looks the same.
  pacMan.seed(0);

  pacMan.canvasEl.style.visibility = '';

  // Covering the right-hand side of the playfield.
  pacMan.createKillScreenElement(272, 0, 200, 80, false);
  pacMan.createKillScreenElement(272 + 8, 80, 200 - 8, 136 - 80, false);

  // Creating little tiles with gibberish.
  pacMan.killScreenTileX = 80;
  pacMan.killScreenTileY = 0;
  for (var x = 280; x <= 472; x += 8) {
    for (var y = 0; y <= 136; y += 8) {
      if (pacMan.rand() < 0.03) {
        pacMan.killScreenTileX = Math.floor(pacMan.rand() * 25) * 10;
        pacMan.killScreenTileY = Math.floor(pacMan.rand() * 2) * 10;
      }

      pacMan.createKillScreenElement(x, y, 8, 8, true);
    }
  }

  pacMan.changeGameplayMode(PM_GAMEPLAY_INFINITE_GAMEOVER);
};  

for (var j = 0; j < pacMan.playerCount; j++) {
  if (pacMan.actors[i].tilePos[0] == pacMan.actors[j].tilePos[0] &&
      pacMan.actors[i].tilePos[1] == pacMan.actors[j].tilePos[1]) {

    // If the ghost is blue, Pac-Man eats the ghost...
    if (pacMan.actors[i].mode == PM_GHOST_MODE_FRIGHT) {
      pacMan.ghostDies(i, j);

      // return here prevents from two ghosts being eaten at the same time
      return;
    } else {
      // ...otherwise, the ghost kills Pac-Man
      if (pacMan.actors[i].mode != PM_GHOST_MODE_EYES &&
          pacMan.actors[i].mode != PM_GHOST_MODE_IN_PEN &&
          pacMan.actors[i].mode != PM_GHOST_MODE_EXITING_PEN &&
          pacMan.actors[i].mode != PM_GHOST_MODE_REEXITING_PEN &&
          pacMan.actors[i].mode != PM_GHOST_MODE_REENTERING_PEN) {
        pacMan.playerDies(j);
      }
    }
  }
}

switch (this.id) {
  // Blinky always follows the player.
  case pacMan.playerCount:
    this.targetPos = [player.tilePos[0], player.tilePos[1]];
    break;

  // Pinky follows a tile ahead of player.
  case pacMan.playerCount + 1:
    this.targetPos = [player.tilePos[0], player.tilePos[1]];
    var movement = PM_MOVEMENTS[player.dir];
    this.targetPos[movement.axis] +=
        4 * PM_TILE_SIZE * movement.increment;

    // Recreating the original Pac-Man bug, in which UP = UP+LEFT
    if (player.dir == PM_DIR_UP) {
      this.targetPos[1] -= 4 * PM_TILE_SIZE;
    }
    break;

  // Inky uses a convoluted scheme averaging Blinky's position and
  // an offset tile.
  case pacMan.playerCount + 2:
    var blinky = pacMan.actors[pacMan.playerCount];

    var offsetPos = [player.tilePos[0], player.tilePos[1]];
    var movement = PM_MOVEMENTS[player.dir];
    offsetPos[movement.axis] +=
        2 * PM_TILE_SIZE * movement.increment;

    // Recreating the original Pac-Man bug, in which UP = UP+LEFT
    if (player.dir == PM_DIR_UP) {
      offsetPos[1] -= 2 * PM_TILE_SIZE;
    }

    this.targetPos[0] = offsetPos[0] * 2 - blinky.tilePos[0];
    this.targetPos[1] = offsetPos[1] * 2 - blinky.tilePos[1];
    break;

  // Clyde uses Pac-Man's position if further away, scatter position
  // if close.
  case pacMan.playerCount + 3:
    var distance = pacMan.getDistance(player.tilePos, this.tilePos);

    if (distance > (8 * PM_TILE_SIZE)) {
      this.targetPos = [player.tilePos[0], player.tilePos[1]];
    } else {
      this.targetPos = this.scatterPos;
    }
    break;
}

/**
 * For two-player game (with Pac-Man and Ms. Pac-Man) each ghosts randomly
 * focuses on one of the players. This changes every time a ghost leaves
 * a pen to make things more interesting.
 */
PacManActor.prototype.updateTargetPlayerId = function() {
  if (this.id >= pacMan.playerCount) {
    this.targetPlayerId = Math.floor(pacMan.rand() * pacMan.playerCount);
  }
};

/**
 * Send a random number from 0 to 1. The reason we're not using Math.random()
 * is that you can't seed it reliably on all the browsers -- and we need
 * random numbers to be repeatable between game plays too allow for patterns
 * etc., and also a consistent kill screen that's procedurally generated.
 * @return {number} Random number from 0 to 1.
 */
pacMan.rand = function() {
  var t32 = 0x100000000;
  var constant = 134775813;
  var x = (constant * pacMan.randSeed + 1);
  return (pacMan.randSeed = x % t32) / t32;
};

// We want to be more forgiving with control. If the player presses
// the arrow one or two pixels *after* the intersection, we still want
// to allow the turn.
var tile = pacMan.playfield[this.tilePos[0]][this.tilePos[1]];
if (tile && (tile.allowedDir & newDir)) {
  var movement = PM_MOVEMENTS[this.dir];
  var newPos = [this.pos[0], this.pos[1]];
  newPos[movement.axis] -= movement.increment;

  ...

  if (backtrackDist) {
    this.dir = newDir;
    this.pos[0] = this.tilePos[0];
    this.pos[1] = this.tilePos[1];
    var movement = PM_MOVEMENTS[this.dir];
    this.pos[movement.axis] += movement.increment * backtrackDist;
    return;
  }
}      

  // If Marcin was a good programmer, the algorithms governing Pac-Man
  // movements would be rock solid. That is not the case. Ryan found a bug
  // once that made him go through a wall. If Marcin was a good tester, he
  // would figure out how to reproduce and fix the bug. That is not the
  // case. Hence a little protection below. This checks if a new tile is
  // actually a valid path and if not, go back to the last-known good tile
  // and stop Pac-Man in its tracks. This is essentially a "treating
  // symptoms" protection, but hey, it's better than nothing, right?
  if (!this.ghost && !pacMan.playfield[tilePos[0]][tilePos[1]].path) {
    this.pos[0] = this.lastGoodTilePos[0];
    this.pos[1] = this.lastGoodTilePos[1];
    tilePos[0] = this.lastGoodTilePos[0];
    tilePos[1] = this.lastGoodTilePos[1];
    this.dir = PM_DIR_NONE;
  } else {
    this.lastGoodTilePos = [tilePos[0], tilePos[1]];
  }

var FRAME_COUNT = 81;
var ANIMATION_POS = [[0,0,0,0],[87,114,34,40],[92,49,82,105],[92,49,82,107],[93,49,81,112],[100,136,40,26], ...

var curFrame = 0;
var jointWidth = 0;

function nextStep() {
  var animPos = ANIMATION_POS[curFrame];
  
  if (animPos[0]) {
    var frameEl = document.createElement('div');
    frameEl.style.left = animPos[0] + 'px';
    frameEl.style.top = animPos[1] + 'px';
    frameEl.style.width = animPos[2] + 'px';
    frameEl.style.height = animPos[3] + 'px';
    frameEl.style.backgroundPosition = (-jointWidth) + 'px 0';
    
    canvasEl.appendChild(frameEl);
   
    curFrame++;
    jointWidth += animPos[2];
  }