Engine

Create a namespace to store all the physics engine core functionality

Engine

Type: ({} | {})

Static Members

▸ Core

Component to store objects and main game loop

Core

Type: {}

▸ Physics

Component to store collision detection and resolving

Physics

Type: {}

▸ Level

Component to store game objects and game data

Level

Type: {}

Static Members

▸ Fuel

Component to store fuel objects

Fuel

Type: {Array: Array<any>, Index: number}

▸ Player

Component to store a reference to a player ship

Player

Type: PlayerShip

▸ EndGame

Component to store game status

EndGame

Type: boolean

lastRenderTime

Engine Loop

lastRenderTime

collision

Collision detection

collision()

Type: function

resolveCollision

Resolve collision using the Impulse Method

resolveCollision(s1: any, s2: any, collisionInfo: CollisionInfo)

Parameters

s1 (any) one of the colliding objects

s2 (any) one od the colliding objects

collisionInfo (CollisionInfo) collision info calculated while collision detection

p

Collision position

p

Type: Vector

tangent

Tangent to a collision normal

tangent

Type: Vector

positionalCorrection

Reduces overlaps between objects by the predefined constant correctionRate

positionalCorrection(s1: any, s2: any, collisionInfo: CollisionInfo)

Parameters

s1 (any)

s2 (any)

collisionInfo (CollisionInfo)

correctionAmount

correctionAmount

Type: Vector

drag

Add drag to objects if they are in a drag area

drag()

j

Change Rigid Shape velocity due to drag

j

screen

Component to store canvas data

screen

Type: {mHeight: any, mWidth: any, mCanvas: HTMLElement, mContext: any}

x

Canvas boundaries

x

Bullet

Class that represents a bullet

new Bullet()

Instance Members

▸ acceleration

bullet acceleration

acceleration

Type: Vector

BulletSource

A class that represents a bullet source

new BulletSource()

Instance Members

▸ shoot()

spawn a new bullet

shoot()

▸ takeDamage()

change damage status

takeDamage()

FuelTank

A class that represent a fuel tank

new FuelTank()

Instance Members

▸ pickUp()

Method to check if player can pick up the tank

pickUp(): boolean

Returns

boolean:

drawLevelSky

Function to draw canvas background

drawLevelSky()

setBunkers

Create bunkers object on level

setBunkers()

setFuel

Create fuel object on level

setFuel()

setDrag

Create drag areas object on level

setDrag()

setScene

Set level initial scene

setScene()

setTerrain

Set terrain on level

setTerrain()

Terrain

Terrain object, stores all terrain elements

new Terrain()

playButton

Button to start game

playButton

Type: {x: number, width: number, y: number, height: number}

drawButton

Draw a button to start game

drawButton()

clickBtn

Check if user clicked a button

clickBtn(e: any)

Parameters

e (any) click event

setUp

Set event listener and draw a button

setUp()

getMousePos

Get user's mouse coordinates

getMousePos(event: any): {x: number, y: number}

Parameters

event (any) mouse event

Returns

{x: number, y: number}: mouse coordinates

isInside

Check if mouse is inside a button

isInside(pos: any, button: any): boolean

Parameters

pos (any) mouse position

button (any) button

Returns

boolean:

startGame

Start game, clear previous data

startGame()

PlayerShip

Class that represents player ship

new PlayerShip()

Instance Members

▸ shoot()

Method to shoot player bullets

shoot()

▸ loseLife()

Method to decrease count of player's lives

loseLife()

ui

Object to store game stats

ui

Type: {score: number, lives: number, fuel: number}

displayUI

Function to display stats on canvas

displayUI()

updateUI

Function to update stats in each loop run

updateUI(score: any, lives: any, fuel: any)

Parameters

score (any) player score

lives (any) player lives left

fuel (any) player fuel

handleKeyInput

Handle keyboard inputs

handleKeyInput(event: any): boolean

Parameters

event (any) keyboard event

Returns

boolean:

CollisionInfo

Class that represents collision info

new CollisionInfo()

Instance Members

▸ setInfo(d, n, s)

Set collision info

setInfo(d: number, n: Vector, s: Vector)

Parameters

d (number) collision depth

n (Vector) collision normal

s (Vector) collision vector start

▸ changeDirection()

Change direction of the normal so that it points in the opposite direction

changeDirection()

▸ display()

Display collision vector

display()

DragArea

Class that represents a drag area

new DragArea()

Instance Members

▸ update()

animate waves

update()

▸ drawWater()

if drag area is water, display as water

drawWater()

SineWave

Class that represents a sine wave used in DragArea animation

new SineWave()

sleep

Function to execute code after a given time

sleep(ms: any): Promise<unknown>

Parameters

ms (any) waiting time

Returns

Promise<unknown>:

Vector

A class that represents a vector using Cartesian coordinates

new Vector()

Instance Members

▸ add(a)

Method to add two vectors

add(a: any): Vector

Parameters

a (any) {Vector} vector added to a vector that called the method

Returns

Vector: a product of vector addition

▸ subtract(a)

Method to subtract two vectors

subtract(a: any): Vector

Parameters

a (any) vector subtracted from a vector that called the method

Returns

Vector: product of vector subtraction

▸ scale(n)

Method to multiply (scale) a vector by a scalar n

scale(n: any): any

Parameters

n (any) scalar by which the vector is multiplied

Returns

any: product of vector scaling

▸ mag()

Method to calculate the magnitude of a vector

mag(): number

Returns

number: the magnitude of a vector that called it

▸ normalize()

Method to normalize the vector that called it, i.e. multiply the vector by a factor so that its magnitude is equal to 1

normalize(): any

Returns

any: normalized vector

▸ dot(a)

Calculate dot product of two vectors

dot(a: any): number

Parameters

a (any) second vector to calculate the product with

Returns

number: product of the dot product operation

▸ cross(a)

Calculate cross product of two vectors

cross(a: any): number

Parameters

a (any) second vector to calculate the product with

Returns

number: vector in z-axis stored as a number

▸ rotate(angle, center)

Method to rotate a vector

rotate(angle: any, center: Vector): Vector

Parameters

angle (any) rotation angle

center (Vector) rotation center

Returns

Vector: rotated vector

▸ draw(color)

Draw the vector

draw(color: any)

Parameters

color (any) vector color

▸ copy()

Copy the vector

copy(): Vector

Returns

Vector: vector that called the method

constructor

Constructor of Circle class

constructor(mass: number, center: Vector, radius: number, angle: number, friction: number, restitution: number, gravity: boolean, info: string)

Parameters

mass (number) Circle mass

center (Vector) Circle center location

radius (number) Circle radius

angle (number = 0) Circle angle in radians

friction (number = 0) Circle friction

restitution (number = 0) Circle restitution (bounciness) (how much energy is preserved after collision)

gravity (boolean = true) consider Circle when applying gravity

info (string = "") additional info

rotate

Rotate circle

rotate(angle: number)

Parameters

angle (number) rotation angle in radians

displayBounds

Display hit box

displayBounds()

updateInertia

Set and update inertia

updateInertia()

collisionTest

Check if collision occurred, call specified methods to handle collision

collisionTest(otherShape: any, collisionInfo: any): boolean

Parameters

otherShape (any) other shape in the collision event

collisionInfo (any) collision info

Returns

boolean: did the collision occur

collidedCircCirc

Handle collision between circles

collidedCircCirc(c1: any, c2: any, collisionInfo: any): (boolean | CollisionInfo)

Parameters

c1 (any) first circle

c2 (any) second circle

collisionInfo (any) collision info

Returns

(boolean | CollisionInfo):

from1To2

from1To2

Type: Vector

constructor

Constructor of a Rectangle object

constructor(mass: number, center: Vector, width: number, height: number, angle: number, friction: number, restitution: number, gravity: boolean, info: string)

Parameters

mass (number) Mass of a Rectangle object

center (Vector) Mass center of a Rectangle object

width (number) Width of a Rectangle object

height (number) Height of a Rectangle object

angle (number = 0) Angle in radians of a Rectangle object axis to global (canvas) x-axis

friction (number = 0) Rectangle friction

restitution (number = 0) Rectangle restitution (bounciness) (how much energy is preserved after collision)

gravity (boolean = true) consider the Rectangle when applying gravity

info (string = "") additional info

vertex

Array to store vertex positions of the rectangle

vertex

Type: Array<Vector>

faceNormal

Array to store the face normal vectors

faceNormal

Type: Array<Vector>

computeVertex

Compute Rectangle vertices

computeVertex()

computeFaceNormal

Compute face normal vectors

computeFaceNormal()

rotate

Rotate Rectangle

rotate(angle: number)

Parameters

angle (number) Angle in radians

updateInertia

Set and update inertia

updateInertia()

collisionTest

collisionTest(otherShape: any, collisionInfo: any): boolean

Parameters

otherShape (any)

collisionInfo (any)

Returns

boolean:

findSupportPoint

Compute a support point based on dir (find a support point for any face normal)

findSupportPoint(dir: Vector, ptOnEdge: Vector): {supportPoint: Vector, supportPointDist: number}

Parameters

dir (Vector) Negated face normal direction

ptOnEdge (Vector) A position on the given edge (e.g. a vertex)

Returns

{supportPoint: Vector, supportPointDist: number}:

findAxisLeastPenetration

Find the axis of the least penetration based on the support point with the least support point distant

findAxisLeastPenetration(otherRect: Rectangle, collisionInfo: any): boolean

Parameters

otherRect (Rectangle) other Rectangle with which collision occurs

collisionInfo (any) collision info

Returns

boolean: hasSupport

collidedRectRect

Compute the axis of lest penetration and choose smaller of the two results

collidedRectRect(r1: Rectangle, r2: Rectangle, collisionInfo: CollisionInfo): boolean

Parameters

r1 (Rectangle) Rectangle that called the method

r2 (Rectangle) Rectangle with which collision occurs

collisionInfo (CollisionInfo) collision info

Returns

boolean:

collidedRectCirc

Detect collision according to the relative position of the circle's center with respect to the rectangle

collidedRectCirc(otherCir: Circle, collisionInfo: CollisionInfo)

Parameters

otherCir (Circle) collided Circle

collisionInfo (CollisionInfo) collision info

supportPoint

supportPoint

Type: Vector

supportPoint

supportPoint

Type: Vector

collisionInfoR1

collisionInfoR1

Type: CollisionInfo

collisionInfoR1

collisionInfoR1

Type: CollisionInfo

collisionInfoR2

collisionInfoR2

Type: CollisionInfo

collisionInfoR2

collisionInfoR2

Type: CollisionInfo

radiusVec

radiusVec

Type: Vector

RigidShape

Abstract class that represents a rigid body

new RigidShape()

Instance Members

▸ angularVelocity

Angular velocity is stored as a scalar representing the z-component magnitude of the vector

angularVelocity

Type: number

▸ update()

Update RigidBody object with its velocity, move and rotate accordingly

update()

▸ move(s)

Displace the object by the given vector

move(s: Vector)

Parameters

s (Vector) object displacement

▸ updateMass(delta)

Support changing of the mass during runtime

updateMass(delta: any)

Parameters

delta (any) mass change

▸ collisionTest(otherShape, collisionInfo)

Detect collision

collisionTest(otherShape: (Circle | Rectangle | Triangle), collisionInfo: CollisionInfo)

Parameters

otherShape ((Circle | Rectangle | Triangle)) collided Circle

collisionInfo (CollisionInfo) collision info

▸ boundTest(otherShape)

Function that implements Broad Phase Method to detect collision detection

boundTest(otherShape: any): boolean

Parameters

otherShape (any) Other object that an object might collide with

Returns

boolean: Returns true when objects are colliding and false when they are not

isGravity

Symplectic Euler Integration

isGravity

constructor

Constructor of a Triangle object

constructor(mass: number, center: Vector, width: number, height: number, angle: number, friction: number, restitution: number, gravity: boolean, info: string)

Parameters

mass (number) Mass of a Triangle object

center (Vector) Mass center of a Triangle object

width (number) Width of a Triangle object

height (number) Height of a Triangle object

angle (number = 0) Angle in radians of a Triangle object axis to global (canvas) x-axis

friction (number = 0) Triangle friction

restitution (number = 0) Triangle restitution (bounciness) (how much energy is preserved after collision)

gravity (boolean = true) consider the Triangle when applying gravity

info (string = "") additional info

vertex

Array to store vertex positions of the triangle

vertex

Type: Array<Vector>

faceNormal

Array to store the face normal vectors

faceNormal

Type: Array<Vector>

computeVertex

Compute Rectangle vertices

computeVertex()

computeFaceNormal

Compute face normal vectors

computeFaceNormal()

rotate

Rotate Rectangle

rotate(angle: number)

Parameters

angle (number) Angle in radians

updateInertia

Set and update inertia

updateInertia()

collisionTest

Check if collision occurred, call specified methods to handle collision

collisionTest(otherShape: any, collisionInfo: any): boolean

Parameters

otherShape (any) other shape in the collision event

collisionInfo (any) collision info

Returns

boolean: did the collision occur

findSupportPoint

Compute a support point based on dir (find a support point for any face normal)

findSupportPoint(dir: Vector, ptOnEdge: Vector): {supportPoint: Vector, supportPointDist: number}

Parameters

dir (Vector) Negated face normal direction

ptOnEdge (Vector) A position on the given edge (e.g. a vertex)

Returns

{supportPoint: Vector, supportPointDist: number}:

findAxisLeastPenetration

Find the axis of the least penetration based on the support point with the least support point distance

findAxisLeastPenetration(otherShape: (Rectangle | Triangle), collisionInfo: any): boolean

Parameters

otherShape ((Rectangle | Triangle)) other Rectangle or Triangle with which collision occurs

collisionInfo (any) collision info

Returns

boolean: hasSupport

collidedTrianTrianRect

Compute the axis of lest penetration and choose smaller of the two results

collidedTrianTrianRect(r1: Triangle, r2: (Triangle | Rectangle), collisionInfo: CollisionInfo): boolean

Parameters

r1 (Triangle) Triangle that called the method

r2 ((Triangle | Rectangle)) Triangle or Rectangle with which collision occurs

collisionInfo (CollisionInfo) collision info

Returns

boolean:

collidedTrianCirc

Detect collision according to the relative position of the circle's center with respect to the triangle

collidedTrianCirc(otherCirc: any, collisionInfo: any): boolean

Parameters

otherCirc (any) collided Circle

collisionInfo (any) collision info

Returns

boolean:

normal

normal

Type: Vector