153 create new wave

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "mochaExplorer.files": "test/**/*.spec.[jt]s",
+    "mochaExplorer.require": "ts-node/register"
+}

index.html

@@ -82,12 +82,15 @@
             { name: 'probe_explosion', url: 'images/probe_explosion.png' },
             { name: 'saucer', url: 'images/saucer.png' },
             { name: 'saucer_explosion', url: 'images/saucer_explosion.png' },
+            { name: 'spider', url: 'images/spider.png' },
+            { name: 'spider_explosion', url: 'images/spider_explosion.png' },
             { name: 'spinner', url: 'images/spinner.png' },
             { name: 'splitter', url: 'images/splitter.png' },
             { name: 'splitter_fragment', url: 'images/splitter_fragment.png' },
             { name: 'splitter_left_separation', url: 'images/splitter_left_separation.png' },
             { name: 'splitter_right_separation', url: 'images/splitter_right_separation.png' },
-            { name: 'star', url: 'images/star.png' }
+            { name: 'star', url: 'images/star.png' },
+            { name: 'web', url: 'images/web.png' }
         ];
         renderer.preLoadImages(images, onImagesLoaded);
 
@@ -165,7 +168,8 @@
             { name: 'player_explosion', url: 'sounds/player_explosion.mp3' },
             { name: 'player_hit', url: 'sounds/player_hit.mp3' },
             { name: 'probe_explosion', url: 'sounds/probe_explosion.mp3' },
-            { name: 'saucer_explosion', url: 'sounds/saucer_explosion.mp3' }
+            { name: 'saucer_explosion', url: 'sounds/saucer_explosion.mp3' },
+            { name: 'spider_explosion', url: 'sounds/spider_explosion.mp3' }
         ];
         audioPlayer.preLoadSounds(sounds, onSoundsLoaded, function(errors) {
             alert('Failed to load sounds: ' + JSON.stringify(errors));

src/Game.ts

@@ -16,6 +16,7 @@ import {Scheduler} from './timing/Scheduler';
 import {ScoreCounter} from './ScoreCounter';
 import {SecondWave} from './waves/SecondWave';
 import {SimpleWave} from './waves/SimpleWave';
+import {SpiderWave} from "./waves/SpiderWave";
 import {SpinnerWave} from './waves/SpinnerWave';
 import {SpinnerWave2} from './waves/SpinnerWave2';
 import {SplitterWave} from './waves/SplitterWave';
@@ -92,7 +93,7 @@ export class Game {
         if (this._isActive) {
             setTimeout(() => {
                 global.requestAnimationFrame(() => { this.tick() });
-            }, 1000/30);
+            }, 1000/40);
         }
         else {
             debug('ticker: Ticker stopping because game is over.');
@@ -188,6 +189,11 @@ export class Game {
                     new SimpleWave(this._audioPlayer, this._world, this._clock),
                     new SecondWave(this._audioPlayer, this._world, this._clock),
                     new SplitterWave(this._audioPlayer, this._world, this._clock)
+                ]),
+                new Level([
+                    new SpinnerWave(this._audioPlayer, this._world, this._clock),
+                    new SpinnerWave2(this._audioPlayer, this._world, this._clock),
+                    new SpiderWave(this._audioPlayer, this._world, this._clock)
                 ])
             ]
         );

src/Point.ts

@@ -43,6 +43,10 @@ export class Point {
         return new Point(this._x + count, this._y);
     }
 
+    equals(other: Point): boolean {
+        return this._x === other._x && this._y === other._y;
+    }
+
     toString(): string {
         return 'Point(x=' + this._x + ', y=' + this._y + ')';
     }

src/enemies/Spider.ts

@@ -0,0 +1,228 @@
+import Debug from "debug";
+const debug = Debug("Blaster:Saucer");
+import {random} from 'underscore';
+
+import {Actor} from "../Actor";
+import {AudioPlayer} from "../devices/AudioPlayer";
+import {Bounds} from '../Bounds';
+import {Clock} from "../timing/Clock";
+import {Enemy} from './Enemy';
+import {ExplosionProperties} from '../ExplosionProperties';
+import {HitArbiter} from '../HitArbiter';
+import {ImageDetails} from '../ImageDetails';
+import {LinePath} from '../paths/LinePath';
+import {LineSegmentPath} from "../paths/LineSegmentPath";
+import {PathAction} from '../paths/PathAction';
+import {PathEntry} from "../paths/PathEntry";
+import {Point} from '../Point';
+import {ScheduledAction} from '../paths/ScheduledAction';
+import {Scheduler} from '../timing/Scheduler';
+import {Web} from '../shots/Web';
+import {World} from "../World";
+
+export class Spider extends Enemy {
+    public static readonly InitialHealth: number = 1;
+
+    private readonly _clock: Clock;
+    private readonly _scheduler: Scheduler;
+    private readonly _hitArbiter: HitArbiter;
+    private readonly _homePosition: Point;
+    private _currentFrame: number = 0;
+    private _currentPath!: PathEntry[];
+    private _pathPosition!: number;
+    private _state: Spider.State;
+
+    constructor(audioPlayer: AudioPlayer, world: World, clock: Clock, startingPoint: Point, homePosition: Point) {
+        super(audioPlayer, world, startingPoint, Spider.InitialHealth);
+        debug('Spider constructor');
+
+        this._clock = clock;
+        this._scheduler = new Scheduler(clock);
+        this._hitArbiter = new HitArbiter(this);
+        this._homePosition = homePosition;
+
+        this.prepareEntryPath(homePosition);
+        this._state = Spider.State.Entering;
+        this.advanceCurrentFrame();
+    }
+
+    get state(): Spider.State {
+        return this._state;
+    }
+
+    get explosionProperties(): ExplosionProperties {
+        return new ExplosionProperties(
+            'spider_explosion',
+            5,
+            52,
+            0.8,
+            'spider_explosion'
+        );
+    }
+
+    get scoreTotal(): number {
+        return 10;
+    }
+
+    getCollisionMask(actor: Actor): Bounds[] {
+        return [new Bounds(-40, 40, -25, 25)];
+    }
+
+    getDamageAgainst(target: Actor): number {
+        return 5;
+    }
+
+    get imageDetails(): ImageDetails {
+        return new ImageDetails('spider', 3, 95, this._currentFrame);
+    }
+
+    hitBy(actor: Actor, damage: number): boolean {
+        this._health = Math.max(0, this._health - damage);
+        return true;
+    }
+
+    tick(): void {
+        debug('Spider.tick');
+        super.tick();
+
+        if (!this._isActive) {
+            return;
+        }
+
+        this._scheduler.executeDueOperations();
+
+        this.step();
+
+        // Check if this enemy has hit the player.
+        const player = this._world.player;
+        if (player) {
+            this._hitArbiter.attemptToHit(player);
+        }
+    }
+
+    private advanceCurrentFrame(): void {
+        this._currentFrame = (this._currentFrame + 1) % 3;
+
+        this._scheduler.scheduleOperation(
+            'advanceCurrentFrame',
+            200,
+            () => { this.advanceCurrentFrame() }
+        );
+    }
+
+    private dropWeb(): void {
+        const web = new Web(this._audioPlayer, this._clock, this._world, this._location);
+        this._world.addActor(web);
+    }
+
+    public swoop(): void {
+        if (random(0, 1) === 0) {
+            // Swoop down and off the screen.
+            const lowestPoint = new Point(Math.floor(random(10, 430)), 670);
+            const turns = random(0, 2);
+            switch (turns) {
+                case 0:
+                    const linePath = new LinePath(this._location, lowestPoint, [new ScheduledAction(0.50, PathAction.Fire)]);
+                    this._currentPath = linePath.getPathForSpeed(10);
+                    this._pathPosition = 0;
+                    this._state = Spider.State.Swooping;
+                    break;
+                case 1:
+                    const midPoint = new Point(Math.floor(random(10, 430)), random(300, 500));
+                    this._currentPath = new LineSegmentPath(
+                        [this._location, midPoint, lowestPoint],
+                        [new ScheduledAction(0.25, PathAction.Fire), new ScheduledAction(0.55, PathAction.Fire)]
+                    ).getPathForSpeed(10);
+                    this._pathPosition = 0;
+                    this._state = Spider.State.Swooping;
+                    break;
+                case 2:
+                    const midPoint1 = new Point(Math.floor(random(10, 430)), random(300, 400));
+                    const midPoint2 = new Point(Math.floor(random(10, 430)), random(400, 500));
+                    this._currentPath = new LineSegmentPath(
+                        [this._location, midPoint1, midPoint2, lowestPoint],
+                        [new ScheduledAction(0.30, PathAction.Fire), new ScheduledAction(0.60, PathAction.Fire)]
+                    ).getPathForSpeed(10);
+                    this._pathPosition = 0;
+                    this._state = Spider.State.Swooping;
+                    break;
+              }
+        }
+        else {
+            // Swoop and return to home.
+            const lowestPoint = new Point(Math.floor(random(10, 430)), 500);
+            const swoopDownPath = new LinePath(this._location, lowestPoint, []);
+            const swoopReturnPath = new LinePath(lowestPoint, this._homePosition, [new ScheduledAction(0.50, PathAction.Fire)]);
+            this._currentPath = swoopDownPath.getPathForSpeed(8).concat(swoopReturnPath.getPathForSpeed(10));
+            this._pathPosition = 0;
+            this._state = Spider.State.SwoopAndReturn;
+        }
+
+        if (random(0, 1) === 0) {
+            this.dropWeb();
+        }
+    }
+
+    private step(): void {
+        // Choose the next path to follow once we've reach the end of the current path.
+        if (this._pathPosition >= this._currentPath.length) {
+            switch (this._state) {
+                case Spider.State.Entering:
+                    this._state = Spider.State.Waiting;
+                    break;
+                case Spider.State.SwoopAndReturn:
+                    this._state = Spider.State.Waiting;
+                    break;
+                case Spider.State.Swooping:
+                    this._scheduler.scheduleOperation(
+                        'enter',
+                        3000,
+                        () => {
+                            // Determine our path back to our home position after.
+                            const worldDimensions = this._world.dimensions;
+                            const spiderStartingPoint = new Point(
+                                Math.floor(random(0, worldDimensions.width-50)),
+                                -20
+                            );
+                            // TODO: We might be able to call prepareEntryPath here instead.
+                            const linePath = new LinePath(spiderStartingPoint, this._homePosition, []);
+                            this._currentPath = linePath.getPathForSteps(10);
+                            this._pathPosition = 0;
+                            this._state = Spider.State.Entering;
+                        }
+                    );
+                    this._state = Spider.State.SwoopComplete;
+                    break;
+            }
+
+            return;
+        }
+
+        // Follow the current path.
+        switch(this._currentPath[this._pathPosition].action) {
+            case PathAction.Move:
+                this._location = this._currentPath[this._pathPosition].location!;
+                break;
+            case PathAction.Fire:
+                this.dropWeb();
+                break;
+        }
+        this._pathPosition++;
+    }
+
+    private prepareEntryPath(homePosition: Point): void {
+        const linePath = new LinePath(this._location, homePosition, []);
+        this._currentPath = linePath.getPathForSteps(10);
+        this._pathPosition = 0;
+    }
+}
+
+export namespace Spider {
+    export enum State {
+        Entering,
+        SwoopAndReturn,
+        SwoopComplete,
+        Swooping,
+        Waiting
+    }
+}

src/enemies/Spinner.ts

@@ -255,7 +255,7 @@ export class Spinner extends Enemy {
     }
 }
 
-export module Spinner {
+export namespace Spinner {
     export enum Bias {
         Left,
         Right

src/paths/LinePath.ts

@@ -17,7 +17,17 @@ export class LinePath {
         this._scheduledActions = scheduledActions;
     }
 
-    getPath(numberOfSteps: number): PathEntry[] {
+    getPathForSpeed(speed: number): PathEntry[] {
+        const lineLength = Math.sqrt(
+            Math.pow(this._end.x - this._start.x, 2) +
+            Math.pow(this._end.y - this._start.y, 2)
+        );
+        const numberOfSteps = Math.max(Math.floor(lineLength / speed), 1);
+
+        return this.getPathForSteps(numberOfSteps);
+    }
+
+    getPathForSteps(numberOfSteps: number): PathEntry[] {
         const path: PathEntry[] = [];
 
         const stepSize = 1.0 / numberOfSteps;