littlejsengine
Version:
LittleJS - Tiny and Fast HTML5 Game Engine
1,168 lines • 111 kB
TypeScript
declare module "littlejsengine" {
/**
* LittleJS - The Tiny Fast JavaScript Game Engine
* MIT License - Copyright 2021 Frank Force
*
* Engine Features
* - Object oriented system with base class engine object
* - Base class object handles update, physics, collision, rendering, etc
* - Engine helper classes and functions like Vector2, Color, and Timer
* - Super fast rendering system for tile sheets
* - Sound effects audio with zzfx and music with zzfxm
* - Input processing system with gamepad and touchscreen support
* - Tile layer rendering and collision system
* - Particle effect system
* - Medal system tracks and displays achievements
* - Debug tools and debug rendering system
* - Post processing effects
* - Call engineInit() to start it up!
* @namespace Engine
*/
/** Name of engine
* @type {string}
* @default
* @memberof Engine */
export const engineName: string;
/** Version of engine
* @type {string}
* @default
* @memberof Engine */
export const engineVersion: string;
/** Frames per second to update
* @type {number}
* @default
* @memberof Engine */
export const frameRate: number;
/** How many seconds each frame lasts, engine uses a fixed time step
* @type {number}
* @default 1/60
* @memberof Engine */
export const timeDelta: number;
/** Array containing all engine objects
* @type {Array<EngineObject>}
* @memberof Engine */
export let engineObjects: Array<EngineObject>;
/** Current update frame, used to calculate time
* @type {number}
* @memberof Engine */
export let frame: number;
/** Current engine time since start in seconds
* @type {number}
* @memberof Engine */
export let time: number;
/** Actual clock time since start in seconds (not affected by pause or frame rate clamping)
* @type {number}
* @memberof Engine */
export let timeReal: number;
/** Is the game paused? Causes time and objects to not be updated
* @type {boolean}
* @default false
* @memberof Engine */
export let paused: boolean;
/** Set if game is paused
* @param {boolean} isPaused
* @memberof Engine */
export function setPaused(isPaused: boolean): void;
/** Startup LittleJS engine with your callback functions
* @param {Function|function():Promise} gameInit - Called once after the engine starts up
* @param {Function} gameUpdate - Called every frame before objects are updated
* @param {Function} gameUpdatePost - Called after physics and objects are updated, even when paused
* @param {Function} gameRender - Called before objects are rendered, for drawing the background
* @param {Function} gameRenderPost - Called after objects are rendered, useful for drawing UI
* @param {Array<string>} [imageSources=[]] - List of images to load
* @param {HTMLElement} [rootElement] - Root element to attach to, the document body by default
* @memberof Engine */
export function engineInit(gameInit: Function | (() => Promise<any>), gameUpdate: Function, gameUpdatePost: Function, gameRender: Function, gameRenderPost: Function, imageSources?: Array<string>, rootElement?: HTMLElement): void;
/** Update each engine object, remove destroyed objects, and update time
* @memberof Engine */
export function engineObjectsUpdate(): void;
/** Destroy and remove all objects
* @memberof Engine */
export function engineObjectsDestroy(): void;
/** Collects all object within a given area
* @param {Vector2} [pos] - Center of test area, or undefined for all objects
* @param {Vector2|number} [size] - Radius of circle if float, rectangle size if Vector2
* @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
* @return {Array<EngineObject>} - List of collected objects
* @memberof Engine */
export function engineObjectsCollect(pos?: Vector2, size?: Vector2 | number, objects?: Array<EngineObject>): Array<EngineObject>;
/** Triggers a callback for each object within a given area
* @param {Vector2} [pos] - Center of test area, or undefined for all objects
* @param {Vector2|number} [size] - Radius of circle if float, rectangle size if Vector2
* @param {Function} [callbackFunction] - Calls this function on every object that passes the test
* @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
* @memberof Engine */
export function engineObjectsCallback(pos?: Vector2, size?: Vector2 | number, callbackFunction?: Function, objects?: Array<EngineObject>): void;
/** Return a list of objects intersecting a ray
* @param {Vector2} start
* @param {Vector2} end
* @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
* @return {Array<EngineObject>} - List of objects hit
* @memberof Engine */
export function engineObjectsRaycast(start: Vector2, end: Vector2, objects?: Array<EngineObject>): Array<EngineObject>;
/** Add a new update function for a plugin
* @param {Function} [updateFunction]
* @param {Function} [renderFunction]
* @memberof Engine */
export function engineAddPlugin(updateFunction?: Function, renderFunction?: Function): void;
/**
* LittleJS Debug System
* - Press Esc to show debug overlay with mouse pick
* - Number keys toggle debug functions
* - +/- apply time scale
* - Debug primitive rendering
* - Save a 2d canvas as a png image
* @namespace Debug
*/
/** True if debug is enabled
* @type {boolean}
* @default
* @memberof Debug */
export const debug: boolean;
/** True if the debug overlay is active, always false in release builds
* @type {boolean}
* @default
* @memberof Debug */
export let debugOverlay: boolean;
/** True if watermark with FPS should be shown, false in release builds
* @type {boolean}
* @default
* @memberof Debug */
export let showWatermark: boolean;
/** Asserts if the expression is false, does not do anything in release builds
* @param {boolean} assert
* @param {Object} [output]
* @memberof Debug */
export function ASSERT(assert: boolean, output?: any): void;
/** Draw a debug rectangle in world space
* @param {Vector2} pos
* @param {Vector2} [size=Vector2()]
* @param {string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {boolean} [fill]
* @memberof Debug */
export function debugRect(pos: Vector2, size?: Vector2, color?: string, time?: number, angle?: number, fill?: boolean): void;
/** Draw a debug poly in world space
* @param {Vector2} pos
* @param {Array<Vector2>} points
* @param {string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {boolean} [fill]
* @memberof Debug */
export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: string, time?: number, angle?: number, fill?: boolean): void;
/** Draw a debug circle in world space
* @param {Vector2} pos
* @param {number} [radius]
* @param {string} [color]
* @param {number} [time]
* @param {boolean} [fill]
* @memberof Debug */
export function debugCircle(pos: Vector2, radius?: number, color?: string, time?: number, fill?: boolean): void;
/** Draw a debug point in world space
* @param {Vector2} pos
* @param {string} [color]
* @param {number} [time]
* @param {number} [angle]
* @memberof Debug */
export function debugPoint(pos: Vector2, color?: string, time?: number, angle?: number): void;
/** Draw a debug line in world space
* @param {Vector2} posA
* @param {Vector2} posB
* @param {string} [color]
* @param {number} [thickness]
* @param {number} [time]
* @memberof Debug */
export function debugLine(posA: Vector2, posB: Vector2, color?: string, thickness?: number, time?: number): void;
/** Draw a debug combined axis aligned bounding box in world space
* @param {Vector2} pA - position A
* @param {Vector2} sA - size A
* @param {Vector2} pB - position B
* @param {Vector2} sB - size B
* @param {string} [color]
* @memberof Debug */
export function debugOverlap(pA: Vector2, sA: Vector2, pB: Vector2, sB: Vector2, color?: string): void;
/** Draw a debug axis aligned bounding box in world space
* @param {string} text
* @param {Vector2} pos
* @param {number} [size]
* @param {string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {string} [font]
* @memberof Debug */
export function debugText(text: string, pos: Vector2, size?: number, color?: string, time?: number, angle?: number, font?: string): void;
/** Clear all debug primitives in the list
* @memberof Debug */
export function debugClear(): void;
/** Trigger debug system to take a screenshot
* @memberof Debug */
export function debugScreenshot(): void;
/** Save a canvas to disk
* @param {HTMLCanvasElement} canvas
* @param {string} [filename]
* @param {string} [type]
* @memberof Debug */
export function debugSaveCanvas(canvas: HTMLCanvasElement, filename?: string, type?: string): void;
/** Save a text file to disk
* @param {string} text
* @param {string} [filename]
* @param {string} [type]
* @memberof Debug */
export function debugSaveText(text: string, filename?: string, type?: string): void;
/** Save a data url to disk
* @param {string} dataURL
* @param {string} filename
* @memberof Debug */
export function debugSaveDataURL(dataURL: string, filename: string): void;
/**
* LittleJS Engine Settings
* - All settings for the engine are here
* @namespace Settings
*/
/** Position of camera in world space
* @type {Vector2}
* @default Vector2()
* @memberof Settings */
export let cameraPos: Vector2;
/** Scale of camera in world space
* @type {number}
* @default
* @memberof Settings */
export let cameraScale: number;
/** The max size of the canvas, centered if window is larger
* @type {Vector2}
* @default Vector2(1920,1080)
* @memberof Settings */
export let canvasMaxSize: Vector2;
/** Fixed size of the canvas, if enabled canvas size never changes
* - you may also need to set mainCanvasSize if using screen space coords in startup
* @type {Vector2}
* @default Vector2()
* @memberof Settings */
export let canvasFixedSize: Vector2;
/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
* - Must be set before startup to take effect
* - If enabled sets css image-rendering:pixelated
* @type {boolean}
* @default
* @memberof Settings */
export let canvasPixelated: boolean;
/** Disables texture filtering for crisper pixel art
* @type {boolean}
* @default
* @memberof Settings */
export let tilesPixelated: boolean;
/** Default font used for text rendering
* @type {string}
* @default
* @memberof Settings */
export let fontDefault: string;
/** Enable to show the LittleJS splash screen be shown on startup
* @type {boolean}
* @default
* @memberof Settings */
export let showSplashScreen: boolean;
/** Disables all rendering, audio, and input for servers
* @type {boolean}
* @default
* @memberof Settings */
export let headlessMode: boolean;
/** Default size of tiles in pixels
* @type {Vector2}
* @default Vector2(16,16)
* @memberof Settings */
export let tileSizeDefault: Vector2;
/** How many pixels smaller to draw tiles to prevent bleeding from neighbors
* @type {number}
* @default
* @memberof Settings */
export let tileFixBleedScale: number;
/** Enable physics solver for collisions between objects
* @type {boolean}
* @default
* @memberof Settings */
export let enablePhysicsSolver: boolean;
/** Default object mass for collision calculations (how heavy objects are)
* @type {number}
* @default
* @memberof Settings */
export let objectDefaultMass: number;
/** How much to slow velocity by each frame (0-1)
* @type {number}
* @default
* @memberof Settings */
export let objectDefaultDamping: number;
/** How much to slow angular velocity each frame (0-1)
* @type {number}
* @default
* @memberof Settings */
export let objectDefaultAngleDamping: number;
/** How much to bounce when a collision occurs (0-1)
* @type {number}
* @default
* @memberof Settings */
export let objectDefaultElasticity: number;
/** How much to slow when touching (0-1)
* @type {number}
* @default
* @memberof Settings */
export let objectDefaultFriction: number;
/** Clamp max speed to avoid fast objects missing collisions
* @type {number}
* @default
* @memberof Settings */
export let objectMaxSpeed: number;
/** How much gravity to apply to objects along the Y axis, negative is down
* @type {number}
* @default
* @memberof Settings */
export let gravity: number;
/** Scales emit rate of particles, useful for low graphics mode (0 disables particle emitters)
* @type {number}
* @default
* @memberof Settings */
export let particleEmitRateScale: number;
/** Enable webgl rendering, webgl can be disabled and removed from build (with some features disabled)
* @type {boolean}
* @default
* @memberof Settings */
export let glEnable: boolean;
/** Fixes slow rendering in some browsers by not compositing the WebGL canvas
* @type {boolean}
* @default
* @memberof Settings */
export let glOverlay: boolean;
/** Should gamepads be allowed
* @type {boolean}
* @default
* @memberof Settings */
export let gamepadsEnable: boolean;
/** If true, the dpad input is also routed to the left analog stick (for better accessability)
* @type {boolean}
* @default
* @memberof Settings */
export let gamepadDirectionEmulateStick: boolean;
/** If true the WASD keys are also routed to the direction keys (for better accessability)
* @type {boolean}
* @default
* @memberof Settings */
export let inputWASDEmulateDirection: boolean;
/** True if touch gamepad should appear on mobile devices
* - Supports left analog stick, 4 face buttons and start button (button 9)
* - Must be set by end of gameInit to be activated
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadEnable: boolean;
/** True if touch gamepad should be analog stick or false to use if 8 way dpad
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadAnalog: boolean;
/** Size of virtual gamepad for touch devices in pixels
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadSize: number;
/** Transparency of touch gamepad overlay
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadAlpha: number;
/** Allow vibration hardware if it exists
* @type {boolean}
* @default
* @memberof Settings */
export let vibrateEnable: boolean;
/** All audio code can be disabled and removed from build
* @type {boolean}
* @default
* @memberof Settings */
export let soundEnable: boolean;
/** Volume scale to apply to all sound, music and speech
* @type {number}
* @default
* @memberof Settings */
export let soundVolume: number;
/** Default range where sound no longer plays
* @type {number}
* @default
* @memberof Settings */
export let soundDefaultRange: number;
/** Default range percent to start tapering off sound (0-1)
* @type {number}
* @default
* @memberof Settings */
export let soundDefaultTaper: number;
/** How long to show medals for in seconds
* @type {number}
* @default
* @memberof Settings */
export let medalDisplayTime: number;
/** How quickly to slide on/off medals in seconds
* @type {number}
* @default
* @memberof Settings */
export let medalDisplaySlideTime: number;
/** Size of medal display
* @type {Vector2}
* @default Vector2(640,80)
* @memberof Settings */
export let medalDisplaySize: Vector2;
/** Size of icon in medal display
* @type {number}
* @default
* @memberof Settings */
export let medalDisplayIconSize: number;
/** Set position of camera in world space
* @param {Vector2} pos
* @memberof Settings */
export function setCameraPos(pos: Vector2): void;
/** Set scale of camera in world space
* @param {number} scale
* @memberof Settings */
export function setCameraScale(scale: number): void;
/** Set max size of the canvas
* @param {Vector2} size
* @memberof Settings */
export function setCanvasMaxSize(size: Vector2): void;
/** Set fixed size of the canvas
* @param {Vector2} size
* @memberof Settings */
export function setCanvasFixedSize(size: Vector2): void;
/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
* @param {boolean} pixelated
* @memberof Settings */
export function setCanvasPixelated(pixelated: boolean): void;
/** Disables texture filtering for crisper pixel art
* @param {boolean} pixelated
* @memberof Settings */
export function setTilesPixelated(pixelated: boolean): void;
/** Set default font used for text rendering
* @param {string} font
* @memberof Settings */
export function setFontDefault(font: string): void;
/** Set if the LittleJS splash screen be shown on startup
* @param {boolean} show
* @memberof Settings */
export function setShowSplashScreen(show: boolean): void;
/** Set to disable rendering, audio, and input for servers
* @param {boolean} headless
* @memberof Settings */
export function setHeadlessMode(headless: boolean): void;
/** Set if webgl rendering is enabled
* @param {boolean} enable
* @memberof Settings */
export function setGlEnable(enable: boolean): void;
/** Set to not composite the WebGL canvas
* @param {boolean} overlay
* @memberof Settings */
export function setGlOverlay(overlay: boolean): void;
/** Set default size of tiles in pixels
* @param {Vector2} size
* @memberof Settings */
export function setTileSizeDefault(size: Vector2): void;
/** Set to prevent tile bleeding from neighbors in pixels
* @param {number} scale
* @memberof Settings */
export function setTileFixBleedScale(scale: number): void;
/** Set if collisions between objects are enabled
* @param {boolean} enable
* @memberof Settings */
export function setEnablePhysicsSolver(enable: boolean): void;
/** Set default object mass for collision calculations
* @param {number} mass
* @memberof Settings */
export function setObjectDefaultMass(mass: number): void;
/** Set how much to slow velocity by each frame
* @param {number} damp
* @memberof Settings */
export function setObjectDefaultDamping(damp: number): void;
/** Set how much to slow angular velocity each frame
* @param {number} damp
* @memberof Settings */
export function setObjectDefaultAngleDamping(damp: number): void;
/** Set how much to bounce when a collision occur
* @param {number} elasticity
* @memberof Settings */
export function setObjectDefaultElasticity(elasticity: number): void;
/** Set how much to slow when touching
* @param {number} friction
* @memberof Settings */
export function setObjectDefaultFriction(friction: number): void;
/** Set max speed to avoid fast objects missing collisions
* @param {number} speed
* @memberof Settings */
export function setObjectMaxSpeed(speed: number): void;
/** Set how much gravity to apply to objects along the Y axis
* @param {number} newGravity
* @memberof Settings */
export function setGravity(newGravity: number): void;
/** Set to scales emit rate of particles
* @param {number} scale
* @memberof Settings */
export function setParticleEmitRateScale(scale: number): void;
/** Set if touch input is allowed
* @param {boolean} enable
* @memberof Settings */
export function setTouchInputEnable(enable: boolean): void;
/** Set if gamepads are enabled
* @param {boolean} enable
* @memberof Settings */
export function setGamepadsEnable(enable: boolean): void;
/** Set if the dpad input is also routed to the left analog stick
* @param {boolean} enable
* @memberof Settings */
export function setGamepadDirectionEmulateStick(enable: boolean): void;
/** Set if true the WASD keys are also routed to the direction keys
* @param {boolean} enable
* @memberof Settings */
export function setInputWASDEmulateDirection(enable: boolean): void;
/** Set if touch gamepad should appear on mobile devices
* @param {boolean} enable
* @memberof Settings */
export function setTouchGamepadEnable(enable: boolean): void;
/** Set if touch gamepad should be analog stick or 8 way dpad
* @param {boolean} analog
* @memberof Settings */
export function setTouchGamepadAnalog(analog: boolean): void;
/** Set size of virtual gamepad for touch devices in pixels
* @param {number} size
* @memberof Settings */
export function setTouchGamepadSize(size: number): void;
/** Set transparency of touch gamepad overlay
* @param {number} alpha
* @memberof Settings */
export function setTouchGamepadAlpha(alpha: number): void;
/** Set to allow vibration hardware if it exists
* @param {boolean} enable
* @memberof Settings */
export function setVibrateEnable(enable: boolean): void;
/** Set to disable all audio code
* @param {boolean} enable
* @memberof Settings */
export function setSoundEnable(enable: boolean): void;
/** Set volume scale to apply to all sound, music and speech
* @param {number} volume
* @memberof Settings */
export function setSoundVolume(volume: number): void;
/** Set default range where sound no longer plays
* @param {number} range
* @memberof Settings */
export function setSoundDefaultRange(range: number): void;
/** Set default range percent to start tapering off sound
* @param {number} taper
* @memberof Settings */
export function setSoundDefaultTaper(taper: number): void;
/** Set how long to show medals for in seconds
* @param {number} time
* @memberof Settings */
export function setMedalDisplayTime(time: number): void;
/** Set how quickly to slide on/off medals in seconds
* @param {number} time
* @memberof Settings */
export function setMedalDisplaySlideTime(time: number): void;
/** Set size of medal display
* @param {Vector2} size
* @memberof Settings */
export function setMedalDisplaySize(size: Vector2): void;
/** Set size of icon in medal display
* @param {number} size
* @memberof Settings */
export function setMedalDisplayIconSize(size: number): void;
/** Set to stop medals from being unlockable
* @param {boolean} preventUnlock
* @memberof Settings */
export function setMedalsPreventUnlock(preventUnlock: boolean): void;
/** Set if watermark with FPS should be shown
* @param {boolean} show
* @memberof Debug */
export function setShowWatermark(show: boolean): void;
/** Set key code used to toggle debug mode, Esc by default
* @param {string} key
* @memberof Debug */
export function setDebugKey(key: string): void;
/**
* LittleJS Utility Classes and Functions
* - General purpose math library
* - Vector2 - fast, simple, easy 2D vector class
* - Color - holds a rgba color with some math functions
* - Timer - tracks time automatically
* - RandomGenerator - seeded random number generator
* @namespace Utilities
*/
/** A shortcut to get Math.PI
* @type {number}
* @default Math.PI
* @memberof Utilities */
export const PI: number;
/** Returns absolute value of value passed in
* @param {number} value
* @return {number}
* @memberof Utilities */
export function abs(value: number): number;
/** Returns lowest of two values passed in
* @param {number} valueA
* @param {number} valueB
* @return {number}
* @memberof Utilities */
export function min(valueA: number, valueB: number): number;
/** Returns highest of two values passed in
* @param {number} valueA
* @param {number} valueB
* @return {number}
* @memberof Utilities */
export function max(valueA: number, valueB: number): number;
/** Returns the sign of value passed in
* @param {number} value
* @return {number}
* @memberof Utilities */
export function sign(value: number): number;
/** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
* @param {number} dividend
* @param {number} [divisor]
* @return {number}
* @memberof Utilities */
export function mod(dividend: number, divisor?: number): number;
/** Clamps the value between max and min
* @param {number} value
* @param {number} [min]
* @param {number} [max]
* @return {number}
* @memberof Utilities */
export function clamp(value: number, min?: number, max?: number): number;
/** Returns what percentage the value is between valueA and valueB
* @param {number} value
* @param {number} valueA
* @param {number} valueB
* @return {number}
* @memberof Utilities */
export function percent(value: number, valueA: number, valueB: number): number;
/** Returns signed wrapped distance between the two values passed in
* @param {number} valueA
* @param {number} valueB
* @param {number} [wrapSize]
* @returns {number}
* @memberof Utilities */
export function distanceWrap(valueA: number, valueB: number, wrapSize?: number): number;
/** Linearly interpolates between values passed in with wrapping
* @param {number} percent
* @param {number} valueA
* @param {number} valueB
* @param {number} [wrapSize]
* @returns {number}
* @memberof Utilities */
export function lerpWrap(percent: number, valueA: number, valueB: number, wrapSize?: number): number;
/** Returns signed wrapped distance between the two angles passed in
* @param {number} angleA
* @param {number} angleB
* @returns {number}
* @memberof Utilities */
export function distanceAngle(angleA: number, angleB: number): number;
/** Linearly interpolates between the angles passed in with wrapping
* @param {number} percent
* @param {number} angleA
* @param {number} angleB
* @returns {number}
* @memberof Utilities */
export function lerpAngle(percent: number, angleA: number, angleB: number): number;
/** Linearly interpolates between values passed in using percent
* @param {number} percent
* @param {number} valueA
* @param {number} valueB
* @return {number}
* @memberof Utilities */
export function lerp(percent: number, valueA: number, valueB: number): number;
/** Applies smoothstep function to the percentage value
* @param {number} percent
* @return {number}
* @memberof Utilities */
export function smoothStep(percent: number): number;
/** Returns the nearest power of two not less then the value
* @param {number} value
* @return {number}
* @memberof Utilities */
export function nearestPowerOfTwo(value: number): number;
/** Returns true if two axis aligned bounding boxes are overlapping
* @param {Vector2} posA - Center of box A
* @param {Vector2} sizeA - Size of box A
* @param {Vector2} posB - Center of box B
* @param {Vector2} [sizeB=(0,0)] - Size of box B, a point if undefined
* @return {boolean} - True if overlapping
* @memberof Utilities */
export function isOverlapping(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB?: Vector2): boolean;
/** Returns true if a line segment is intersecting an axis aligned box
* @param {Vector2} start - Start of raycast
* @param {Vector2} end - End of raycast
* @param {Vector2} pos - Center of box
* @param {Vector2} size - Size of box
* @return {boolean} - True if intersecting
* @memberof Utilities */
export function isIntersecting(start: Vector2, end: Vector2, pos: Vector2, size: Vector2): boolean;
/** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
* @param {number} [frequency] - Frequency of the wave in Hz
* @param {number} [amplitude] - Amplitude (max height) of the wave
* @param {number} [t=time] - Value to use for time of the wave
* @return {number} - Value waving between 0 and amplitude
* @memberof Utilities */
export function wave(frequency?: number, amplitude?: number, t?: number): number;
/** Formats seconds to mm:ss style for display purposes
* @param {number} t - time in seconds
* @return {string}
* @memberof Utilities */
export function formatTime(t: number): string;
/** Random global functions
* @namespace Random */
/** Returns a random value between the two values passed in
* @param {number} [valueA]
* @param {number} [valueB]
* @return {number}
* @memberof Random */
export function rand(valueA?: number, valueB?: number): number;
/** Returns a floored random value between the two values passed in
* The upper bound is exclusive. (If 2 is passed in, result will be 0 or 1)
* @param {number} valueA
* @param {number} [valueB]
* @return {number}
* @memberof Random */
export function randInt(valueA: number, valueB?: number): number;
/** Randomly returns either -1 or 1
* @return {number}
* @memberof Random */
export function randSign(): number;
/** Returns a random Vector2 within a circular shape
* @param {number} [radius]
* @param {number} [minRadius]
* @return {Vector2}
* @memberof Random */
export function randInCircle(radius?: number, minRadius?: number): Vector2;
/** Returns a random Vector2 with the passed in length
* @param {number} [length]
* @return {Vector2}
* @memberof Random */
export function randVector(length?: number): Vector2;
/** Returns a random color between the two passed in colors, combine components if linear
* @param {Color} [colorA=(1,1,1,1)]
* @param {Color} [colorB=(0,0,0,1)]
* @param {boolean} [linear]
* @return {Color}
* @memberof Random */
export function randColor(colorA?: Color, colorB?: Color, linear?: boolean): Color;
/**
* Seeded random number generator
* - Can be used to create a deterministic random number sequence
* @example
* let r = new RandomGenerator(123); // random number generator with seed 123
* let a = r.float(); // random value between 0 and 1
* let b = r.int(10); // random integer between 0 and 9
* r.seed = 123; // reset the seed
* let c = r.float(); // the same value as a
*/
export class RandomGenerator {
/** Create a random number generator with the seed passed in
* @param {number} seed - Starting seed */
constructor(seed: number);
/** @property {number} - random seed */
seed: number;
/** Returns a seeded random value between the two values passed in
* @param {number} [valueA]
* @param {number} [valueB]
* @return {number} */
float(valueA?: number, valueB?: number): number;
/** Returns a floored seeded random value the two values passed in
* @param {number} valueA
* @param {number} [valueB]
* @return {number} */
int(valueA: number, valueB?: number): number;
/** Randomly returns either -1 or 1 deterministically
* @return {number} */
sign(): number;
}
/**
* 2D Vector object with vector math library
* - Functions do not change this so they can be chained together
* @example
* let a = new Vector2(2, 3); // vector with coordinates (2, 3)
* let b = new Vector2; // vector with coordinates (0, 0)
* let c = vec2(4, 2); // use the vec2 function to make a Vector2
* let d = a.add(b).scale(5); // operators can be chained
*/
export class Vector2 {
/** Create a 2D vector with the x and y passed in, can also be created with vec2()
* @param {number} [x] - X axis location
* @param {number} [y] - Y axis location */
constructor(x?: number, y?: number);
/** @property {number} - X axis location */
x: number;
/** @property {number} - Y axis location */
y: number;
/** Sets values of this vector and returns self
* @param {number} [x] - X axis location
* @param {number} [y] - Y axis location
* @return {Vector2} */
set(x?: number, y?: number): Vector2;
/** Returns a new vector that is a copy of this
* @return {Vector2} */
copy(): Vector2;
/** Returns a copy of this vector plus the vector passed in
* @param {Vector2} v - other vector
* @return {Vector2} */
add(v: Vector2): Vector2;
/** Returns a copy of this vector minus the vector passed in
* @param {Vector2} v - other vector
* @return {Vector2} */
subtract(v: Vector2): Vector2;
/** Returns a copy of this vector times the vector passed in
* @param {Vector2} v - other vector
* @return {Vector2} */
multiply(v: Vector2): Vector2;
/** Returns a copy of this vector divided by the vector passed in
* @param {Vector2} v - other vector
* @return {Vector2} */
divide(v: Vector2): Vector2;
/** Returns a copy of this vector scaled by the vector passed in
* @param {number} s - scale
* @return {Vector2} */
scale(s: number): Vector2;
/** Returns the length of this vector
* @return {number} */
length(): number;
/** Returns the length of this vector squared
* @return {number} */
lengthSquared(): number;
/** Returns the distance from this vector to vector passed in
* @param {Vector2} v - other vector
* @return {number} */
distance(v: Vector2): number;
/** Returns the distance squared from this vector to vector passed in
* @param {Vector2} v - other vector
* @return {number} */
distanceSquared(v: Vector2): number;
/** Returns a new vector in same direction as this one with the length passed in
* @param {number} [length]
* @return {Vector2} */
normalize(length?: number): Vector2;
/** Returns a new vector clamped to length passed in
* @param {number} [length]
* @return {Vector2} */
clampLength(length?: number): Vector2;
/** Returns the dot product of this and the vector passed in
* @param {Vector2} v - other vector
* @return {number} */
dot(v: Vector2): number;
/** Returns the cross product of this and the vector passed in
* @param {Vector2} v - other vector
* @return {number} */
cross(v: Vector2): number;
/** Returns the clockwise angle of this vector, up is angle 0
* @return {number} */
angle(): number;
/** Sets this vector with clockwise angle and length passed in
* @param {number} [angle]
* @param {number} [length]
* @return {Vector2} */
setAngle(angle?: number, length?: number): Vector2;
/** Returns copy of this vector rotated by the clockwise angle passed in
* @param {number} angle
* @return {Vector2} */
rotate(angle: number): Vector2;
/** Set the integer direction of this vector, corresponding to multiples of 90 degree rotation (0-3)
* @param {number} [direction]
* @param {number} [length] */
setDirection(direction?: number, length?: number): Vector2;
/** Returns the integer direction of this vector, corresponding to multiples of 90 degree rotation (0-3)
* @return {number} */
direction(): number;
/** Returns a copy of this vector that has been inverted
* @return {Vector2} */
invert(): Vector2;
/** Returns a copy of this vector with each axis floored
* @return {Vector2} */
floor(): Vector2;
/** Returns the area this vector covers as a rectangle
* @return {number} */
area(): number;
/** Returns a new vector that is p percent between this and the vector passed in
* @param {Vector2} v - other vector
* @param {number} percent
* @return {Vector2} */
lerp(v: Vector2, percent: number): Vector2;
/** Returns true if this vector is within the bounds of an array size passed in
* @param {Vector2} arraySize
* @return {boolean} */
arrayCheck(arraySize: Vector2): boolean;
/** Returns this vector expressed as a string
* @param {number} digits - precision to display
* @return {string} */
toString(digits?: number): string;
/** Checks if this is a valid vector
* @return {boolean} */
isValid(): boolean;
}
/**
* Color object (red, green, blue, alpha) with some helpful functions
* @example
* let a = new Color; // white
* let b = new Color(1, 0, 0); // red
* let c = new Color(0, 0, 0, 0); // transparent black
* let d = rgb(0, 0, 1); // blue using rgb color
* let e = hsl(.3, 1, .5); // green using hsl color
*/
export class Color {
/** Create a color with the rgba components passed in, white by default
* @param {number} [r] - red
* @param {number} [g] - green
* @param {number} [b] - blue
* @param {number} [a] - alpha*/
constructor(r?: number, g?: number, b?: number, a?: number);
/** @property {number} - Red */
r: number;
/** @property {number} - Green */
g: number;
/** @property {number} - Blue */
b: number;
/** @property {number} - Alpha */
a: number;
/** Sets values of this color and returns self
* @param {number} [r] - red
* @param {number} [g] - green
* @param {number} [b] - blue
* @param {number} [a] - alpha
* @return {Color} */
set(r?: number, g?: number, b?: number, a?: number): Color;
/** Returns a new color that is a copy of this
* @return {Color} */
copy(): Color;
/** Returns a copy of this color plus the color passed in
* @param {Color} c - other color
* @return {Color} */
add(c: Color): Color;
/** Returns a copy of this color minus the color passed in
* @param {Color} c - other color
* @return {Color} */
subtract(c: Color): Color;
/** Returns a copy of this color times the color passed in
* @param {Color} c - other color
* @return {Color} */
multiply(c: Color): Color;
/** Returns a copy of this color divided by the color passed in
* @param {Color} c - other color
* @return {Color} */
divide(c: Color): Color;
/** Returns a copy of this color scaled by the value passed in, alpha can be scaled separately
* @param {number} scale
* @param {number} [alphaScale=scale]
* @return {Color} */
scale(scale: number, alphaScale?: number): Color;
/** Returns a copy of this color clamped to the valid range between 0 and 1
* @return {Color} */
clamp(): Color;
/** Returns a new color that is p percent between this and the color passed in
* @param {Color} c - other color
* @param {number} percent
* @return {Color} */
lerp(c: Color, percent: number): Color;
/** Sets this color given a hue, saturation, lightness, and alpha
* @param {number} [h] - hue
* @param {number} [s] - saturation
* @param {number} [l] - lightness
* @param {number} [a] - alpha
* @return {Color} */
setHSLA(h?: number, s?: number, l?: number, a?: number): Color;
/** Returns this color expressed in hsla format
* @return {Array<number>} */
HSLA(): Array<number>;
/** Returns a new color that has each component randomly adjusted
* @param {number} [amount]
* @param {number} [alphaAmount]
* @return {Color} */
mutate(amount?: number, alphaAmount?: number): Color;
/** Returns this color expressed as a hex color code
* @param {boolean} [useAlpha] - if alpha should be included in result
* @return {string} */
toString(useAlpha?: boolean): string;
/** Set this color from a hex code
* @param {string} hex - html hex code
* @return {Color} */
setHex(hex: string): Color;
/** Returns this color expressed as 32 bit RGBA value
* @return {number} */
rgbaInt(): number;
/** Checks if this is a valid color
* @return {boolean} */
isValid(): boolean;
}
/**
* Timer object tracks how long has passed since it was set
* @example
* let a = new Timer; // creates a timer that is not set
* a.set(3); // sets the timer to 3 seconds
*
* let b = new Timer(1); // creates a timer with 1 second left
* b.unset(); // unset the timer
*/
export class Timer {
/** Create a timer object set time passed in
* @param {number} [timeLeft] - How much time left before the timer elapses in seconds */
constructor(timeLeft?: number);
time: number;
setTime: number;
/** Set the timer with seconds passed in
* @param {number} [timeLeft] - How much time left before the timer is elapsed in seconds */
set(timeLeft?: number): void;
/** Unset the timer */
unset(): void;
/** Returns true if set
* @return {boolean} */
isSet(): boolean;
/** Returns true if set and has not elapsed
* @return {boolean} */
active(): boolean;
/** Returns true if set and elapsed
* @return {boolean} */
elapsed(): boolean;
/** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
* @return {number} */
get(): number;
/** Get percentage elapsed based on time it was set to, returns 0 if not set
* @return {number} */
getPercent(): number;
/** Returns this timer expressed as a string
* @return {string} */
toString(): string;
/** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
* @return {number} */
valueOf(): number;
}
/**
* Create a 2d vector, can take another Vector2 to copy, 2 scalars, or 1 scalar
* @param {Vector2|number} [x]
* @param {number} [y]
* @return {Vector2}
* @example
* let a = vec2(0, 1); // vector with coordinates (0, 1)
* let b = vec2(a); // copy a into b
* a = vec2(5); // set a to (5, 5)
* b = vec2(); // set b to (0, 0)
* @memberof Utilities
*/
export function vec2(x?: Vector2 | number, y?: number): Vector2;
/**
* Create a color object with RGBA values, white by default
* @param {number} [r=1] - red
* @param {number} [g=1] - green
* @param {number} [b=1] - blue
* @param {number} [a=1] - alpha
* @return {Color}
* @memberof Utilities
*/
export function rgb(r?: number, g?: number, b?: number, a?: number): Color;
/**
* Create a color object with HSLA values, white by default
* @param {number} [h=0] - hue
* @param {number} [s=0] - saturation
* @param {number} [l=1] - lightness
* @param {number} [a=1] - alpha
* @return {Color}
* @memberof Utilities
*/
export function hsl(h?: number, s?: number, l?: number, a?: number): Color;
/**
* Check if object is a valid Color
* @param {any} c
* @return {boolean}
* @memberof Utilities
*/
export function isColor(c: any): boolean;
/** Color - White #ffffff
* @type {Color}
* @memberof Utilities */
export const WHITE: Color;
/** Color - Black #000000
* @type {Color}
* @memberof Utilities */
export const BLACK: Color;
/** Color - Gray #808080
* @type {Color}
* @memberof Utilities */
export const GRAY: Color;
/** Color - Red #ff0000
* @type {Color}
* @memberof Utilities */
export const RED: Color;
/** Color - Orange #ff8000
* @type {Color}
* @memberof Utilities */
export const ORANGE: Color;
/** Color - Yellow #ffff00
* @type {Color}
* @memberof Utilities */
export const YELLOW: Color;
/** Color - Green #00ff00
* @type {Color}
* @memberof Utilities */
export const GREEN: Color;
/** Color - Cyan #00ffff
* @type {Color}
* @memberof Utilities */
export const CYAN: Color;
/** Color - Blue #0000ff
* @type {Color}
* @memberof Utilities */
export const BLUE: Color;
/** Color - Purple #8000ff
* @type {Color}
* @memberof Utilities */
export const PURPLE: Color;
/** Color - Magenta #ff00ff
* @type {Color}
* @memberof Utilities */
export const MAGENTA: Color;
/** Array containing texture info for batch rendering system
* @type {Array<TextureInfo>}
* @memberof Draw */
export let textureInfos: Array<TextureInfo>;
/**
* Create a tile info object using a grid based system
* - This can take vecs or floats for easier use and conversion
* - If an index is passed in, the tile size and index will determine the position
* @param {Vector2|number} [pos=0] - Index of tile in sheet
* @param {Vector2|number} [size=tileSizeDefault] - Size of tile in pixels
* @param {number} [textureIndex] - Texture index to use
* @param {number} [padding] - How many pixels padding around tiles
* @return {TileInfo}
* @example
* tile(2) // a tile at index 2 using the default tile size of 16
* tile(5, 8) // a tile at index 5 using a tile size of 8
* tile(1, 16, 3) // a tile at index 1 of size 16 on texture 3
* tile(vec2(4,8), vec2(30,10)) // a tile at index (4,8) with a size of (30,10)
* @memberof Draw
*/
export function tile(pos?: Vector2 | number, size?: Vector2 | number, textureIndex?: number, padding?: number): TileInfo;
/**
* Tile Info - Stores info about how to draw a tile
*/
export class TileInfo {
/** Create a tile info object
* @param {Vector2} [pos=(0,0)] - Top left corner of tile in pixels
* @param {Vector2} [size=tileSizeDefault] - Size of tile in pixels
* @param {number} [textureIndex] - Texture index to use
* @param {number} [padding] - How many pixels padding around tiles
*/
constructor(pos?: Vector2, size?: Vector2, textureIndex?: number, padding?: number);
/** @property {Vector2} - Top left corner of tile in pixels */
pos: Vector2;
/** @property {Vector2} - Size of tile in pixels */
size: Vector2;
/** @property {number} - Texture index to use */
textureIndex: number;
/** @property {number} - How many pixels padding around tiles */
padding: number;
/** Returns a copy of this tile offset by a vector
* @param {Vector2} offset - Offset to apply in pixels
* @return {TileInfo}
*/
offset(offset: Vector2): TileInfo;
/** Returns a copy of this tile offset by a number of an