pyscript/examples/mario/js/player.js

(function () {
  if (typeof Mario === "undefined") window.Mario = {};

  var Player = (Mario.Player = function (pos) {
    //I know, I know, there are a lot of variables tracking Mario's state.
    //Maybe these can be consolidated some way? We'll see once they're all in.
    this.power = 0;
    this.coins = 0;
    this.powering = [];
    this.bounce = false;
    this.jumping = 0;
    this.canJump = true;
    this.invincibility = 0;
    this.crouching = false;
    this.fireballs = 0;
    this.runheld = false;
    this.noInput = false;
    this.targetPos = [];

    Mario.Entity.call(this, {
      pos: pos,
      sprite: new Mario.Sprite("sprites/player.png", [80, 32], [16, 16], 0),
      hitbox: [0, 0, 16, 16],
    });
  });

  Mario.Util.inherits(Player, Mario.Entity);

  Player.prototype.run = function () {
    this.maxSpeed = 2.5;
    if (this.power == 2 && !this.runheld) {
      this.shoot();
    }
    this.runheld = true;
  };

  Player.prototype.shoot = function () {
    if (this.fireballs >= 2) return; //Projectile limit!
    this.fireballs += 1;
    var fb = new Mario.Fireball([this.pos[0] + 8, this.pos[1]]); //I hate you, Javascript.
    fb.spawn(this.left);
    this.shooting = 2;
  };

  Player.prototype.noRun = function () {
    this.maxSpeed = 1.5;
    this.moveAcc = 0.07;
    this.runheld = false;
  };

  Player.prototype.moveRight = function () {
    //we're on the ground
    if (this.vel[1] === 0 && this.standing) {
      if (this.crouching) {
        this.noWalk();
        return;
      }
      this.acc[0] = this.moveAcc;
      this.left = false;
    } else {
      this.acc[0] = this.moveAcc;
    }
  };

  Player.prototype.moveLeft = function () {
    if (this.vel[1] === 0 && this.standing) {
      if (this.crouching) {
        this.noWalk();
        return;
      }
      this.acc[0] = -this.moveAcc;
      this.left = true;
    } else {
      this.acc[0] = -this.moveAcc;
    }
  };

  Player.prototype.noWalk = function () {
    this.maxSpeed = 0;
    if (this.vel[0] === 0) return;

    if (Math.abs(this.vel[0]) <= 0.1) {
      this.vel[0] = 0;
      this.acc[0] = 0;
    }
  };

  Player.prototype.crouch = function () {
    if (this.power === 0) {
      this.crouching = false;
      return;
    }

    if (this.standing) this.crouching = true;
  };

  Player.prototype.noCrouch = function () {
    this.crouching = false;
  };

  Player.prototype.jump = function () {
    if (this.vel[1] > 0) {
      return;
    }
    if (this.jumping) {
      this.jumping -= 1;
    } else if (this.standing && this.canJump) {
      this.jumping = 20;
      this.canJump = false;
      this.standing = false;
      this.vel[1] = -6;
      if (this.power === 0) {
        sounds.smallJump.currentTime = 0;
        sounds.smallJump.play();
      } else {
        sounds.bigJump.currentTime = 0;
        sounds.bigJump.play();
      }
    }
  };

  Player.prototype.noJump = function () {
    this.canJump = true;
    if (this.jumping) {
      if (this.jumping <= 16) {
        this.vel[1] = 0;
        this.jumping = 0;
      } else this.jumping -= 1;
    }
  };

  Player.prototype.setAnimation = function () {
    if (this.dying) return;

    if (this.starTime) {
      var index;
      if (this.starTime > 60) index = Math.floor(this.starTime / 2) % 3;
      else index = Math.floor(this.starTime / 8) % 3;

      this.sprite.pos[1] = level.invincibility[index];
      if (this.power == 0) {
        this.sprite.pos[1] += 32;
      }
      this.starTime -= 1;
      if (this.starTime == 0) {
        switch (this.power) {
          case 0:
            this.sprite.pos[1] = 32;
            break;
          case 1:
            this.sprite.pos[1] = 0;
            break;
          case 2:
            this.sprite.pos[1] = 96;
            break;
        }
      }
    }
    //okay cool, now set the sprite
    if (this.crouching) {
      this.sprite.pos[0] = 176;
      this.sprite.speed = 0;
      return;
    }

    if (this.jumping) {
      this.sprite.pos[0] = 160;
      this.sprite.speed = 0;
    } else if (this.standing) {
      if (Math.abs(this.vel[0]) > 0) {
        if (this.vel[0] * this.acc[0] >= 0) {
          this.sprite.pos[0] = 96;
          this.sprite.frames = [0, 1, 2];
          if (this.vel[0] < 0.2) {
            this.sprite.speed = 5;
          } else {
            this.sprite.speed = Math.abs(this.vel[0]) * 8;
          }
        } else if (
          (this.vel[0] > 0 && this.left) ||
          (this.vel[0] < 0 && !this.left)
        ) {
          this.sprite.pos[0] = 144;
          this.sprite.speed = 0;
        }
      } else {
        this.sprite.pos[0] = 80;
        this.sprite.speed = 0;
      }
      if (this.shooting) {
        this.sprite.pos[0] += 160;
        this.shooting -= 1;
      }
    }

    if (this.flagging) {
      this.sprite.pos[0] = 192;
      this.sprite.frames = [0, 1];
      this.sprite.speed = 10;
      if (this.vel[1] === 0) this.sprite.frames = [0];
    }

    //which way are we facing?
    if (this.left) {
      this.sprite.img = "sprites/playerl.png";
    } else {
      this.sprite.img = "sprites/player.png";
    }
  };

  Player.prototype.update = function (dt, vX) {
    if (this.powering.length !== 0) {
      var next = this.powering.shift();
      if (next == 5) return;
      this.sprite.pos = this.powerSprites[next];
      this.sprite.size = this.powerSizes[next];
      this.pos[1] += this.shift[next];
      if (this.powering.length === 0) {
        delete level.items[this.touchedItem];
      }
      return;
    }

    if (this.invincibility) {
      this.invincibility -= Math.round(dt * 60);
    }

    if (this.waiting) {
      this.waiting -= dt;
      if (this.waiting <= 0) {
        this.waiting = 0;
      } else return;
    }

    if (this.bounce) {
      this.bounce = false;
      this.standing = false;
      this.vel[1] = -3;
    }

    if (this.pos[0] <= vX) {
      this.pos[0] = vX;
      this.vel[0] = Math.max(this.vel[0], 0);
    }

    if (Math.abs(this.vel[0]) > this.maxSpeed) {
      this.vel[0] -= (0.05 * this.vel[0]) / Math.abs(this.vel[0]);
      this.acc[0] = 0;
    }

    if (this.dying) {
      if (this.pos[1] < this.targetPos[1]) {
        this.vel[1] = 1;
      }
      this.dying -= 1 * dt;
      if (this.dying <= 0) {
        player = new Mario.Player(level.playerPos);
        level.loader.call();
        input.reset();
      }
    } else {
      this.acc[1] = 0.25;
      if (this.pos[1] > 240) {
        this.die();
      }
    }

    if (this.piping) {
      this.acc = [0, 0];
      var pos = [Math.round(this.pos[0]), Math.round(this.pos[1])];
      if (pos[0] === this.targetPos[0] && pos[1] === this.targetPos[1]) {
        this.piping = false;
        this.pipeLoc.call();
      }
    }

    if (this.flagging) {
      this.acc = [0, 0];
    }

    if (this.exiting) {
      this.left = false;
      this.flagging = false;
      this.vel[0] = 1.5;
      if (this.pos[0] >= this.targetPos[0]) {
        this.sprite.size = [0, 0];
        this.vel = [0, 0];
        window.setTimeout(function () {
          player.sprite.size = player.power === 0 ? [16, 16] : [16, 32];
          player.exiting = false;
          player.noInput = false;
          level.loader();
          if (player.power !== 0) player.pos[1] -= 16;
          music.overworld.currentTime = 0;
        }, 5000);
      }
    }

    //approximate acceleration
    this.vel[0] += this.acc[0];
    this.vel[1] += this.acc[1];
    this.pos[0] += this.vel[0];
    this.pos[1] += this.vel[1];

    this.setAnimation();
    this.sprite.update(dt);
  };

  Player.prototype.checkCollisions = function () {
    if (this.piping || this.dying) return;
    //x-axis first!
    var h = this.power > 0 ? 2 : 1;
    var w = 1;
    if (this.pos[1] % 16 !== 0) {
      h += 1;
    }
    if (this.pos[0] % 16 !== 0) {
      w += 1;
    }
    var baseX = Math.floor(this.pos[0] / 16);
    var baseY = Math.floor(this.pos[1] / 16);

    for (var i = 0; i < h; i++) {
      if (baseY + i < 0 || baseY + i >= 15) continue;
      for (var j = 0; j < w; j++) {
        if (baseY < 0) {
          i++;
        }
        if (level.statics[baseY + i][baseX + j]) {
          level.statics[baseY + i][baseX + j].isCollideWith(this);
        }
        if (level.blocks[baseY + i][baseX + j]) {
          level.blocks[baseY + i][baseX + j].isCollideWith(this);
        }
      }
    }
  };

  Player.prototype.powerUp = function (idx) {
    sounds.powerup.play();
    this.powering = [
      0, 5, 2, 5, 1, 5, 2, 5, 1, 5, 2, 5, 3, 5, 1, 5, 2, 5, 3, 5, 1, 5, 4,
    ];
    this.touchedItem = idx;

    if (this.power === 0) {
      this.sprite.pos[0] = 80;
      var newy = this.sprite.pos[1] - 32;
      this.powerSprites = [
        [80, newy + 32],
        [80, newy + 32],
        [320, newy],
        [80, newy],
        [128, newy],
      ];
      this.powerSizes = [
        [16, 16],
        [16, 16],
        [16, 32],
        [16, 32],
        [16, 32],
      ];
      this.shift = [0, 16, -16, 0, -16];
      this.power = 1;
      this.hitbox = [0, 0, 16, 32];
    } else if (this.power == 1) {
      var curx = this.sprite.pos[0];
      this.powerSprites = [
        [curx, 96],
        [curx, level.invincibility[0]],
        [curx, level.invincibility[1]],
        [curx, level.invincibility[2]],
        [curx, 96],
      ];
      this.powerSizes[([16, 32], [16, 32], [16, 32], [16, 32], [16, 32])];
      this.shift = [0, 0, 0, 0, 0];
      this.power = 2;
    } else {
      this.powering = [];
      delete level.items[idx];
      //no animation, but we play the sound and you get 5000 points.
    }
  };

  Player.prototype.damage = function () {
    if (this.power === 0) {
      //if you're already small, you dead!
      this.die();
    } else {
      //otherwise, you get turned into small mario
      sounds.pipe.play();
      this.powering = [
        0, 5, 1, 5, 2, 5, 1, 5, 2, 5, 1, 5, 2, 5, 1, 5, 2, 5, 1, 5, 2, 5, 3,
      ];
      this.shift = [0, 16, -16, 16];
      this.sprite.pos = [160, 0];
      this.powerSprites = [
        [160, 0],
        [240, 32],
        [240, 0],
        [160, 32],
      ];
      this.powerSizes = [
        [16, 32],
        [16, 16],
        [16, 32],
        [16, 16],
      ];
      this.invincibility = 120;
      this.power = 0;
      this.hitbox = [0, 0, 16, 16];
    }
  };

  Player.prototype.die = function () {
    //TODO: rewrite the way sounds work to emulate the channels of an NES.
    music.overworld.pause();
    music.underground.pause();
    music.overworld.currentTime = 0;
    music.death.play();
    this.noWalk();
    this.noRun();
    this.noJump();

    this.acc[0] = 0;
    this.sprite.pos = [176, 32];
    this.sprite.speed = 0;
    this.power = 0;
    this.waiting = 0.5;
    this.dying = 2;

    if (this.pos[1] < 240) {
      //falling into a pit doesn't do the animation.
      this.targetPos = [this.pos[0], this.pos[1] - 128];
      this.vel = [0, -5];
    } else {
      this.vel = [0, 0];
      this.targetPos = [this.pos[0], this.pos[1] - 16];
    }
  };

  Player.prototype.star = function (idx) {
    delete level.items[idx];
    this.starTime = 660;
  };

  Player.prototype.pipe = function (direction, destination) {
    sounds.pipe.play();
    this.piping = true;
    this.pipeLoc = destination;
    switch (direction) {
      case "LEFT":
        this.vel = [-1, 0];
        this.targetPos = [
          Math.round(this.pos[0] - 16),
          Math.round(this.pos[1]),
        ];
        break;
      case "RIGHT":
        this.vel = [1, 0];
        this.targetPos = [
          Math.round(this.pos[0] + 16),
          Math.round(this.pos[1]),
        ];
        break;
      case "DOWN":
        this.vel = [0, 1];
        this.targetPos = [
          Math.round(this.pos[0]),
          Math.round(this.pos[1] + this.hitbox[3]),
        ];
        break;
      case "UP":
        this.vel = [0, -1];
        this.targetPos = [
          Math.round(this.pos[0]),
          Math.round(this.pos[1] - this.hitbox[3]),
        ];
        break;
    }
  };

  Player.prototype.flag = function () {
    this.noInput = true;
    this.flagging = true;
    this.vel = [0, 2];
    this.acc = [0, 0];
  };

  Player.prototype.exit = function () {
    this.pos[0] += 16;
    this.targetPos[0] = level.exit * 16;
    this.left = true;
    this.setAnimation();
    this.waiting = 1;
    this.exiting = true;
  };
})();