littlejsengine
Version:
LittleJS - Tiny and Fast HTML5 Game Engine
1,111 lines • 281 kB
TypeScript
declare module "littlejsengine" {
/**
* - Update or render function for a plugin
*/
export type PluginCallback = () => any;
/**
* - Called after the engine starts, can be async
*/
export type GameInitCallback = () => void | Promise<void>;
/**
* - Update or render function for the game
*/
export type GameCallback = () => any;
/**
* - Function that processes an object
*/
export type ObjectCallbackFunction = (object: EngineObject) => any;
/**
* - Checks if a position is colliding
*/
export type LineTestFunction = (pos: Vector2) => any;
/**
* - A function that draws to a 2D canvas context
*/
export type Canvas2DDrawFunction = (context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D) => any;
/**
* - Function called when a sound ends
*/
export type AudioEndedCallback = (source: AudioBufferSourceNode) => any;
/**
* - Function to handle a tile collision test
*/
export type TileCollisionCallback = (tileData: number, pos: Vector2) => any;
/**
* - Function that processes a medal
*/
export type MedalCallbackFunction = (medal: Medal) => any;
/**
* - Function that processes a particle
*/
export type ParticleCallback = (particle: Particle) => any;
/**
* - Collide callback for particles
*/
export type ParticleCollideCallback = (particle: Particle, tileData: number, pos: Vector2) => any;
/**
* LittleJS - The Tiny Fast JavaScript Game Engine
* MIT License - Copyright 2021 Frank Force
*
* Engine Features
* - Object oriented system with EngineObject base class
* - Automatic object lifecycle (update, physics, collision, rendering)
* - Engine helper classes: Vector2, Color, Timer, RandomGenerator
* - Hybrid rendering with WebGL batching and Canvas2D fallback
* - Audio system with wave, mp3, or ZzFX sound effects
* - Input system with keyboard, mouse, gamepad, and touch support
* - Tile layer rendering and collision detection
* - Particle effect system with emitters
* - Medal/achievement system with local storage
* - Comprehensive debug tools and visualizations
* - Fixed 60 FPS timestep with configurable time scale
* - Raycast and spatial query utilities
* - Plugin system for extending engine functionality
* - Start with engineInit() and provide your game callbacks
* @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>;
/** Array with only objects set to collide with other objects this frame (for optimization)
* @type {Array<EngineObject>}
* @memberof Engine */
export let engineObjectsCollide: 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, timescale, 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;
/** Get if game is paused
* @return {boolean}
* @memberof Engine */
export function getPaused(): boolean;
/** Set if game is paused
* @param {boolean} [isPaused]
* @memberof Engine */
export function setPaused(isPaused?: boolean): void;
/**
* @callback GameInitCallback - Called after the engine starts, can be async
* @return {void|Promise<void>}
* @memberof Engine
*/
/**
* @callback GameCallback - Update or render function for the game
* @memberof Engine
*/
/** Startup LittleJS engine with your callback functions
* @param {GameInitCallback} gameInit - Called once after the engine starts up, can be async for loading
* @param {GameCallback} gameUpdate - Called every frame before objects are updated (60fps), use for game logic
* @param {GameCallback} gameUpdatePost - Called after physics and objects are updated, even when paused, use for UI updates
* @param {GameCallback} gameRender - Called before objects are rendered, use for drawing backgrounds/world elements
* @param {GameCallback} gameRenderPost - Called after objects are rendered, use for drawing UI/overlays
* @param {Array<string>} [imageSources=[]] - List of image file paths to preload (e.g., ['player.png', 'tiles.png'])
* @param {HTMLElement} [rootElement] - Root DOM element to attach canvas to, defaults to document.body
* @example
* // Basic engine startup
* engineInit(
* ()=> { LOG('Game initialized!'); }, // gameInit
* ()=> { updateGameLogic(); }, // gameUpdate
* ()=> { updateUI(); }, // gameUpdatePost
* ()=> { drawBackground(); }, // gameRender
* ()=> { drawHUD(); }, // gameRenderPost
* ['tiles.png', 'tilesLevel.png'] // images to load
* );
* @memberof Engine */
export function engineInit(gameInit: GameInitCallback, gameUpdate: GameCallback, gameUpdatePost: GameCallback, gameRender: GameCallback, gameRenderPost: GameCallback, imageSources?: Array<string>, rootElement?: HTMLElement): Promise<void>;
/** Update each engine object, remove destroyed objects, and update time
* can be called manually if objects need to be updated outside of main loop
* @memberof Engine */
export function engineObjectsUpdate(): void;
/** Destroy and remove all objects
* - This can be used to clear out all objects when restarting a level
* - Objects can override their destroy function to do cleanup or stick around
* @param {boolean} [immediate] - should attached effects be allowed to die off?
* @memberof Engine */
export function engineObjectsDestroy(immediate?: boolean): 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>;
/**
* @callback ObjectCallbackFunction - Function that processes an object
* @param {EngineObject} object
* @memberof Engine
*/
/** 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 {ObjectCallbackFunction} [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?: ObjectCallbackFunction, 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>;
/**
* @callback PluginCallback - Update or render function for a plugin
* @memberof Engine
*/
/** Add a new update function for a plugin
* @param {PluginCallback} [update]
* @param {PluginCallback} [render]
* @param {PluginCallback} [glContextLost]
* @param {PluginCallback} [glContextRestored]
* @memberof Engine */
export function engineAddPlugin(update?: PluginCallback, render?: PluginCallback, glContextLost?: PluginCallback, glContextRestored?: PluginCallback): void;
/**
* LittleJS Debug System
* - Press Esc to toggle debug overlay with object picking
* - Number keys toggle debug visualizations (physics, particles, etc.)
* - +/- keys control time scale for slow motion/fast forward
* - ASSERT and LOG macros for development (removed in release builds)
* - Debug primitive rendering (rectangles, circles, lines, points, text)
* - Screenshot and video capture support
* - FPS counter and performance watermark
* - Debug overlay shows mouse position and picked objects
* @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 debugWatermark: boolean;
/** Asserts if the expression is false, does nothing in release builds
* Halts execution if the assert fails and throws an error
* @param {boolean} assert
* @param {...Object} output - error message output
* @memberof Debug */
export function ASSERT(assert: boolean, ...output: any[]): void;
/** Log to console if debug is enabled, does nothing in release builds
* @param {...Object} output - message output
* @memberof Debug */
export function LOG(...output: any[]): void;
/** Size to render debug points by default
* @type {number}
* @default
* @memberof Debug */
export const debugPointSize: number;
/** Draw a debug rectangle in world space
* @param {Vector2} pos
* @param {Vector2} [size=vec2(0)]
* @param {Color|string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {boolean} [fill]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugRect(pos: Vector2, size?: Vector2, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
/** Draw a debug poly in world space
* @param {Vector2} pos
* @param {Array<Vector2>} points
* @param {Color|string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {boolean} [fill]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
/** Draw a debug circle in world space
* @param {Vector2} pos
* @param {number} [size] - diameter
* @param {Color|string} [color]
* @param {number} [time]
* @param {boolean} [fill]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugCircle(pos: Vector2, size?: number, color?: Color | string, time?: number, fill?: boolean, screenSpace?: boolean): void;
/** Draw a debug point in world space
* @param {Vector2} pos
* @param {Color|string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugPoint(pos: Vector2, color?: Color | string, time?: number, angle?: number, screenSpace?: boolean): void;
/** Draw a debug line in world space
* @param {Vector2} posA
* @param {Vector2} posB
* @param {Color|string} [color]
* @param {number} [width]
* @param {number} [time]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugLine(posA: Vector2, posB: Vector2, color?: Color | string, width?: number, time?: number, screenSpace?: boolean): void;
/** Draw a debug combined axis aligned bounding box in world space
* @param {Vector2} posA
* @param {Vector2} sizeA
* @param {Vector2} posB
* @param {Vector2} sizeB
* @param {Color|string} [color]
* @param {number} [time]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugOverlap(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2, color?: Color | string, time?: number, screenSpace?: boolean): void;
/** Draw debug text in world space
* @param {string|number} text
* @param {Vector2} pos
* @param {number} [size]
* @param {Color|string} [color]
* @param {number} [time]
* @param {number} [angle]
* @param {string} [font]
* @param {boolean} [screenSpace]
* @memberof Debug */
export function debugText(text: string | number, pos: Vector2, size?: number, color?: Color | string, time?: number, angle?: number, font?: string, screenSpace?: boolean): 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;
/** Breaks on all asserts/errors, hides the canvas, and shows message in plain text
* This is a good function to call at the start of your game to catch all errors
* In release builds this function has no effect
* @memberof Debug */
export function debugShowErrors(): void;
/** Start capturing video
* @memberof Debug */
export function debugVideoCaptureStart(): void;
/** Stop capturing video and save to disk
* @memberof Debug */
export function debugVideoCaptureStop(): void;
/** Check if video capture is active
* @memberof Debug */
export function debugVideoCaptureIsActive(): boolean;
/**
* 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;
/** Rotation angle of camera in world space
* @type {number}
* @default
* @memberof Settings */
export let cameraAngle: number;
/** Scale of camera in world space
* @type {number}
* @default
* @memberof Settings */
export let cameraScale: number;
/** Scale applied to engine time, can be used for slow motion or fast forward
* - 1 is normal speed, 2 is double speed, 0.5 is half speed
* - 0 freezes the simulation without setting the paused flag
* - Should be >= 0; stacks multiplicatively with the debug +/- shortcut
* @type {number}
* @default
* @memberof Settings */
export let timeScale: number;
/** Enable applying color to tiles when using canvas2d
* - This is slower but should be the same as WebGL rendering
* @type {boolean}
* @default
* @memberof Settings */
export let canvasColorTiles: boolean;
/** Color to clear the canvas to before render, does not clear if alpha is 0
* @type {Color}
* @memberof Settings */
export let canvasClearColor: Color;
/** The max size of the canvas, centered if window is larger
* @type {Vector2}
* @default Vector2(1920,1080)
* @memberof Settings */
export let canvasMaxSize: Vector2;
/** Minimum aspect ratio of the canvas (width/height), unused if 0
* Can be used with canvasMaxAspect to limit aspect ratio
* @type {number}
* @default
* @memberof Settings */
export let canvasMinAspect: number;
/** Maximum aspect ratio of the canvas (width/height), unused if 0
* Can be used with canvasMinAspect to limit aspect ratio
* @type {number}
* @default
* @memberof Settings */
export let canvasMaxAspect: number;
/** 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 canvas scaling for more pixelated look
* - If enabled sets css image-rendering:pixelated
* @type {boolean}
* @default
* @memberof Settings */
export let canvasPixelated: boolean;
/** Disables texture filtering for crisper pixel art
* - Leave true for pixel art so sprites stay sharp when scaled (uses NEAREST filtering)
* - Set false for smooth/high-resolution art to enable bilinear filtering and mipmaps
* @type {boolean}
* @default
* @memberof Settings */
export let tilesPixelated: boolean;
/** Scale factor applied to the canvas backing store for native-resolution rendering.
* Pass 1 for no scaling, a number for an explicit ratio, or undefined to track devicePixelRatio each frame.
* @type {number|undefined}
* @default
* @memberof Settings */
export let canvasPixelRatio: number | undefined;
/** Default font used for text rendering
* @type {string}
* @default
* @memberof Settings */
export let fontDefault: string;
/** Enable to show the LittleJS splash screen 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 tileDefaultSize: Vector2;
/** Default padding pixels around tiles
* @type {number}
* @default
* @memberof Settings */
export let tileDefaultPadding: number;
/** Default amount of pixels smaller to draw tiles to prevent neighbor bleeding
* @type {number}
* @default
* @memberof Settings */
export let tileDefaultBleed: 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 objectDefaultRestitution: 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, negative Y is down
* @type {Vector2}
* @default
* @memberof Settings */
export let gravity: Vector2;
/** 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 accelerated rendering
* @type {boolean}
* @default
* @memberof Settings */
export let glEnable: boolean;
/** How many sided poly to use when drawing circles and ellipses with WebGL
* @type {number}
* @default
* @memberof Settings */
export let glCircleSides: number;
/** 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 accessibility)
* @type {boolean}
* @default
* @memberof Settings */
export let gamepadDirectionEmulateStick: boolean;
/** If true the WASD keys are also routed to the direction keys (for better accessibility)
* @type {boolean}
* @default
* @memberof Settings */
export let inputWASDEmulateDirection: boolean;
/** True if touch input is enabled for mobile devices
* - Touch events will be routed to mouse events
* @type {boolean}
* @default
* @memberof Settings */
export let touchInputEnable: boolean;
/** True if touch gamepad should appear on mobile devices
* - Supports left analog stick, 4 face buttons and start button (button 9)
* - setTouchGamepadButtonCount(1) to use face buttons as right analog stick
* - Analog stick buttons 10 and 11 are also activated when virtual sticks are touched
* - Rendered as a full-viewport HTML/SVG overlay, so controls may sit outside the game canvas
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadEnable: boolean;
/** True if touches outside the gamepad controls should still drive mouse/touch input
* - When false (the default), enabling the touch gamepad suppresses touch-to-mouse input entirely
* - Set true to also pass touches outside the controls through to the game as mouse/touch input
* - Touches on the gamepad controls never drive the mouse regardless of this setting
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadPassthrough: boolean;
/** Size of center button if touch gamepad should have start button in the center
* - Prevents activating when pressed near virtual stick or face buttons
* - When the game is paused, any touch will press the button
* - Measured in viewport CSS pixels
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadCenterButtonSize: number;
/** Number of buttons on the right side of the touch gamepad (0-4), using gamepad buttons 0-3
* - A count of 1 is a single large button (the size of a stick)
* - Ignored when touchGamepadRightStick is set (the right side is a stick instead)
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadButtonCount: number;
/** True if the touch gamepad should have a left analog stick (or dpad)
* - When false, the left side is face buttons (touchGamepadLeftButtonCount) or nothing
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadLeftStick: boolean;
/** Number of buttons on the left side of the touch gamepad (0-4), using gamepad buttons 4-7
* - Only used when touchGamepadLeftStick is false (otherwise the left side is a stick)
* - A count of 1 is a single large button (the size of a stick)
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadLeftButtonCount: number;
/** True if the touch gamepad right side should be an analog stick (or dpad) instead of face buttons
* - When set, touchGamepadButtonCount is ignored and the right side is a stick
* - Uses an analog stick when touchGamepadAnalog is true, otherwise an 8 way dpad
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadRightStick: 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;
/** True if touch gamepad directional controls should float to where you press
* - Only affects analog sticks and dpads, not face buttons
* - Directional controls re-anchor to where you press within the bottom ~60% of their screen half; the top ~40% passes through to the game
* - The right side floats only when it acts as the right analog stick (touchGamepadRightStick is set)
* - A center button (touchGamepadCenterButtonSize) still works since it ignores touches near the sticks
* @type {boolean}
* @default
* @memberof Settings */
export let touchGamepadFloating: boolean;
/** Size of virtual gamepad for touch devices in viewport CSS pixels
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadSize: number;
/** Transparency of touch gamepad overlay
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadAlpha: number;
/** How long to display the touch gamepad on screen in seconds, set to 0 to always display
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadDisplayTime: number;
/** Duration in ms to vibrate when a touch gamepad face button or start button is pressed
* - Set to 0 to disable, also requires vibrateEnable and hardware support (ignored on iOS)
* @type {number}
* @default
* @memberof Settings */
export let touchGamepadVibration: 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
* Use setSoundVolume to also update the audio master gain immediately
* @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;
/** Set position of camera in world space
* @param {Vector2} pos
* @memberof Settings */
export function setCameraPos(pos: Vector2): void;
/** Set angle of camera in world space
* @param {number} angle
* @memberof Settings */
export function setCameraAngle(angle: number): void;
/** Set scale of camera in world space
* @param {number} scale
* @memberof Settings */
export function setCameraScale(scale: number): void;
/** Set scale applied to engine time
* @param {number} scale
* @memberof Settings */
export function setTimeScale(scale: number): void;
/** Set if tiles should be colorized when using canvas2d
* This can be slower but results should look nearly identical to WebGL rendering
* It can be enabled/disabled at any time
* Optimized for performance, and will use faster method if color is white or untextured
* @param {boolean} colorTiles
* @memberof Settings */
export function setCanvasColorTiles(colorTiles: boolean): void;
/** Set color to clear the canvas to before render, does not clear if alpha is 0
* @param {Color} color
* @memberof Settings */
export function setCanvasClearColor(color: Color): void;
/** Set max size of the canvas
* @param {Vector2} size
* @memberof Settings */
export function setCanvasMaxSize(size: Vector2): void;
/** Set minimum aspect ratio of the canvas (width/height), unused if 0
* @param {number} aspect
* @memberof Settings */
export function setCanvasMinAspect(aspect: number): void;
/** Set maximum aspect ratio of the canvas (width/height), unused if 0
* @param {number} aspect
* @memberof Settings */
export function setCanvasMaxAspect(aspect: number): void;
/** Set fixed size of the canvas
* @param {Vector2} size
* @memberof Settings */
export function setCanvasFixedSize(size: Vector2): void;
/** Use nearest 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
* - Leave true for pixel art; set false for smooth/high-resolution art
* @param {boolean} pixelated
* @memberof Settings */
export function setTilesPixelated(pixelated: boolean): void;
/** Set the canvas pixel ratio.
* Pass a number for an explicit ratio, or call with no argument to track devicePixelRatio each frame.
* @param {number} [pixelRatio]
* @memberof Settings */
export function setCanvasPixelRatio(pixelRatio?: number): 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 should 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 default size of tiles in pixels
* @param {Vector2} size
* @memberof Settings */
export function setTileDefaultSize(size: Vector2): void;
/** Default padding pixels around tiles
* @param {number} padding
* @memberof Settings */
export function setTileDefaultPadding(padding: number): void;
/** Default amount of pixels smaller to draw tiles to prevent neighbor bleeding
* @param {number} bleed
* @memberof Settings */
export function setTileDefaultBleed(bleed: 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 occurs
* @param {number} restitution
* @memberof Settings */
export function setObjectDefaultRestitution(restitution: 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
* @param {Vector2} newGravity
* @memberof Settings */
export function setGravity(newGravity: Vector2): void;
/** Set to scales emit rate of particles
* @param {number} scale
* @memberof Settings */
export function setParticleEmitRateScale(scale: number): void;
/** Set how many sided polygons to use when drawing circles and ellipses with WebGL
* @param {number} sides
* @memberof Settings */
export function setGLCircleSides(sides: 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 touches outside the gamepad controls should still drive mouse/touch input
* @param {boolean} passthrough
* @memberof Settings */
export function setTouchGamepadPassthrough(passthrough: boolean): void;
/** Set if touch gamepad should have start button in the center
* - Set size to enable the center button
* - When the game is paused, any touch will press the button
* @param {number} size
* @memberof Settings */
export function setTouchGamepadCenterButtonSize(size: number): void;
/** Set number of buttons on the right side of the touch gamepad (0-4, gamepad buttons 0-3)
* @param {number} count
* @memberof Settings */
export function setTouchGamepadButtonCount(count: number): void;
/** Set if the touch gamepad should have a left analog stick (or dpad)
* @param {boolean} enable
* @memberof Settings */
export function setTouchGamepadLeftStick(enable: boolean): void;
/** Set number of buttons on the left side of the touch gamepad (0-4, gamepad buttons 4-7)
* - Only used when touchGamepadLeftStick is false
* @param {number} count
* @memberof Settings */
export function setTouchGamepadLeftButtonCount(count: number): void;
/** Set if the touch gamepad right side is an analog stick (or dpad) instead of face buttons
* @param {boolean} rightStick
* @memberof Settings */
export function setTouchGamepadRightStick(rightStick: 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 if touch gamepad directional controls should float to where you press
* @param {boolean} floating
* @memberof Settings */
export function setTouchGamepadFloating(floating: 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 how long to display the touch gamepad on screen in seconds, set to 0 to always display
* @param {number} time
* @memberof Settings */
export function setTouchGamepadDisplayTime(time: number): void;
/** Set duration in ms to vibrate when a touch gamepad face or start button is pressed (0 disables)
* @param {number} ms
* @memberof Settings */
export function setTouchGamepadVibration(ms: 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 if watermark with FPS should be shown
* @param {boolean} show
* @memberof Debug */
export function setDebugWatermark(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 Math Classes and Functions
* - Comprehensive math utilities for game development
* - Vector2 class for 2D positions, directions, and math operations
* - Color class for RGBA colors with interpolation and manipulation
* - RandomGenerator for seeded pseudo-random number generation
* - Math shortcuts (PI, abs, floor, ceil, min, max, sin, cos, etc.)
* - Interpolation functions (lerp, smoothStep, percent)
* - Clamping, wrapping, and modulo operations
* - Angle utilities with wrap-around support
* - Collision detection (overlapping, intersection, line tests)
* - Random number generation and seeding
* - Type checking utilities
* @namespace Math
*/
/** The value of PI
* @type {number}
* @default Math.PI
* @memberof Math */
export const PI: number;
/** Returns absolute value of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const abs: (x: number) => number;
/** Returns floored value of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const floor: (x: number) => number;
/** Returns ceiled value of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const ceil: (x: number) => number;
/** Returns rounded value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const round: (x: number) => number;
/** Returns lowest value passed in
* @param {...number} values
* @return {number}
* @memberof Math */
export const min: (...values: number[]) => number;
/** Returns highest value passed in
* @param {...number} values
* @return {number}
* @memberof Math */
export const max: (...values: number[]) => number;
/** Returns the sign of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export function sign(x: number): number;
/** Returns hypotenuse of values passed in
* @param {...number} values
* @return {number}
* @memberof Math */
export function hypot(...values: number[]): number;
/** Returns log2 of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export function log2(x: number): number;
/** Returns sin of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const sin: (x: number) => number;
/** Returns cos of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const cos: (x: number) => number;
/** Returns tan of value passed in
* @param {number} x
* @return {number}
* @memberof Math */
export const tan: (x: number) => number;
/** Returns atan2 of values passed in
* @param {number} y
* @param {number} x
* @return {number}
* @memberof Math */
export const atan2: (y: number, x: 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 Math */
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 Math */
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 Math */
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]
* @return {number}
* @memberof Math */
export function distanceWrap(valueA: number, valueB: number, wrapSize?: number): number;
/** Linearly interpolates between values passed in with wrapping
* @param {number} valueA
* @param {number} valueB
* @param {number} percent
* @param {number} [wrapSize]
* @return {number}
* @memberof Math */
export function lerpWrap(valueA: number, valueB: number, percent: number, wrapSize?: number): number;
/** Returns signed wrapped distance between the two angles passed in
* @param {number} angleA
* @param {number} angleB
* @return {number}
* @memberof Math */
export function distanceAngle(angleA: number, angleB: number): number;
/** Linearly interpolates between the angles passed in with wrapping
* @param {number} angleA
* @param {number} angleB
* @param {number} percent
* @return {number}
* @memberof Math */
export function lerpAngle(angleA: number, angleB: number, percent: number): number;
/** Linearly interpolates between values passed in using percent
* @param {number} valueA
* @param {number} valueB
* @param {number} percent
* @return {number}
* @memberof Math */
export function lerp(valueA: number, valueB: number, percent: number): number;
/** Gets percent between percentA and percentB and linearly interpolates between lerpA and lerpB
* A shortcut for lerp(lerpA, lerpB, percent(value, percentA, percentB))
* @param {number} value
* @param {number} percentA
* @param {number} percentB
* @param {number} lerpA
* @param {number} lerpB
* @return {number}
* @memberof Math */
export function percentLerp(value: number, percentA: number, percentB: number, lerpA: number, lerpB: number): number;
/** Applies smoothstep function to the percentage value
* @param {number} percent
* @return {number}
* @memberof Math */
export function smoothStep(percent: number): number;
/** Returns the nearest power of two not less than the value
* @param {number} value
* @return {number}
* @memberof Math */
export function nearestPowerOfTwo(value: number): number;
/** Checks if the value passed in is a power of two
* @param {number} value
* @return {boolean}
* @memberof Math */
export function isPowerOfTwo(value: number): boolean;
/** Returns true if two axis aligned bounding boxes are overlapping
* this can be used for simple collision detection between objects
* @param {Vector2} posA - Center of box A
* @param {Vector2} sizeA - Size of box A
* @param {Vector2} posB - Center of box B
* @param {Vector2} [sizeB=vec2()] - Size of box B, uses a point if undefined
* @return {boolean} - True if overlapping
* @memberof Math */
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 Math */
export function isIntersecting(start: Vector2, end: Vector2, pos: Vector2, size: Vector2): boolean;
/**
* @callback LineTestFunction - Checks if a position is colliding
* @param {Vector2} pos
* @memberof Draw
*/
/**
* Casts a ray and returns position of the first collision found, or undefined if none are found
* @param {Vector2} posStart
* @param {Vector2} posEnd
* @param {LineTestFunction} testFunction - Check if colliding
* @param {Vector2} [normal] - Optional vector to store the normal
* @return {Vector2|undefined} - Position of the collision or undefined if none found
* @memberof Math */
export function lineTest(posStart: Vector2, posEnd: Vector2, testFunction: LineTestFunction, normal?: Vector2): Vector2 | undefined;
/** 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
* @param {number} [offset] - Value to use for time offset of the wave
* @param {number} [type] - Wave type: 0=sine, 1=triangle, 2=square, 3=sawtooth
* @return {number} - Value waving between 0 and amplitude
* @memberof Math */
export function oscillate(frequency?: number, amplitude?: number, t?: number, offset?: number, type?: 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;
/** Fetches a JSON file from a URL and returns the parsed JSON object. Must be used with await!
* @param {string} url - URL of JSON file
* @return {Promise<object>}
* @memberof Utilities */
export function fetchJSON(url: string): Promise<object>;
/** Save a text file to disk
* @param {string} text
* @param {string} [filename]
* @param {string} [type]
* @memberof Utilities */
export function saveText(text: string, filename?: string, type?: string): void;
/** Save a canvas to disk
* @param {HTMLCanvasElement|OffscreenCanvas} canvas
* @param {string} [filename]
* @param {string} [type]
* @memberof Utilities */
export function saveCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, filename?: string, type?: string): void;
/** Save a data url to disk
* @param {string} url
* @param {string} [filename]
* @param {number} [revokeTime] - how long before revoking the url
* @memberof Utilities */
export function saveDataURL(url: string, filename?: string, revokeTime?: number): void;
/** Share content using the native share dialog if available
* @param {string} title - title of the share
* @param {string} url - url to share
* @param {Function} [callback] - Called when share is complete
* @memberof Utilities */
export function shareURL(title: string, url: string, callback?: Function): void;
/** Read save data from local storage
* @param {string} saveName - unique name for the game/save
* @param {Object} [defaultSaveData] - default values for save
* @return {Object}
* @memberof Utilities */
export function readSaveData(saveName: string, defaultSaveData?: any): any;
/** Write save data to local storage
* @param {string} saveName - unique name for the game/save
* @param {Object} saveData - object containing data to be saved
* @memberof Utilities */
export function writeSaveData(saveName: string, saveData: any): void;
/** 1D gradient noise — returns a smooth value in [0, 1] for any real x.
* Integer inputs land on deterministic lattice values; non-integer inputs
* are interpolated with smoothStep for C1 continuity.
* @param {number} x
* @return {number}
* @memberof Utilities */
export function noise1D(x: number): number;
/** 2D gradient noise — returns a smooth value in [0, 1] for any real (x, y).
* @param {number} x
* @param {number} y
* @return {number}
* @memberof Utilities */
export function noise2D(x: number, y: numb