function nextFrame(elapsedTime) {
    // First, let's look at our avatar. If he's jumping, then figure out which
    // platform (if any) he's currently over.
    if (avatar.isJumping) {
      var lowestZFound = -5000;
      for (var i = 0; i < world.platforms.length; i++) {
        platform = world.platforms[i];
        if (platform.parentID == avatar.parentPlatformID ||
            i == avatar.parentPlatformID) {
          if (avatar.z > platform.z &&
              avatar.mapX > platform.left.mapX &&
              avatar.mapX < platform.right.mapX &&
              platform.z > lowestZFound && platform.isNotSolid != true) {
            lowestZFound = world.platforms[i].z
            avatar.platformID = i;
          }
        }
      }
    }
  
    // Create a myPlatform variable for convenience.
    var myPlatform = world.platforms[avatar.platformID]
  
    // Platforms without a parentID aren't really platforms. The actually define
    // the "world path" that meanders through our level. Therefore, if the only
    // platform that Io is over is one of these, then our current GROUNDZ (aka
    // the nearest walkable altitude),
    if (exists(myPlatform.parentID)) {
      GROUNDZ = myPlatform.z
      avatar.parentPlatformID = myPlatform.parentID;
    } else {
      GROUNDZ = -5000;
      avatar.parentPlatformID = avatar.platformID;
    }
  
    // The avatar's mapX is really important. It defines his position in the
    // imaginary 2d platformer that we weave through a 3D world. When he's at
    // mapX of 0, he's at the far left of the level (think super mario.) As
    // he proceeds through the level, his mapX will get bigger. Meanwhile, his
    // actual x, y, and z (aka altitude) values will be kept track of as well.
    // Anyway, every platform that Io can stand on has a "left" and a "right"
    // to them. Let's check to see if we've walked off of it...
    if (avatar.mapX < myPlatform.left.mapX) {
      // Whoa! We've walked off the left of our platform! If there's an adjacent
      // platform to step onto, then do that. Otherwise, it's fallin' time.
      if (exists(myPlatform.left.adjacentID)) {
        // Do some math to ensure that our actual x and y values are corrected
        // so Io stays perfectly in our "world path" plane.
        oldPlatform = myPlatform;
        overshot = avatar.mapX - myPlatform.left.mapX;
        avatar.platformID = myPlatform.left.adjacentID;
        myPlatform = world.platforms[avatar.platformID];
        avatar.x -= Math.cos(oldPlatform.rotZ) * overshot;
        avatar.y -= Math.sin(oldPlatform.rotZ) * overshot;
        avatar.x += Math.cos(myPlatform.rotZ) * overshot;
        avatar.y += Math.sin(myPlatform.rotZ) * overshot;
      } else {
        GROUNDZ = -5000;
      }
    } else if (avatar.mapX > myPlatform.right.mapX) {
      // Whoa! We've walked off the right of our platform!
      if (exists(myPlatform.right.adjacentID)) {
        oldPlatform = myPlatform;
        overshot = avatar.mapX - myPlatform.right.mapX;
        avatar.platformID = myPlatform.right.adjacentID;
        myPlatform = world.platforms[avatar.platformID];
        avatar.x -= Math.cos(oldPlatform.rotZ) * overshot;
        avatar.y -= Math.sin(oldPlatform.rotZ) * overshot;
        avatar.x += Math.cos(myPlatform.rotZ) * overshot;
        avatar.y += Math.sin(myPlatform.rotZ) * overshot;
      } else {
        GROUNDZ = -5000;
      }
    }
  
    // Now it's time to figure out if there's a "obstacle" nearby. Each platform
    // can potentially have a left.obstacleHeight and/or a right.obstableHeight.
    // We'll store how close any of them are in these OBSTABLE_LEFT type
    // "constants."
    OBSTACLE_RIGHT = 9000
    OBSTACLE_RIGHT_HEIGHT = 0
    OBSTACLE_LEFT = 9000
    OBSTACLE_LEFT_HEIGHT = 0
  
    if (myPlatform.right.obstacleHeight > 0) {
      OBSTACLE_RIGHT = myPlatform.right.mapX - avatar.mapX;
      OBSTACLE_RIGHT_HEIGHT = myPlatform.right.obstacleHeight - avatar.velZ + 20;
    }
    if (myPlatform.left.obstacleHeight > 0) {
      OBSTACLE_LEFT = avatar.mapX - myPlatform.left.mapX;
      OBSTACLE_LEFT_HEIGHT = myPlatform.left.obstacleHeight - avatar.velZ + 20;
    }
  
    // So... now that we've figured all of that stuff out, let's store how
    // far *above* the current platform Io is.
    avatar.relativeZ = avatar.z - myPlatform.z;
  
    // This special variable, avatar.groundZ, can be set by moving
    // platforms and other actors to override our actual groundZ. This allows
    // the avatar to "float" in space (or really, to stand on stuff that's
    // not a static platform but a moving one.) So if we find that variable,
    // it trumps the calculated GROUNDZ. However, we *always* clear that
    // variable out after using it. It's up to the Actor who is moving Io to
    // keep this updated inside their onTick event. (See horizontalpad.js for
    // an example of this.)
    if (exists(avatar.groundZ)) {
      GROUNDZ = avatar.groundZ;
      avatar.groundZ = undefined;
    }
  
    // Gah. Another one of our "special constants" that used to be updated
    // by SketchUp but now is done via JS data structures.
    // TODO: Clean 'tup.
    WORLD_ANGLE = myPlatform.rotZ;
  
    // Check for keyboard stuff.
    handleInput();
  
    // Handle falling and gravity.
    avatar.z += avatar.velZ;
    if (avatar.z - GROUNDZ > 1) {
      avatar.isJumping = true;
    } else {
      if (avatar.isJumping == true) {
        soundPlayer.play('sound/step2.mp3', 100);
      }
      avatar.isJumping = false;
    }
    if (avatar.isJumping == true) {
      avatar.velZ += GRAVITY;
    }
    if (avatar.z < GROUNDZ) {
      avatar.velZ = 0;
      avatar.z = GROUNDZ + .1;
      avatar.isJumping = false;
      avatar.animation = 'Hero_Run';
  
    }
    if (avatar.z < -1000) {
      avatar.x = 0;
      avatar.y = 0;
      avatar.z = 200;
      avatar.mapX = 0;
      avatar.platformID = 0;
      avatar.parentPlatformID = 0;
    }
  
    // Handle collision with things to the left and right of our avatar.
    // From here is where we start to decide which animation cycle we're on.
    // Now you can see how we're using avatar.relativeZ along with our
    // OBSTACLE_FOO "special constants" to determine not only if we've hit an
    // obstacle, but whether we've jumped high enough to get over it.
    if (OBSTACLE_LEFT < 25 && keyIsDown[LEFT] &&
        OBSTACLE_LEFT_HEIGHT > avatar.relativeZ) {
      avatar.targetVelX = 0;
      avatar.animation = 'Hero_Stand';
      avatar.frame = 1;
    }
    if (OBSTACLE_RIGHT < 25 && keyIsDown[RIGHT] &&
        OBSTACLE_RIGHT_HEIGHT > avatar.relativeZ) {
      avatar.targetVelX = 0;
      avatar.animation = 'Hero_Stand';
      avatar.frame = 1;
    }
  
    // If we're jumping, then use the jumping animation cycle.
    if (avatar.isJumping == true) {
      avatar.animation = 'Hero_Jump';
      if (avatar.velZ > 0) {
        avatar.frame++;
        if (avatar.frame > 3) {
          avatar.frame = 3;
        }
      } else {
        if (avatar.z > GROUNDZ + 20) {
          avatar.frame = 4;
        } else {
          avatar.frame = 5;
        }
      }
    }
  
    // Figure out which frame to display inside our current cycle.
    didSwordStrike = '0';
    if (avatar.animation == 'Hero_Run') {
      avatar.frame++;
      if (avatar.frame > 10) {
        avatar.frame = 1;
      }
      if (avatar.frame % 5 == 0) {
        var soundToPlay = 'sound/step'
        soundToPlay += (Math.floor(Math.random() * 3) + 1);
        soundToPlay += '.mp3'
        soundPlayer.play(soundToPlay, 100);
      }
    } else if (avatar.animation == 'Hero_Sword') {
      avatar.targetVelX = 0;
      avatar.framesSinceShot = 0;
      avatar.frame += avatar.swordRate;
      if (avatar.frame < 1) {
        avatar.animation = 'Hero_Stand'
          avatar.frame = 1;
      } else if (avatar.frame > 6) {
        avatar.swordRate = -.5;
        avatar.frame = 6 + avatar.swordRate;
        didSwordStrike = '1';
      } else if (avatar.frame == 3 && avatar.swordRate < 0) {
        if (swingAgain == true) {
          avatar.swordRate = 1;
          swingAgain = false;
        } else {
          avatar.swordRate = -.5;
        }
      }
  
      if (avatar.frame == 3 && avatar.swordRate > 0) {
        soundPlayer.play('sound/_MISS.mp3', 100);
      }
    }
  
    // Update our position.
    avatar.velX = (avatar.velX + avatar.targetVelX + avatar.targetVelX) / 3;
    if (Math.abs(avatar.velX) < .2) {
      avatar.velX = 0;
    }
    avatar.mapX += avatar.velX;
    avatar.x += avatar.velX * Math.cos(WORLD_ANGLE);
    avatar.y += avatar.velX * Math.sin(WORLD_ANGLE);
    avatar.rotZ = (avatar.rotZ + avatar.targetRotZ + avatar.targetRotZ) / 3;
  
    // Calculate our final frameName string to pass to SketchUp (or o3d).
    frameName = avatar.animation;
    if (avatar.frame < 10) {
      frameName += '0';
    }
    frameName += Math.floor(avatar.frame);
    if (avatar.framesSinceShot > 0) {
      frameName += 'Shoot';
      avatar.framesSinceShot--;
    }
    if (avatar.framesSinceShot == 3) {
      // TODO: Make this work with multiple arrows, perform
      // better, and be smart enough to handle level reloads.
      if (top.arrowActor == undefined) {
        for (var actorID = 0; actorID < world.actors.length; actorID++) {
          arrow = world.actors[actorID];
          if (arrow.name.indexOf('Arrow') == 0) {
            top.arrowActor = arrow;
            top.arrowActor.shoot();
          }
        }
      } else {
        top.arrowActor.shoot();
      }
    }
    avatar.frameName = frameName;
  
    // Here's where we send our state down to SketchUp or O3D.
    // Always do our avatar last, since he's the one likely to have
    // been modified by other things in the environment. (Our avatar
    // is guaranteed by the level exporter to be in world.actors[0])
    for (i = world.actors.length - 1; i >= 0; i--) {
      world.actors[i].onTick(elapsedTime);
    }
  
    // Now move the camera in a pleasing motion to float over Io's
    // right shoulder. (Well, it's his right shoulder when he's
    // facing "right" toward the end of the level.)
    newEyeX = avatar.x + 350 * Math.sin(WORLD_ANGLE);
    newEyeY = avatar.y - 350 * Math.cos(WORLD_ANGLE);
    newEyeZ = avatar.z + 150;
    eyeX = (newEyeX + eyeX * CAMERA_SOFTNESS) / (CAMERA_SOFTNESS + 1);
    eyeY = (newEyeY + eyeY * CAMERA_SOFTNESS) / (CAMERA_SOFTNESS + 1);
    eyeZ = (newEyeZ + eyeZ * CAMERA_SOFTNESS) / (CAMERA_SOFTNESS + 1);
    targetX = (avatar.x + targetX) / 2;
    targetY = (avatar.y + targetY) / 2;
    targetZ = (avatar.z + 200 + targetZ * 3) / 5;
  
    // Here's where we send our camera down to SketchUp or O3D.
    updateCamera(targetX, targetY, targetZ, eyeX, eyeY, eyeZ)
  
    // If we're running inside SketchUp, clear out our old timer and set a new
    // one.
    if (isSU) {
      clearTimeout(timerID);
      timerID = self.setTimeout('nextFrame()', FRAME_DELAY);
    }
  }