Merge branches 'cleaning' and 'balancing'
authorMegaBrutal <code+git@megabrutal.com>
Thu, 28 Dec 2017 01:00:00 +0000 (02:00 +0100)
committerMegaBrutal <code+git@megabrutal.com>
Thu, 28 Dec 2017 01:00:00 +0000 (02:00 +0100)
modified:   ld40.js

1  2 
ld40.js

diff --combined ld40.js
index 7b14c05b870e51ba841e4ff0a0feb9d25c09fae8,892e1b1d62239d0ec497f90ce9ad7b69bee19f2f..f7954c2a7d4a0ae5239f12a0094744b2cafe8b7b
+++ b/ld40.js
@@@ -21,9 -21,8 +21,9 @@@
          const MONSTER_HEALTH          =     20;
          const MODE_DETERMINATION      =      0;
          const MODE_JUSTICE            =      1;
 -        const SPEED_PLAYER            =     50;
 -        const SPEED_PROJECTILE                =    500;
 +        const SPEED_PLAYER            =    150;
 +        const SPEED_PPROJECTILE               =    500;
 +        const SPEED_MPROJECTILE               =    200;
  
          window.addEventListener("keydown", function(e) {
              // Prevent default browser action for arrows and spacebar
                  this.lasttime_shoot = 0;
                  this.lasttime_mode = 0;
                  this.lasttime_damage = 0;
-                 this.speed = 150;
+                 this.speed = SPEED_PLAYER;
                  this.switchmode(MODE_DETERMINATION);
 -                this.projectiles = game.add.group();
 +                this.weapon = new JusticeBlaster(game, this);
 +                this.weapon.bulletSpeed = SPEED_PPROJECTILE;
                  this.healthBar = new HealthBar(60, game.world.height - (WALL_BORDERBOTTOM / 2));
              }
  
                      }
                      if ((this.mode == MODE_JUSTICE) && game.input.keyboard.isDown(Phaser.Keyboard.SPACEBAR) && ((game.time.now - this.lasttime_shoot) > WAIT_SHOOT))
                      {
 -                        this.shoot(0, SPEED_PROJECTILE);
 -                        this.shoot(0, -SPEED_PROJECTILE);
 -                        this.shoot(SPEED_PROJECTILE, 0);
 -                        this.shoot(-SPEED_PROJECTILE, 0);
 +                        this.shoot();
                      }
                  }
              }
                  this.mode = soulmode;
              }
  
 -            shoot(velocityx, velocityy) {
 -                var projectile = new Justice(this.x, this.y, velocityx, velocityy);
 -                projectile.enablePhysics();
 -                this.projectiles.add(projectile);
 +            shoot() {
 +                this.weapon.fire(this, 0, this.y);
 +                this.weapon.fire(this, this.x, 0);
 +                this.weapon.fire(this, this.x, game.world.height);
 +                this.weapon.fire(this, game.world.width, this.y);
                  this.lasttime_shoot = game.time.now;
              }
  
                  super.update();
                  this.control();
                  this.healthBar.update(this.love, this.maxHealth, this.health);
 +                game.physics.arcade.overlap(monsters, this.weapon.bullets, function(m,b) { b.overlap_monster(m); });
                  if ((game.time.now - this.lasttime_mode) > WAIT_SOULMODE) { this.switchmode(MODE_DETERMINATION); }
              }
          }
                  this.anchor.setTo(0.5, 0.5);
                  this.health = MONSTER_HEALTH;
                  this.nexttime_shoot = game.time.now;
 -                this.weapon = new Phaser.Weapon(game, this);
 -                this.weapon.x = x;
 -                this.weapon.y = y;
 -                this.weapon.createBullets(20, 'projectile');
 +                this.weapon = new JusticeBlaster(game, this);
 +                this.weapon.bulletSpeed = SPEED_MPROJECTILE;
 +                this.weapon.trackSprite(this);
              }
  
              enablePhysics() {
                      this.weapon.fireAtSprite(player);
                      this.nexttime_shoot = game.time.now + (WAIT_MONSTERSHOOT / 2) + (Math.random() * WAIT_MONSTERSHOOT);
                  }
 -                game.physics.arcade.overlap(player, this.weapon.bullets, function(p,b) { p.damage(p.love); });
 +                game.physics.arcade.overlap(player, this.weapon.bullets, function(p,b) { b.overlap_player(p); });
              }
          }
  
              }
          }
  
 -        class Justice extends Phaser.Sprite {
 -            constructor(x, y, velocityx, velocityy) {
 +        class Justice extends Phaser.Bullet {
 +            constructor(game, x, y, key, frame) {
                  super(game, x, y, 'projectile');
                  this.anchor.setTo(0.5, 0.5);
 -                this.velocityx = velocityx;
 -                this.velocityy = velocityy;
              }
  
 -            enablePhysics() {
 -                game.physics.arcade.enable(this);
 -                this.body.velocity.x = this.velocityx;
 -                this.body.velocity.y = this.velocityy;
 +            overlap_monster(entity) {
 +                entity.damage(player.love);
 +                this.kill();
              }
  
 -            overlap(entity) {
 -                entity.damage(player.love);
 +            overlap_player(player) {
 +                player.damage(player.love);
                  this.kill();
              }
          }
  
 +        class JusticeBlaster extends Phaser.Weapon {
 +            constructor(game, parent) {
 +                super(game, parent);
 +                this.bulletClass = Justice;
 +                this.multiFire = true;
 +                this.createBullets(100, null);
 +            }
 +        }
 +
          class HealthBar {
              constructor(x, y) {
                  this.mhealth = game.add.tileSprite(x + 10, y, 0, HB_THICKNESS, 'wall');
              nexttime_determination = Math.random() * WAIT_DETERMINATION;
  
              monsters = game.add.group();
-             monsters.add(new Monster(400, 500));
-             monsters.children.forEach(function(monster) { monster.enablePhysics(); });
-             nexttime_monsterspawn = WAIT_MONSTERSPAWN;
+             nexttime_monsterspawn = WAIT_MONSTERSPAWN / 4;
  
              player = new Player(game.world.width / 2, game.world.height / 2);
              player.enablePhysics();
              game.camera.follow(player);
              cursors = game.input.keyboard.createCursorKeys();
  
 -            keyboard_handler = keyPress_default;
 -
          }
  
          function update () {
              game.physics.arcade.collide(player, walls);
              game.physics.arcade.overlap(player, determinations, function(p,d) { p.overlap_determination(d); });
              game.physics.arcade.overlap(player, monsters, function(p,m) { m.overlap_player(p); });
 -            game.physics.arcade.overlap(monsters, player.projectiles, function(m,j) { j.overlap(m); });
  
              if (game.time.now > nexttime_determination)
              {
                  var monster = new Monster(Math.random() * game.world.width, Math.random() * game.world.height);
                  monster.enablePhysics();
                  monsters.add(monster);
-                 nexttime_monsterspawn = game.time.now + (WAIT_MONSTERSPAWN / player.love) + (Math.random() * WAIT_MONSTERSPAWN);
+                 var waittime = WAIT_MONSTERSPAWN - ((Math.random() * 2000) * player.love);
+                 nexttime_monsterspawn = game.time.now + waittime;
+                 console.log('Next monster in ' + waittime);
              }
  
              if ((game.time.now - player.lastmovetime) > WAIT_KEY) player.body.velocity.x = player.body.velocity.y = 0;
 -            if (keyboard_handler) keyboard_handler();
 -
 -        }
 -
 -        function keyPress_default() {
 -
 -            // Maybe needed later.
  
          }