Origin/new engine features (#2)

* isolate features

.gitignore

@@ -10,6 +10,9 @@ dist/*
 # Include the built-in asset folder
 !dist/builtin/
 
+# Include the hw1 assets
+!dist/hw3_assets/
+
 # Include the hw1 assets
 !dist/hw4_assets/
 

src/Wolfie2D/AI/AIManager.ts

@@ -1,6 +1,7 @@
 import Actor from "../DataTypes/Interfaces/Actor";
 import Updateable from "../DataTypes/Interfaces/Updateable";
 import AI from "../DataTypes/Interfaces/AI";
+import GoapAI from "../DataTypes/Interfaces/GoapAI"
 import Map from "../DataTypes/Map";
 
 /**
@@ -39,7 +40,7 @@ export default class AIManager implements Updateable {
 	 * @param name The name of the AI to register
 	 * @param constr The constructor for the AI
 	 */
-	registerAI(name: string, constr: new <T extends AI>() => T ): void {
+	registerAI(name: string, constr: new <T extends AI | GoapAI>() => T ): void {
 		this.registeredAI.add(name, constr);
 	}
 
@@ -48,7 +49,7 @@ export default class AIManager implements Updateable {
 	 * @param name The name of the AI to add
 	 * @returns A new AI instance
 	 */
-	generateAI(name: string): AI {
+	generateAI(name: string): AI | GoapAI {
 		if(this.registeredAI.has(name)){
 			return new (this.registeredAI.get(name))();
 		} else {

src/Wolfie2D/AI/GoapActionPlanner.ts

@@ -0,0 +1,82 @@
+import Graph from "../DataTypes/Graphs/Graph";
+import GoapAction from "../DataTypes/Interfaces/GoapAction";
+import GoapAI from "../DataTypes/Interfaces/GoapAI";
+import Queue from "../DataTypes/Queue";
+import Stack from "../DataTypes/Stack";
+import GraphUtils from "../Utils/GraphUtils";
+
+export default class GoapActionPlanner {
+    mapping: Map<number,GoapAction | string>;
+    graph: Graph;
+    path: Array<number>;
+
+    plan(goal: string, possibleActions: Array<GoapAction>, currentStatus: Array<string>, actor: GoapAI): Stack<GoapAction> {
+        this.graph = new Graph(true);
+        this.mapping = new Map();
+
+        //0 is our root
+        this.graph.addNode();
+        this.mapping.set(0,"Start");
+        //1 is the goal
+        this.graph.addNode();
+        this.mapping.set(1,"Goal");
+        this.graph.addEdge(1,1,Number.POSITIVE_INFINITY);
+
+        //Build tree from 0 to 1
+        this.buildTree(0, goal, possibleActions, currentStatus);
+        console.log(this.graph.toString());
+
+        //Run djikstra to find shortest path
+        this.path = GraphUtils.djikstra(this.graph, 0);
+
+        //Push all elements of the plan
+        let plan = new Stack<GoapAction>();
+		
+		let i = 1;
+		while(this.path[i] !== -1){
+            console.log(this.path[i]);
+            if (this.path[i] !== 0){
+			    plan.push(<GoapAction>this.mapping.get(this.path[i]));
+            }
+			i = this.path[i];
+		}
+        
+        return plan;
+    }
+
+    buildTree(root: number, goal:string, possibleActions: Array<GoapAction>, currentStatus: Array<string>): void {
+        //For each possible action 
+        possibleActions.forEach(action => {
+            console.log("root:" + root + ",action precons:" + action.preconditions.toString() 
+                + ", action effects:" + action.effects.toString() + ", current Status:" + currentStatus.toString())
+
+            //Can it be performed?
+            if (action.checkPreconditions(currentStatus)){
+                //This action can be performed
+                //Add effects to currentStatus
+                let newStatus = [...currentStatus];
+                newStatus.push(...action.effects);
+
+                //Check if the new node is the goal
+                if (newStatus.includes(goal)){
+                    console.log("AT GOAL");
+                    let newNode = this.graph.addNode() - 1;
+                    this.mapping.set(newNode, action);
+                    this.graph.addEdge(root, newNode, action.cost);
+                    this.graph.addEdge(newNode, 1, 0);
+                    return;
+                }
+
+                //Add node and edge from root
+                let newNode = this.graph.addNode() - 1;
+                this.mapping.set(newNode, action);
+                this.graph.addEdge(root, newNode, action.cost);
+                
+                //Recursive call
+                console.log(possibleActions.indexOf(action))
+                let newActions = possibleActions.filter(act => act !== action)
+                this.buildTree(newNode, goal, newActions, action.effects);
+            }
+        });
+    }
+}

src/Wolfie2D/AI/StateMachineGoapAI.ts

@@ -0,0 +1,40 @@
+import GoapAction from "../DataTypes/Interfaces/GoapAction";
+import GoapAI from "../DataTypes/Interfaces/GoapAI";
+import Queue from "../DataTypes/Queue";
+import Stack from "../DataTypes/Stack";
+import StateMachine from "../DataTypes/State/StateMachine";
+import GameNode from "../Nodes/GameNode";
+import GoapActionPlanner from "./GoapActionPlanner";
+
+/**
+ * A version of a @reference[StateMachine] that is configured to work as an AI controller for a @reference[GameNode]
+ */
+ export default class StateMachineGoapAI extends StateMachine implements GoapAI {
+	/**	The GameNode that uses this StateMachine for its AI */
+	protected owner: GameNode;
+
+	goal: string;
+
+    currentStatus: Array<string>;
+
+    possibleActions: Array<GoapAction>;
+
+    plan: Stack<GoapAction>;
+    
+    planner: GoapActionPlanner;
+
+	// @implemented
+	initializeAI(owner: GameNode, config: Record<string, any>): void {}
+
+	// @implemented
+	destroy(){
+		// Get rid of our reference to the owner
+		delete this.owner;
+		this.receiver.destroy();
+	}
+
+	// @implemented
+	activate(options: Record<string, any>): void {}
+
+	changeGoal(goal: string): void {}
+}

src/Wolfie2D/DataTypes/Graphs/Graph.ts

@@ -125,7 +125,7 @@ export default class Graph {
 		for(let i = 0; i < this.numVertices; i++){
 			let edge = this.edges[i];
 			let edgeStr = "";
-			while(edge !== null){
+			while(edge !== undefined && edge !== null){
 				edgeStr += edge.y.toString();
 				if(this.weighted){
 					edgeStr += " (" + edge.weight + ")";

src/Wolfie2D/DataTypes/Interfaces/Actor.ts

@@ -1,12 +1,13 @@
 import NavigationPath from "../../Pathfinding/NavigationPath";
 import AI from "./AI";
+import GoapAI from "./GoapAI";
 
 /**
  * A game object that has an AI and can perform its own actions every update cycle
  */
 export default interface Actor {
     /** The AI of the actor */
-    ai: AI;
+    ai: AI | GoapAI;
 
     /** The activity status of the actor */
     aiActive: boolean;
@@ -21,8 +22,9 @@ export default interface Actor {
      * Adds an AI to this Actor.
      * @param ai The name of the AI, or the actual AI, to add to the Actor.
      * @param options The options to give to the AI for initialization.
+     * @param type The type of the AI, 0 for AI, 1 for GoapAI, defaults to assume AI
      */
-    addAI<T extends AI>(ai: string | (new () => T), options: Record<string, any>): void;
+    addAI<T extends AI>(ai: string | (new () => T), options: Record<string, any>, type?: number): void;
 
     /**
      * Sets the AI to start/stop for this Actor.

src/Wolfie2D/DataTypes/Interfaces/GoapAI.ts

@@ -0,0 +1,42 @@
+import GoapActionPlanner from "../../AI/GoapActionPlanner";
+import GameEvent from "../../Events/GameEvent";
+import GameNode from "../../Nodes/GameNode";
+import Queue from "../Queue";
+import Stack from "../Stack";
+import GoapAction from "./GoapAction";
+import Updateable from "./Updateable";
+
+/**
+ * Defines a controller for a bot or a human. Must be able to update
+ */
+export default interface GoapAI extends Updateable {
+    /** Current goal of the AI */
+    goal: string;
+
+    /** All current statuses this AI has */
+    currentStatus: Array<string>;
+
+    /** All possible actions that can be carried out */
+    possibleActions: Array<GoapAction>;
+
+    /** Current actions to be carried out */
+    plan: Stack<GoapAction>;
+    
+    /** Once we have no actions, the planner can be called to find a new sequence of actions */
+    planner: GoapActionPlanner;
+
+    /** Clears references from to the owner */
+    destroy(): void;
+
+    /** Activates this AI from a stopped state and allows variables to be passed in */
+    activate(options: Record<string, any>): void;
+
+    /** Handles events from the Actor */
+    handleEvent(event: GameEvent): void;
+
+    /** Initializes the AI with the actor and any additional config */
+    initializeAI(owner:GameNode, options: Record<string, any>): void
+
+    /** Change the goal to a new goal */
+    changeGoal(goal: string): void
+}

src/Wolfie2D/DataTypes/Interfaces/GoapAction.ts

@@ -0,0 +1,61 @@
+import StateMachineGoapAI from "../../AI/StateMachineGoapAI";
+
+export default abstract class GoapAction {
+    /** Cost it takes to complete this action */
+    cost: number;
+
+    /** Preconditions that have to be satisfied for an action to happen */
+    preconditions: Array<string>;
+
+    /** Resulting statuses after this action completes */
+    effects: Array<string>;
+
+    /** If the action fails, do we keep trying until we succeed */
+    loopAction: boolean;
+
+    /**
+     * Attempt to perform an action, if successful, it will return an array of the expected effects, otherwise it will return null
+     * @param statuses Current statuses of the actor
+     * @param actor GameNode for the actor
+     * @param deltaT The time sine the last update
+     * @param target GameNode for a optional target
+     */
+    abstract performAction(statuses: Array<string>, actor: StateMachineGoapAI, deltaT: number, target?: StateMachineGoapAI): Array<string>;
+
+    /** Check preconditions with current statuses to see if action can be performed */
+    checkPreconditions(statuses: Array<string>): boolean {
+        // Check that every element in the preconditions array is found in the statuses array
+        return (this.preconditions.every((status) => {
+            if (!statuses.includes(status)){
+                return false;
+            }
+            return true;
+        }));
+    }
+
+    /** Add one or more preconditions to this action */
+    addPrecondition(preconditions: string | string[]): void {
+        this.preconditions.push(...preconditions);
+    }
+
+    /** Add one or more effects to this action */
+    addEffect(effects: string | string[]): void {
+        this.effects.push(...effects);
+    }
+
+    /** Removes an precondition, returns true if successful */
+    removePrecondition(precondition: string): boolean {
+        throw new Error("Method not implemented.");
+    }
+    
+    /** Removes an precondition, returns true if successful */
+    removeEffect(effect: string): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    /** Update the cost of this action based on options */
+    abstract updateCost(options: Record<string,number>): void;
+
+    abstract toString(): string;
+
+}

src/Wolfie2D/DataTypes/Interfaces/Navigable.ts

@@ -7,6 +7,7 @@ export default interface Navigable {
      * Gets a new navigation path based on this Navigable object.
      * @param fromPosition The position to start navigation from.
      * @param toPosition The position to navigate to.
+     * @param direct If true, move directly from fromPosition to toPosition
      */
-    getNavigationPath(fromPosition: Vec2, toPosition: Vec2): NavigationPath;
+    getNavigationPath(fromPosition: Vec2, toPosition: Vec2, direct?: boolean): NavigationPath;
 }

src/Wolfie2D/Events/BattleSystem.ts

@@ -0,0 +1,38 @@
+import Updateable from "../DataTypes/Interfaces/Updateable";
+import EventQueue from "./EventQueue";
+import Receiver from "./Receiver";
+
+export default abstract class BattleSystem implements Updateable {
+
+    units: Map<number,Record<string, number>>;
+    receiver: Receiver;
+    eventQueue: EventQueue;
+    statSystem: Array<string>;
+
+    constructor(battleEvents: Array<string>, statSystem: Array<string>){
+        this.eventQueue = EventQueue.getInstance();
+        this.eventQueue.subscribe(this.receiver, battleEvents);
+        this.statSystem = statSystem;
+    }
+
+    getUnitStats(id: number): Record<string,number> {
+        return this.units.get(id);
+    }
+    
+    validateStats(stats: Record<string,number>): Record<string,number> {
+        this.statSystem.forEach(e => {
+            if (stats[e] === undefined){
+                stats[e] = 0;
+            }
+        });
+        return stats;
+    }
+
+    initalizeUnit(id: number, stats: Record<string, number>): void{
+        this.units.set(id, this.validateStats(stats));
+    }
+
+    abstract update(deltaT: number): void;
+
+
+}

src/Wolfie2D/Input/Input.ts

@@ -12,6 +12,7 @@ import { GameEventType } from "../Events/GameEventType";
 export default class Input {
 	private static mousePressed: boolean;
 	private static mouseJustPressed: boolean;
+	private static mouseButtonPressed: number;
 
 	private static keyJustPressed: Map<boolean>;
 	private static keyPressed: Map<boolean>;
@@ -35,7 +36,7 @@ export default class Input {
 	 * Initializes the Input object
 	 * @param viewport A reference to the viewport of the game
 	 */
-	static initialize(viewport: Viewport, keyMap: Array<Record<string, any>>){
+	static initialize(viewport: Viewport, keyMap: Array<Record<string, any>>) {
 		Input.viewport = viewport;
 		Input.mousePressed = false;
 		Input.mouseJustPressed = false;
@@ -53,7 +54,7 @@ export default class Input {
 		Input.keyMap = new Map();
 
 		// Add all keys to the keymap
-		for(let entry in keyMap){
+		for (let entry in keyMap) {
 			let name = keyMap[entry].name;
 			let keys = keyMap[entry].keys;
 			Input.keyMap.add(name, keys);
@@ -62,7 +63,7 @@ export default class Input {
 		Input.eventQueue = EventQueue.getInstance();
 		// Subscribe to all input events
 		Input.eventQueue.subscribe(Input.receiver, [GameEventType.MOUSE_DOWN, GameEventType.MOUSE_UP, GameEventType.MOUSE_MOVE,
-			 GameEventType.KEY_DOWN, GameEventType.KEY_UP, GameEventType.CANVAS_BLUR, GameEventType.WHEEL_UP, GameEventType.WHEEL_DOWN]);
+		GameEventType.KEY_DOWN, GameEventType.KEY_UP, GameEventType.CANVAS_BLUR, GameEventType.WHEEL_UP, GameEventType.WHEEL_DOWN]);
 	}
 
 	static update(deltaT: number): void {
@@ -72,53 +73,54 @@ export default class Input {
 		Input.justScrolled = false;
 		Input.scrollDirection = 0;
 
-		while(Input.receiver.hasNextEvent()){			
+		while (Input.receiver.hasNextEvent()) {
 			let event = Input.receiver.getNextEvent();
 
 			// Handle each event type
-			if(event.type === GameEventType.MOUSE_DOWN){
+			if (event.type === GameEventType.MOUSE_DOWN) {
 				Input.mouseJustPressed = true;
 				Input.mousePressed = true;
 				Input.mousePressPosition = event.data.get("position");
+				Input.mouseButtonPressed = event.data.get("button");
 			}
 
-			if(event.type === GameEventType.MOUSE_UP){
+			if (event.type === GameEventType.MOUSE_UP) {
 				Input.mousePressed = false;
 			}
 
-			if(event.type === GameEventType.MOUSE_MOVE){
+			if (event.type === GameEventType.MOUSE_MOVE) {
 				Input.mousePosition = event.data.get("position");
 			}
 
-			if(event.type === GameEventType.KEY_DOWN){
+			if (event.type === GameEventType.KEY_DOWN) {
 				let key = event.data.get("key");
 				// Handle space bar
-				if(key === " "){
+				if (key === " ") {
 					key = "space";
 				}
-				if(!Input.keyPressed.get(key)){
+				if (!Input.keyPressed.get(key)) {
 					Input.keyJustPressed.set(key, true);
 					Input.keyPressed.set(key, true);
 				}
 			}
 
-			if(event.type === GameEventType.KEY_UP){
+			if (event.type === GameEventType.KEY_UP) {
 				let key = event.data.get("key");
 				// Handle space bar
-				if(key === " "){
+				if (key === " ") {
 					key = "space";
 				}
 				Input.keyPressed.set(key, false);
 			}
 
-			if(event.type === GameEventType.CANVAS_BLUR){
+			if (event.type === GameEventType.CANVAS_BLUR) {
 				Input.clearKeyPresses()
 			}
 
-			if(event.type === GameEventType.WHEEL_UP){
+			if (event.type === GameEventType.WHEEL_UP) {
 				Input.scrollDirection = -1;
 				Input.justScrolled = true;
-			} else if(event.type === GameEventType.WHEEL_DOWN){
+			} else if (event.type === GameEventType.WHEEL_DOWN) {
 				Input.scrollDirection = 1;
 				Input.justScrolled = true;
 			}
@@ -137,9 +139,9 @@ export default class Input {
 	 * @returns True if the key was just pressed, false otherwise
 	 */
 	static isKeyJustPressed(key: string): boolean {
-		if(Input.keysDisabled) return false;
+		if (Input.keysDisabled) return false;
 
-		if(Input.keyJustPressed.has(key)){
+		if (Input.keyJustPressed.has(key)) {
 			return Input.keyJustPressed.get(key)
 		} else {
 			return false;
@@ -152,11 +154,11 @@ export default class Input {
 	 * @returns An array of all of the newly pressed keys.
 	 */
 	static getKeysJustPressed(): Array<string> {
-		if(Input.keysDisabled) return [];
+		if (Input.keysDisabled) return [];
 
 		let keys = Array<string>();
 		Input.keyJustPressed.forEach(key => {
-			if(Input.keyJustPressed.get(key)){
+			if (Input.keyJustPressed.get(key)) {
 				keys.push(key);
 			}
 		});
@@ -169,9 +171,9 @@ export default class Input {
 	 * @returns True if the key is currently pressed, false otherwise
 	 */
 	static isKeyPressed(key: string): boolean {
-		if(Input.keysDisabled) return false;
+		if (Input.keysDisabled) return false;
 
-		if(Input.keyPressed.has(key)){
+		if (Input.keyPressed.has(key)) {
 			return Input.keyPressed.get(key)
 		} else {
 			return false;
@@ -200,13 +202,13 @@ export default class Input {
 	 * @returns True if the input was just pressed, false otherwise
 	 */
 	static isJustPressed(inputName: string): boolean {
-		if(Input.keysDisabled) return false;
+		if (Input.keysDisabled) return false;
 
-		if(Input.keyMap.has(inputName)){
+		if (Input.keyMap.has(inputName)) {
 			const keys = Input.keyMap.get(inputName);
 			let justPressed = false;
 
-			for(let key of keys){
+			for (let key of keys) {
 				justPressed = justPressed || Input.isKeyJustPressed(key);
 			}
 
@@ -222,13 +224,13 @@ export default class Input {
 	 * @returns True if the input is pressed, false otherwise
 	 */
 	static isPressed(inputName: string): boolean {
-		if(Input.keysDisabled) return false;
+		if (Input.keysDisabled) return false;
 
-		if(Input.keyMap.has(inputName)){
+		if (Input.keyMap.has(inputName)) {
 			const keys = Input.keyMap.get(inputName);
 			let pressed = false;
 
-			for(let key of keys){
+			for (let key of keys) {
 				pressed = pressed || Input.isKeyPressed(key);
 			}
 
@@ -237,20 +239,30 @@ export default class Input {
 			return false;
 		}
 	}
-
 	/**
-	 * Returns whether or not the mouse was newly pressed Input frame
+	 * 
+	 * Returns whether or not the mouse was newly pressed Input frame.
+	 * @param mouseButton Optionally specify which mouse click you want to know was pressed. 
+	 * 0 for left click, 1 for middle click, 2 for right click.
 	 * @returns True if the mouse was just pressed, false otherwise
 	 */
-	static isMouseJustPressed(): boolean {
+	static isMouseJustPressed(mouseButton?: number): boolean {
+		if (mouseButton) {
+			return Input.mouseJustPressed && !Input.mouseDisabled && mouseButton == this.mouseButtonPressed;
+		}
 		return Input.mouseJustPressed && !Input.mouseDisabled;
 	}
 
 	/**
 	 * Returns whether or not the mouse is currently pressed
+	 * @param mouseButton Optionally specify which mouse click you want to know was pressed. 
+	 * 0 for left click, 1 for middle click, 2 for right click.
 	 * @returns True if the mouse is currently pressed, false otherwise
 	 */
-	static isMousePressed(): boolean {
+	static isMousePressed(mouseButton?: number): boolean {
+		if (mouseButton) {
+			return Input.mousePressed && !Input.mouseDisabled && mouseButton == this.mouseButtonPressed;
+		}
 		return Input.mousePressed && !Input.mouseDisabled;
 	}
 
@@ -275,7 +287,7 @@ export default class Input {
 	 * @returns The mouse position stored as a Vec2
 	 */
 	static getMousePosition(): Vec2 {
-		return Input.mousePosition.scaled(1/this.viewport.getZoomLevel());
+		return Input.mousePosition.scaled(1 / this.viewport.getZoomLevel());
 	}
 
 	/**
@@ -284,7 +296,7 @@ export default class Input {
 	 * @returns The mouse position stored as a Vec2
 	 */
 	static getGlobalMousePosition(): Vec2 {
-		return Input.mousePosition.clone().scale(1/this.viewport.getZoomLevel()).add(Input.viewport.getOrigin());
+		return Input.mousePosition.clone().scale(1 / this.viewport.getZoomLevel()).add(Input.viewport.getOrigin());
 	}
 
 	/**

src/Wolfie2D/Input/InputHandler.ts

@@ -29,7 +29,8 @@ export default class InputHandler {
 
     private handleMouseDown = (event: MouseEvent, canvas: HTMLCanvasElement): void => {
 		let pos = this.getMousePosition(event, canvas);
-        let gameEvent = new GameEvent(GameEventType.MOUSE_DOWN, {position: pos});
+        let button = event.button;
+        let gameEvent = new GameEvent(GameEventType.MOUSE_DOWN, {position: pos, button: button});
         this.eventQueue.addEvent(gameEvent);
     }
 

src/Wolfie2D/Nodes/GameNode.ts

@@ -18,6 +18,7 @@ import TweenController from "../Rendering/Animations/TweenController";
 import Debug from "../Debug/Debug";
 import Color from "../Utils/Color";
 import Circle from "../DataTypes/Shapes/Circle";
+import GoapAI from "../DataTypes/Interfaces/GoapAI";
 
 /**
  * The representation of an object in the game world.
@@ -54,7 +55,7 @@ export default abstract class GameNode implements Positioned, Unique, Updateable
 	isColliding: boolean = false;
 
 	/*---------- ACTOR ----------*/
-	_ai: AI;
+	_ai: AI | GoapAI;
 	aiActive: boolean;
 	path: NavigationPath;
 	pathfinding: boolean = false;
@@ -331,11 +332,11 @@ export default abstract class GameNode implements Positioned, Unique, Updateable
 	}
 
 	/*---------- ACTOR ----------*/
-	get ai(): AI {
+	get ai(): AI | GoapAI {
 		return this._ai;
 	}
 
-	set ai(ai: AI) {
+	set ai(ai: AI | GoapAI) {
 		if(!this._ai){
 			// If we haven't been previously had an ai, register us with the ai manager
 			this.scene.getAIManager().registerActor(this);
@@ -346,7 +347,7 @@ export default abstract class GameNode implements Positioned, Unique, Updateable
 	}
 
 	// @implemented
-	addAI<T extends AI>(ai: string | (new () => T), options?: Record<string, any>): void {
+	addAI<T extends AI | GoapAI>(ai: string | (new () => T), options?: Record<string, any>, type?: number): void {
 		if(!this._ai){
 			this.scene.getAIManager().registerActor(this);
 		}
@@ -357,6 +358,7 @@ export default abstract class GameNode implements Positioned, Unique, Updateable
 			this._ai = new ai();
 		}
 
+		// Question, how much do we want different type of AI to be handled the same, i.e. should GoapAI and AI similar methods and signatures for the sake of unity
 		this._ai.initializeAI(this, options);
 
 		this.aiActive = true;

src/Wolfie2D/Nodes/Graphic.ts

@@ -29,4 +29,28 @@ export default abstract class Graphic extends CanvasNode {
     setColor(color: Color){
         this.color = color;
     }
+
+    set colorR(r: number){
+        this.color.r = r;
+    }
+
+    get colorR(): number {
+        return this.color.r;
+    }
+
+    set colorG(g: number){
+        this.color.g = g;
+    }
+
+    get colorG(): number {
+        return this.color.g;
+    }
+
+    set colorB(b: number){
+        this.color.b = b;
+    }
+
+    get colorB(): number {
+        return this.color.b;
+    }
 }

src/Wolfie2D/Nodes/Graphics/GraphicTypes.ts

@@ -2,4 +2,5 @@ export enum GraphicType {
 	POINT = "POINT",
 	RECT = "RECT",
 	LINE = "LINE",
+	PARTICLE = "PARTICLE"
 }

src/Wolfie2D/Nodes/Graphics/Particle.ts

@@ -0,0 +1,57 @@
+import Vec2 from "../../DataTypes/Vec2";
+import Point from "./Point";
+
+/**
+ * - Position X
+- Velocity (speed and direction) X
+- Color X
+- Lifetime 
+- Age can be handled as lifetime
+- Shape X
+- Size X
+- Transparency X
+ */
+
+
+export default class Particle extends Point {
+    age: number;
+
+    inUse: boolean;
+
+    vel: Vec2;
+
+    mass: number;
+
+    constructor(position: Vec2, size: Vec2, mass: number) {
+        // Are we making this a circle?
+        super(position, size);
+        this.inUse = false;
+        this.mass = mass;
+    }
+
+    setParticleActive(lifetime: number, position: Vec2) {
+        this.age = lifetime;
+        this.inUse = true;
+        this.visible = true;
+        this.position = position;
+    }
+
+    decrementAge(decay: number) {
+        this.age -= decay;
+    }
+
+    setParticleInactive(){
+        this.inUse = false;
+        this.visible = false;
+    }
+
+    set velY(y: number){
+        this.vel.y = y;
+    }
+
+    get velY(): number {
+        return this.vel.y;
+    }
+
+
+}

src/Wolfie2D/Nodes/Graphics/Point.ts

@@ -4,9 +4,10 @@ import Vec2 from "../../DataTypes/Vec2";
 /** A basic point to be drawn on the screen. */
 export default class Point extends Graphic {
 
-    constructor(position: Vec2){
+    constructor(position: Vec2, size: Vec2) {
+        // Are we making this a circle?
         super();
         this.position = position;
-        this.size.set(5, 5);
+        this.size.set(size.x, size.y);
     }
 }

src/Wolfie2D/Pathfinding/NavigationManager.ts

@@ -30,10 +30,11 @@ export default class NavigationManager {
 	 * @param navName The name of the registered Navigable object
 	 * @param fromPosition The starting position of navigation
 	 * @param toPosition The ending position of Navigation
+	 * @param direct If true, go direct from fromPosition to toPosition, don't use NavMesh
 	 * @returns A NavigationPath containing the route to take over the Navigable entity to get between the provided positions.
 	 */
-	getPath(navName: string, fromPosition: Vec2, toPosition: Vec2): NavigationPath {
+	getPath(navName: string, fromPosition: Vec2, toPosition: Vec2, direct?: boolean): NavigationPath {
 		let nav = this.navigableEntities.get(navName);
-		return nav.getNavigationPath(fromPosition.clone(), toPosition.clone());
+		return nav.getNavigationPath(fromPosition.clone(), toPosition.clone(), direct);
 	}
 }

src/Wolfie2D/Pathfinding/Navmesh.ts

@@ -21,18 +21,23 @@ export default class Navmesh implements Navigable {
 	}
 
 	// @implemented
-	getNavigationPath(fromPosition: Vec2, toPosition: Vec2): NavigationPath {
+	getNavigationPath(fromPosition: Vec2, toPosition: Vec2, direct: boolean): NavigationPath {
 		let start = this.getClosestNode(fromPosition);
 		let end = this.getClosestNode(toPosition);
 
-		let parent = GraphUtils.djikstra(this.graph, start);
-
 		let pathStack = new Stack<Vec2>(this.graph.numVertices);
 		
 		// Push the final position and the final position in the graph
 		pathStack.push(toPosition.clone());
+
+		if (direct) {
+			return new NavigationPath(pathStack);
+		}
+
 		pathStack.push(this.graph.positions[end]);
 
+		let parent = GraphUtils.djikstra(this.graph, start);
+
 		// Add all parents along the path
 		let i = end;
 		while(parent[i] !== -1){

src/Wolfie2D/Rendering/Animations/ParticleSystem.ts

@@ -0,0 +1,163 @@
+import Updateable from "../../DataTypes/Interfaces/Updateable";
+import Vec2 from "../../DataTypes/Vec2";
+import { GraphicType } from "../../Nodes/Graphics/GraphicTypes";
+import Particle from "../../Nodes/Graphics/Particle";
+import Scene from "../../Scene/Scene";
+import Timer from "../../Timing/Timer";
+import Color from "../../Utils/Color";
+import { EaseFunctionType } from "../../Utils/EaseFunctions";
+import RandUtils from "../../Utils/RandUtils";
+import ParticleSystemManager from "./ParticleSystemManager";
+
+/*
+-Move particle system to HW#4, particle class and particle manager(object pool), source, randomized period of decay,
+ semi-randomized approach for spawning, should be general purpose 
+ and load some settings from a json (location, states, colors, randomization). 
+ Should be effect when balloon is popped 
+*/
+
+export default class ParticleSystem implements Updateable {
+    protected particlePool: Array<Particle>;
+
+    protected lifetime: number;
+
+    protected liveParticles: number;
+
+    protected maxLiveParticles: number;
+
+    protected sourcePoint: Vec2;
+
+    protected particleSize: Vec2;
+
+    protected systemLifetime: Timer;
+
+    protected systemRunning: boolean;
+
+    protected color: Color = new Color(255, 0, 0);
+
+    constructor(poolSize: number, sourcePoint: Vec2, lifetime: number, size: number, maxParticles: number) {
+        this.particlePool = new Array(poolSize);
+        this.sourcePoint = sourcePoint;
+        this.lifetime = lifetime;
+        this.particleSize = new Vec2(size, size);
+        this.maxLiveParticles = maxParticles;
+        this.systemRunning = false;
+
+        ParticleSystemManager.getInstance().registerParticleSystem(this);
+    }
+
+    initalizePool(scene: Scene, layer: string, type: ParticleSystemType, mass: number) {
+        for (let i = 0; i < this.particlePool.length; i++) {
+            this.particlePool[i] = <Particle>scene.add.graphic(GraphicType.PARTICLE, layer,
+                { position: this.sourcePoint.clone(), size: this.particleSize.clone(), mass: mass });
+            this.particlePool[i].addPhysics();
+            this.particlePool[i].isCollidable = false;
+            this.particlePool[i].visible = false;
+        }
+    }
+
+    startSystem(time: number, startPoint?: Vec2) {
+        this.systemLifetime = new Timer(time);
+        this.systemLifetime.start();
+        this.systemRunning = true;
+        this.sourcePoint = startPoint;
+    }
+
+    stopSystem() {
+        console.log(this);
+        this.systemRunning = false;
+        for (let particle of this.particlePool) {
+            if (particle.inUse) {
+                particle.setParticleInactive();
+            }
+        }
+    }
+
+    changeColor(color: Color) {
+        this.color = color;
+    }
+
+    update(deltaT: number) {
+        if (!this.systemRunning) {
+            return;
+        }
+        if (this.systemLifetime.isStopped()) {
+            this.stopSystem();
+        }
+        else {
+            for (let particle of this.particlePool) {
+                if (particle.inUse) {
+                    particle.decrementAge(deltaT * 1000);
+
+                    if (particle.age <= 0) {
+                        particle.setParticleInactive();
+                    }
+
+                    //particle.vel.y += 200*deltaT;
+                    particle.move(particle.vel.scaled(deltaT));
+                }
+                else {
+                    particle.setParticleActive(this.lifetime, this.sourcePoint.clone());
+
+                    particle.color = this.color;
+                    particle.alpha = 1;
+                    //particle.size.set(1)
+                    particle.vel = RandUtils.randVec(-50, 50, -100, 100);
+
+                    particle.tweens.add("active", {
+                        startDelay: 0,
+                        duration: 2000,
+                        effects: [
+                            {
+                                property: "alpha",
+                                resetOnComplete: true,
+                                start: 1,
+                                end: 0,
+                                ease: EaseFunctionType.IN_OUT_SINE
+                            },
+                            /*{
+                                property: "colorR",
+                                resetOnComplete: true,
+                                start: particle.color.r,
+                                end: 255,
+                                ease: EaseFunctionType.IN_OUT_SINE
+                            },
+                            {
+                                property: "colorG",
+                                resetOnComplete: true,
+                                start: particle.color.g,
+                                end: 255,
+                                ease: EaseFunctionType.IN_OUT_SINE
+                            },
+                            {
+                                property: "colorB",
+                                resetOnComplete: true,
+                                start: particle.color.b,
+                                end: 255,
+                                ease: EaseFunctionType.IN_OUT_SINE
+                            },*/
+                            {
+                                property: "velY",
+                                resetOnComplete: true,
+                                start: particle.vel.y,
+                                end: particle.vel.y + ((this.lifetime * particle.mass)/2),
+                                ease: EaseFunctionType.IN_OUT_SINE
+                            }
+                        ]
+                    });
+
+                    particle.tweens.play("active");
+
+                    //particle.vel = RandUtils.randVec(-150, 150, -100, 100);
+                    //console.log(particle.vel.toString());
+                }
+            }
+        }
+    }
+
+}
+
+export enum ParticleSystemType {
+    emitter = "emitter",
+    burst = "burst"
+}

src/Wolfie2D/Rendering/Animations/ParticleSystemManager.ts

@@ -0,0 +1,40 @@
+import Updateable from "../../DataTypes/Interfaces/Updateable";
+import ParticleSystem from "./ParticleSystem";
+
+export default class ParticleSystemManager implements Updateable {
+
+    private static instance: ParticleSystemManager = null;
+    
+    protected particleSystems: Array<ParticleSystem>;
+
+    private constructor(){
+        this.particleSystems = new Array();
+    }
+
+    static getInstance(): ParticleSystemManager {
+        if(ParticleSystemManager.instance === null){
+            ParticleSystemManager.instance = new ParticleSystemManager();
+        }
+
+        return ParticleSystemManager.instance;
+    }
+
+    registerParticleSystem(system: ParticleSystem){
+        this.particleSystems.push(system);
+    }
+
+    deregisterParticleSystem(system: ParticleSystem){
+        let index = this.particleSystems.indexOf(system);
+        this.particleSystems.splice(index, 1);
+    }
+
+    clearParticleSystems(){
+        this.particleSystems = new Array();
+    }
+
+    update(deltaT: number): void {
+        for(let particleSystem of this.particleSystems){
+            particleSystem.update(deltaT);
+        }
+    }
+}

src/Wolfie2D/Scene/Factories/CanvasNodeFactory.ts

@@ -14,6 +14,7 @@ import TextInput from "../../Nodes/UIElements/TextInput";
 import Rect from "../../Nodes/Graphics/Rect";
 import ResourceManager from "../../ResourceManager/ResourceManager";
 import Line from "../../Nodes/Graphics/Line";
+import Particle from "../../Nodes/Graphics/Particle";
 
 // @ignorePage
 
@@ -143,6 +144,9 @@ export default class CanvasNodeFactory {
 			case GraphicType.RECT:
 				instance = this.buildRect(options);
 				break;
+			case GraphicType.PARTICLE:
+				instance = this.buildParticle(options);
+				break;				
 			default:
 				throw `GraphicType '${type}' does not exist, or is registered incorrectly.`
 		}
@@ -196,8 +200,18 @@ export default class CanvasNodeFactory {
 
 	buildPoint(options?: Record<string, any>): Point {
 		this.checkIfPropExists("Point", options, "position", Vec2, "Vec2");
+		this.checkIfPropExists("Point", options, "size", Vec2, "Vec2");
 
-		return new Point(options.position);
+		return new Point(options.position, options.size);
+	}
+
+	buildParticle(options?: Record<string, any>): Point {
+		this.checkIfPropExists("Particle", options, "position", Vec2, "Vec2");
+		this.checkIfPropExists("Particle", options, "size", Vec2, "Vec2");
+		this.checkIfPropExists("Particle", options, "mass", "number", "number");
+
+		//Changed for testing
+		return new Particle(options.position, options.size, options.mass);
 	}
 
 	buildLine(options?: Record<string, any>): Point {

src/Wolfie2D/Scene/Scene.ts

@@ -25,6 +25,7 @@ import RenderingManager from "../Rendering/RenderingManager";
 import Debug from "../Debug/Debug";
 import TimerManager from "../Timing/TimerManager";
 import TweenManager from "../Rendering/Animations/TweenManager";
+import ParticleSystemManager from "../Rendering/Animations/ParticleSystemManager";
 
 /**
  * Scenes are the main container in the game engine.
@@ -173,6 +174,9 @@ export default class Scene implements Updateable {
         // Update all tweens
         TweenManager.getInstance().update(deltaT);
 
+        // Update all particle systems
+        ParticleSystemManager.getInstance().update(deltaT);
+
         // Update viewport
         this.viewport.update(deltaT);
     }

src/main.ts

@@ -1,3 +1,4 @@
+
 import Game from "./Wolfie2D/Loop/Game";
 import default_scene from "./default_scene";