duckengine
Version:
A 2D Game Engine for the web.
319 lines (318 loc) • 13 kB
TypeScript
import Game from './game';
import Render from '../base/render';
import { Duck } from '../index';
import Sprite from './gameobjects/sprite';
import Rect from './gameobjects/rect';
import Circle from './gameobjects/circle';
import RoundRect from './gameobjects/roundrect';
import Particle from './gameobjects/particles/particle';
import ParticleEmitter from './gameobjects/particles/particleEmitter';
import SoundPlayer from './sound/soundPlayer';
import Input from './input/input';
import Camera from './camera/camera';
import StaticLight from './lights/staticLight';
import Group from './group/group';
import Cutscene from './cutscene/cutscene';
import Loader from './loader/loader';
import TileMap from './map/tilemap';
import Once from '../base/once';
import Amount from '../base/amount';
import Button from './gameobjects/ui/button';
import Text from './gameobjects/ui/text';
import Effect from './effect/effect';
import ExplosionEffect from './effect/preset/explosion';
import SmokeEffect from './effect/preset/smoke';
import DisplayList from './models/displayList';
import CanvasModulate from './gameobjects/misc/canvasModulate';
import Vector2 from './math/vector2';
import PhysicsServer from './physics/server/physicsServer';
import PhysicsList from './models/physicsList';
import Area from './physics/models/area';
import PhysicsBody from './physics/physicsBody';
import GameObject from './gameobjects/gameObject';
import Tileset from './map/tileset';
import TileLayer from './map/tilelayer';
import Timer from '../base/timer';
/**
* @class Scene
* @classdesc Creates a DuckEngine Scene
* @description The Scene Class. Main rendering happens here
* @since 1.0.0-beta
*/
export default class Scene extends Render {
/**
* @memberof Scene
* @description The key of the Scene, used to identify the Scene
* @type string
* @since 1.0.0-beta
*/
readonly key: string;
/**
* @memberof Scene
* @description The state of the Scene being visible, determines if the Scene.displayList, physicsList, update, and __tick, is being called/used
* in the game loop
* @type boolean
* @since 1.0.0-beta
*/
visible: boolean;
/**
* @memberof Scene
* @description Determines if the Scene is visible by default
* @type boolean
* @since 1.0.0-beta
*/
readonly default: boolean;
/**
* @memberof Scene
* @description The game instance the scene is added to
* @type Game
* @since 1.0.0-beta
*/
protected game: Game;
/**
* @memberof Scene
* @description The current camera being updated
* @type Camera | undefined
* @since 1.0.0-beta
*/
currentCamera: Camera | undefined;
/**
* @memberof Scene
* @description The main camera of the scene
* @type Camera | undefined
* @since 1.0.0-beta
*/
mainCamera: Camera | undefined;
/**
* @memberof Scene
* @description An array of cameras that the scene holds
* @type Camera[]
* @since 1.0.0-beta
*/
cameras: Camera[];
/**
* @memberof Scene
* @description A DisplayList instance, holds and manages Renderables
* @type DisplayList
* @since 2.0.0
*/
displayList: DisplayList;
/**
* @memberof Scene
* @description A PhysicsList instance, holds and manages PhysicsBodies
* @type PhysicsList
* @since 2.0.0
*/
physicsList: PhysicsList;
/**
* @memberof Scene
* @description A Loader instance, used to load assets in Scene.preload method that you override
* @type Loader
* @since 2.0.0
*/
loader: Loader;
/**
* @memberof Scene
* @description A PhysicsServer instance, manages and updates all the physics for the Scene.PhysicsList. It is set to undefined if
* Game.config.physics.customTick is truthy
* @type PhysicsServer | undefined
* @since 2.0.0
*/
physicsServer: PhysicsServer | undefined;
/**
* @memberof Scene
* @description A property that is a function that gets called when the scene is switched to being visible
* @type () => void
* @since 2.1.0
*/
onSceneActive: () => void;
/**
* @memberof Scene
* @description A property that is a function that gets called when the scene is switched to not being visible
* @type () => void
* @since 2.1.0
*/
onSceneInactive: () => void;
/**
* @memberof Scene
* @description Used to add GameObjects and more to the scene
* @since 1.0.0-beta
*/
add: {
gameobject: {
misc: {
canvasModulate: (x: number, y: number, w: number, h: number, fillColor: string) => CanvasModulate;
};
existing: <t extends Duck.Types.Texture.Type>(gameobject: GameObject<t>) => GameObject<t>;
sprite: (x: number, y: number, w: number, h: number, textureKey: string, currentRow?: number, currentCol?: number) => Sprite;
rect: (x: number, y: number, w: number, h: number, fillColor: string) => Rect;
circle: (x: number, y: number, r: number, fillColor: string) => Circle;
roundRect: (x: number, y: number, w: number, h: number, r: number, fillColor: string) => RoundRect;
};
misc: {
area: (x: number, y: number, w: number, h: number, collisionFilter: PhysicsBody<Duck.Types.Texture.Type>[]) => Area;
};
ui: {
text: (text: string, config: Duck.Types.UI.Text.Config) => Text;
button: (shape: Duck.Types.UI.Button.Shape, x: number, y: number, w: number, h: number, r: number, fillColor: string, text: Text) => Button;
};
soundPlayer: (path: string, options?: Duck.Types.Sound.Config) => SoundPlayer;
input: () => Input;
camera: () => Camera;
mainCamera: () => Camera;
light: {
staticLight: (x: number, y: number, r: number, fillColor: string, alpha: Duck.Types.Helper.AlphaRange) => StaticLight;
};
group: <t>(name: string, defaultValues?: t[]) => Group<t>;
particle: (shape: Duck.Types.Collider.ShapeString, w: number, h: number, r: number, fillColor: string) => Particle;
particleEmitter: (particle: Particle, rangeX: Duck.Types.ParticleEmitter.Range, rangeY: Duck.Types.ParticleEmitter.Range, amount: number, autoCreate?: boolean) => ParticleEmitter;
cutscene: (config: Duck.Types.Cutscene.Config, instructions: Duck.Types.Cutscene.Instructions) => Cutscene;
map: {
tilemap: (origin: Duck.Types.Math.Vector2Like, tilelayers: TileLayer[]) => TileMap;
tileset: (textureKey: string, tileW: number, tileH: number, rows: number, cols: number) => Tileset;
tileLayer: (tileset: Tileset, map: number[][], zIndex?: number, visible?: boolean) => TileLayer;
};
effect: (rangeX: Duck.Types.ParticleEmitter.Range, rangeY: Duck.Types.ParticleEmitter.Range, particleEmitter: ParticleEmitter) => Effect;
presetEffect: {
explosionEffect: (rangeX: Duck.Types.ParticleEmitter.Range, rangeY: Duck.Types.ParticleEmitter.Range, particleAmount: number | undefined, speedRange: [1, 1] | undefined, maxAge: number | undefined, color: string | undefined) => ExplosionEffect;
smokeEffect: (rangeX: Duck.Types.ParticleEmitter.Range, rangeY: Duck.Types.ParticleEmitter.Range, particleAmount: number | undefined, speedRangeX: [-0.1, 0.4] | undefined, speedRangeY: [-0.1, 0.4] | undefined, maxAge: number | undefined, color: '#2e2e2e' | undefined, interval: 50 | undefined) => SmokeEffect;
};
};
/**
* @memberof Scene
* @description Misc tools, contains color, physics, and math related tools
* @since 1.0.0-beta
*/
tools: {
loader: typeof Loader;
color: {
random: () => string;
randomWithAlpha: (alpha?: Duck.Types.Helper.AlphaRange) => string;
is: {
hex: (str: string) => boolean;
hsl: (str: string) => boolean;
rgb: (str: string) => boolean;
};
convert: {
rgb: {
toHsl: (r: number, g: number, b: number) => string;
toRgba: (color: string, alpha: Duck.Types.Helper.AlphaRange) => string;
};
rgba: {
toHsla: (r: string | number, g: string | number, b: string | number, a: Duck.Types.Helper.AlphaRange) => string;
toRgb: (rgba: string) => string;
};
hex: {
toRgba: (hex: string, alpha: Duck.Types.Helper.AlphaRange) => string;
toRgb: (hex: string) => string | null;
toHsl: (hex: string) => string;
};
};
};
physics: {
rectToRectIntersect: (rect: Rect | Sprite, rect2: Rect | Sprite) => boolean;
circleToRectIntersect: (circle: Circle | {
position: {
x: number;
y: number;
};
w: number;
h: number;
r: number;
}, rect: Rect | Sprite | {
position: {
x: number;
y: number;
};
w: number;
h: number;
}) => boolean;
};
math: {
createVector: (x?: number, y?: number) => Vector2;
vector: typeof Vector2;
clamp: (x: number, min: number, max: number) => number;
lerp: (start: number, end: number, amount: number) => number;
randomInt: (min: number, max: number) => number;
randomFloat: (min: number, max: number, fixed?: number) => number;
};
};
/**
* @constructor Scene
* @description Creates a Scene instance
* @param {string} key Key/Identifier or name of scene
* @param {Game} game Game instance
* @param {boolean} [visible=false] Is the scene visible, defaults to false
* @since 1.0.0-beta
*/
constructor(key: string, game: Game, visible?: boolean);
/**
* @memberof Scene
* @description Calls physics server __tick method if game.config.physics.enabled is true
* and game.config.physics.customTick is false
* *Do not call manually, this is called in GAME LOOP*
*
* @since 2.0.0
*/
__tick(): void;
/**
* @memberof Scene
* @description Sets the visible property and calls the game.renderer.pipeline.pool method to immediately update the visibility
*
* **Note: this calls Game.renderer.pipeline.pool to immediately update the visibility**
*
* @param {boolean} visible What to set the visible property to
* @since 2.1.0
*/
setVisible(visible: boolean): void;
/**
* @memberof Scene
* @description Switches the active camera to a passed camera
* @param {Camera} camera Camera to switch to
* @memberof 1.0.0-beta
*/
switchCamera(camera: Camera): void;
/**
* @memberof Scene
* @description Switches the active camera to the main camera
* @since 1.0.0-beta
*/
switchToMainCamera(): void;
/**
* @memberof Scene
* @description Sets a camera as the main camera
* @param {Camera} camera Camera to set the main camera as
* @since 1.0.0-beta
*/
setMainCamera(camera: Camera): void;
/**
* @memberof Scene
* @description Runs a function once no matter if it is in a loop or not
* @param {(...args: unknown[]) => unknown} func Function to run
* @param {boolean} [run] Determines if function is ran right when it is initialized
* @returns {Once}
* @since 1.0.0
*/
once(func: (...args: unknown[]) => unknown, run?: boolean): Once;
/**
* @memberof Scene
* @description Allows a function to only be ran a max amount of times
* @param {(currentCount:number) => void} func Function to call
* @param {number} maxAmount Max amount of times to allow the function to be called
* @param {boolean} [run] Determines if function is ran right when it is initialized
* @returns {Amount}
* @since 1.1.0
*/
runAmount(func: (currentCount: number) => void, maxAmount: number, run?: boolean): Amount;
/**
* @memberof Scene
* @description Creates and returns a Timer instance
* @param {number} ms Milliseconds, converted to seconds which is used to check if the target time is reached in Timer.count
* @param {(...args:unknown[])=>unknown} cb Callback to call every time the timer reaches its target
* @param {unknown[]} args Arguments to pass to the callback
* @param {number} repeat Amount of times to repeat, set to infinity to repeat forever
* @returns {Timer}
* @since 2.1.0
*/
createTimer(ms: number, cb: (...args: unknown[]) => unknown, args: unknown[], repeat: number): Timer;
}