// Type definitions for Pixi.js 4.5 // Project: https://github.com/pixijs/pixi.js/tree/dev // Definitions by: clark-stevenson // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.1 declare namespace PIXI { // from CONST const VERSION: typeof CONST.VERSION; const PI_2: typeof CONST.PI_2; const RAD_TO_DEG: typeof CONST.RAD_TO_DEG; const DEG_TO_RAD: typeof CONST.DEG_TO_RAD; const RENDERER_TYPE: typeof CONST.RENDERER_TYPE; const BLEND_MODES: typeof CONST.BLEND_MODES; const DRAW_MODES: typeof CONST.DRAW_MODES; const SCALE_MODES: typeof CONST.SCALE_MODES; const WRAP_MODES: typeof CONST.WRAP_MODES; const TRANSFORM_MODE: typeof CONST.TRANSFORM_MODE; const PRECISION: typeof CONST.PRECISION; const GC_MODES: typeof CONST.GC_MODES; const SHAPES: typeof CONST.SHAPES; const TEXT_GRADIENT: typeof CONST.TEXT_GRADIENT; const UPDATE_PRIORITY: typeof CONST.UPDATE_PRIORITY; function autoDetectRenderer(width: number, height: number, options?: PIXI.RendererOptions, forceCanvas?: boolean): PIXI.WebGLRenderer | PIXI.CanvasRenderer; function autoDetectRenderer(options?: PIXI.RendererOptions): PIXI.WebGLRenderer | PIXI.CanvasRenderer; const loader: PIXI.loaders.Loader; ////////////////////////////////////////////////////////////////////////////// ///////////////////////////////SETTINGS/////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace settings { let TARGET_FPMS: number; let MIPMAP_TEXTURES: boolean; let RESOLUTION: number; let FILTER_RESOLUTION: number; let SPRITE_MAX_TEXTURES: number; let SPRITE_BATCH_SIZE: number; let RETINA_PREFIX: RegExp; const RENDER_OPTIONS: { view: HTMLCanvasElement | null, antialias: boolean, forceFXAA: boolean, autoResize: boolean, transparent: boolean, backgroundColor: number, clearBeforeRender: boolean, preserveDrawingBuffer: boolean, roundPixels: boolean width: number, height: number, legacy: boolean, }; let TRANSFORM_MODE: number; let GC_MODE: number; let GC_MAX_IDLE: number; let GC_MAX_CHECK_COUNT: number; let WRAP_MODE: number; let SCALE_MODE: number; let PRECISION_VERTEX: string; let PRECISION_FRAGMENT: string; let PRECISION: string; let UPLOADS_PER_FRAME: number; let CAN_UPLOAD_SAME_BUFFER: boolean; } ////////////////////////////////////////////////////////////////////////////// /////////////////////////////ACCESSIBILITY//////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace accessibility { // accessibility class AccessibilityManager { constructor(renderer: CanvasRenderer | WebGLRenderer); activate(): void; deactivate(): void; protected div: HTMLElement; protected pool: HTMLElement[]; protected renderId: number; debug: boolean; renderer: SystemRenderer; protected children: AccessibleTarget[]; protected isActive: boolean; protected updateAccessibleObjects(displayObject: DisplayObject): void; protected update(): void; protected capHitArea(hitArea: HitArea): void; protected addChild(displayObject: DisplayObject): void; protected _onClick(e: interaction.InteractionEvent): void; protected _onFocus(e: interaction.InteractionEvent): void; protected _onFocusOut(e: interaction.InteractionEvent): void; protected _onKeyDown(e: interaction.InteractionEvent): void; protected _onMouseMove(): void; destroy(): void; } interface AccessibleTarget { accessible: boolean; accessibleTitle: string | null; accessibleHint: string | null; tabIndex: number; } } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////CORE////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // const namespace CONST { const VERSION: string; const PI_2: number; const RAD_TO_DEG: number; const DEG_TO_RAD: number; const TARGET_FPMS: number; const RENDERER_TYPE: { UNKNOWN: number; WEBGL: number; CANVAS: number; }; const BLEND_MODES: { NORMAL: number; ADD: number; MULTIPLY: number; SCREEN: number; OVERLAY: number; DARKEN: number; LIGHTEN: number; COLOR_DODGE: number; COLOR_BURN: number; HARD_LIGHT: number; SOFT_LIGHT: number; DIFFERENCE: number; EXCLUSION: number; HUE: number; SATURATION: number; COLOR: number; LUMINOSITY: number; NORMAL_NPM: number; ADD_NPM: number; SCREEN_NPM: number; }; const DRAW_MODES: { POINTS: number; LINES: number; LINE_LOOP: number; LINE_STRIP: number; TRIANGLES: number; TRIANGLE_STRIP: number; TRIANGLE_FAN: number; }; const SCALE_MODES: { LINEAR: number, NEAREST: number }; const GC_MODES: { AUTO: number; MANUAL: number; }; const WRAP_MODES: { CLAMP: number; MIRRORED_REPEAT: number; REPEAT: number; }; const TRANSFORM_MODE: { DEFAULT: number; DYNAMIC: number; STATIC: number; }; const URL_FILE_EXTENSION: RegExp | string; const DATA_URI: RegExp | string; const SVG_SIZE: RegExp | string; const SHAPES: { POLY: number; RECT: number; CIRC: number; ELIP: number; RREC: number; }; const PRECISION: { LOW: string; MEDIUM: string; HIGH: string; }; const TEXT_GRADIENT: { LINEAR_VERTICAL: number; LINEAR_HORIZONTAL: number; }; const UPDATE_PRIORITY: { INTERACTION: number; HIGH: number; NORMAL: number; LOW: number; UTILITY: number; }; } // display class Application { constructor(options?: ApplicationOptions) constructor(width?: number, height?: number, options?: ApplicationOptions, noWebGL?: boolean, sharedTicker?: boolean, sharedLoader?: boolean); private _ticker: ticker.Ticker; renderer: PIXI.WebGLRenderer | PIXI.CanvasRenderer; stage: Container; ticker: ticker.Ticker; readonly screen: Rectangle; stop(): void; start(): void; render(): void; destroy(removeView?: boolean): void; readonly view: HTMLCanvasElement; } interface DestroyOptions { children?: boolean; texture?: boolean; baseTexture?: boolean; } class Bounds { minX: number; minY: number; maxX: number; maxY: number; rect: Rectangle; isEmpty(): boolean; clear(): void; getRectangle(rect?: Rectangle): Rectangle; addPoint(point: Point): void; addQuad(vertices: number[]): Bounds | undefined; addFrame(transform: Transform, x0: number, y0: number, x1: number, y1: number): void; addVertices(transform: Transform, vertices: number[], beginOffset: number, endOffset: number): void; addBounds(bounds: Bounds): void; addBoundsMask(bounds: Bounds, mask: Bounds): void; addBoundsArea(bounds: Bounds, area: Rectangle): void; } class Container extends DisplayObject { // begin extras.getChildByName getChildByName(name: string): DisplayObject; // end extras.getChildByName children: DisplayObject[]; width: number; height: number; protected onChildrenChange: (...args: any[]) => void; addChild(child: T, ...additionalChildren: DisplayObject[]): T; addChildAt(child: T, index: number): T; swapChildren(child: DisplayObject, child2: DisplayObject): void; getChildIndex(child: DisplayObject): number; setChildIndex(child: DisplayObject, index: number): void; getChildAt(index: number): DisplayObject; removeChild(child: DisplayObject): DisplayObject; removeChildAt(index: number): DisplayObject; removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[]; updateTransform(): void; calculateBounds(): void; protected _calculateBounds(): void; protected containerUpdateTransform(): void; renderWebGL(renderer: WebGLRenderer): void; renderAdvancedWebGL(renderer: WebGLRenderer): void; protected _renderWebGL(renderer: WebGLRenderer): void; protected _renderCanvas(renderer: CanvasRenderer): void; renderCanvas(renderer: CanvasRenderer): void; destroy(options?: DestroyOptions | boolean): void; once(event: "added" | "removed", fn: (displayObject: DisplayObject) => void, context?: any): this; //tslint:disable-next-line:ban-types forbidden-types once(event: string, fn: Function, context?: any): this; on(event: "added" | "removed", fn: (displayObject: DisplayObject) => void, context?: any): this; //tslint:disable-next-line:ban-types forbidden-types on(event: string, fn: Function, context?: any): this; //tslint:disable-next-line:ban-types forbidden-types off(event: "added" | "removed" | string, fn?: Function, context?: any): this; } class DisplayObject extends utils.EventEmitter implements interaction.InteractiveTarget, accessibility.AccessibleTarget { // begin extras.cacheAsBitmap protected _cacheAsBitmap: boolean; protected _cacheData: boolean; cacheAsBitmap: boolean; protected _renderCachedWebGL(renderer: WebGLRenderer): void; protected _initCachedDisplayObject(renderer: WebGLRenderer): void; protected _renderCachedCanvas(renderer: CanvasRenderer): void; protected _initCachedDisplayObjectCanvas(renderer: CanvasRenderer): void; protected _calculateCachedBounds(): Rectangle; protected _getCachedLocalBounds(): Rectangle; protected _destroyCachedDisplayObject(): void; protected _cacheAsBitmapDestroy(options: boolean | any): void; // end extras.cacheAsBitmap // begin extras.getChildByName name: string | null; // end extras.getChildByName // begin extras.getGlobalPosition getGlobalPosition(point?: Point, skipUpdate?: boolean): Point; // end extras.getGlobalPosition // begin accessible target accessible: boolean; accessibleTitle: string | null; accessibleHint: string | null; tabIndex: number; // end accessible target // begin interactive target interactive: boolean; interactiveChildren: boolean; hitArea: PIXI.Rectangle | PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.RoundedRectangle; buttonMode: boolean; cursor: string; trackedPointers(): { [key: number]: interaction.InteractionTrackingData; }; // depricated defaultCursor: string; // end interactive target transform: TransformBase; alpha: number; visible: boolean; renderable: boolean; parent: Container; worldAlpha: number; filterArea: Rectangle; protected _filters: Filter[] | null; protected _enabledFilters: Filter[] | null; protected _bounds: Bounds; protected _boundsID: number; protected _lastBoundsID: number; protected _boundsRect: Rectangle; protected _localBoundsRect: Rectangle; protected _mask: PIXI.Graphics | PIXI.Sprite; protected readonly _destroyed: boolean; x: number; y: number; worldTransform: Matrix; localTransform: Matrix; position: Point | ObservablePoint; scale: Point | ObservablePoint; pivot: Point | ObservablePoint; skew: ObservablePoint; rotation: number; worldVisible: boolean; mask: PIXI.Graphics | PIXI.Sprite; filters: Filter[] | null; updateTransform(): void; protected displayObjectUpdateTransform(): void; protected _recursivePostUpdateTransform(): void; getBounds(skipUpdate?: boolean, rect?: Rectangle): Rectangle; getLocalBounds(rect?: Rectangle): Rectangle; //creates and returns a new point toGlobal(position: PointLike): Point; //modifies the x and y of the passed point and returns it toGlobal(position: PointLike, point?: T, skipUpdate?: boolean): T; //creates and returns a new point toLocal(position: PointLike, from?: DisplayObject): Point; //modifies the x and y of the passed point and returns it toLocal(position: PointLike, from?: DisplayObject, point?: T, skipUpdate?: boolean): T; renderWebGL(renderer: WebGLRenderer): void; renderCanvas(renderer: CanvasRenderer): void; setParent(container: Container): Container; setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, pivotX?: number, pivotY?: number): DisplayObject; destroy(): void; on(event: interaction.InteractionEventTypes, fn: (event: interaction.InteractionEvent) => void, context?: any): this; once(event: interaction.InteractionEventTypes, fn: (event: interaction.InteractionEvent) => void, context?: any): this; removeListener(event: interaction.InteractionEventTypes, fn?: (event: interaction.InteractionEvent) => void, context?: any): this; removeAllListeners(event: interaction.InteractionEventTypes): this; off(event: interaction.InteractionEventTypes, fn?: (event: interaction.InteractionEvent) => void, context?: any): this; addListener(event: interaction.InteractionEventTypes, fn: (event: interaction.InteractionEvent) => void, context?: any): this; } class TransformBase { static IDENTITY: TransformBase; worldTransform: Matrix; localTransform: Matrix; protected _worldID: number; updateLocalTransform(): void; updateTransform(parentTransform: TransformBase): void; updateWorldTransform(parentTransform: TransformBase): void; } class TransformStatic extends TransformBase { position: ObservablePoint; scale: ObservablePoint; pivot: ObservablePoint; skew: ObservablePoint; protected _rotation: number; protected _sr?: number; protected _cr?: number; protected _cy?: number; protected _sy?: number; protected _nsx?: number; protected _cx?: number; protected _currentLocalID: number; protected onChange(): void; updateSkew(): void; updateLocalTransform(): void; updateTransform(parentTransform: TransformBase): void; setFromMatrix(matrix: Matrix): void; rotation: number; } class Transform extends TransformBase { constructor(); position: Point; scale: Point; skew: ObservablePoint; pivot: Point; protected _rotation: number; protected _sr?: number; protected _cr?: number; protected _cy?: number; protected _sy?: number; protected _nsx?: number; protected _cx?: number; updateSkew(): void; setFromMatrix(matrix: Matrix): void; rotation: number; } // graphics class GraphicsData { constructor( lineWidth: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number, fill: boolean, nativeLines: boolean, shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any); lineWidth: number; nativeLines: boolean; lineColor: number; lineAlpha: number; protected _lineTint: number; fillColor: number; fillAlpha: number; protected _fillTint: number; fill: boolean; protected holes: Circle[] | Rectangle[] | Ellipse[] | Polygon[] | RoundedRectangle[] | any[]; shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any; type?: number; clone(): GraphicsData; addHole(shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any): void; destroy(options?: DestroyOptions | boolean): void; } class Graphics extends Container { constructor(nativeLines?: boolean); fillAlpha: number; lineWidth: number; nativeLines: boolean; lineColor: number; protected graphicsData: GraphicsData[]; tint: number; protected _prevTint: number; blendMode: number; currentPath: GraphicsData; protected _webGL: any; isMask: boolean; boundsPadding: number; protected _localBounds: Bounds; dirty: number; fastRectDirty: number; clearDirty: number; boundsDirty: number; protected cachedSpriteDirty: boolean; protected _spriteRect: Rectangle; protected _fastRect: boolean; static _SPRITE_TEXTURE: Texture; clone(): Graphics; lineStyle(lineWidth?: number, color?: number, alpha?: number): Graphics; moveTo(x: number, y: number): Graphics; lineTo(x: number, y: number): Graphics; quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics; bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics; arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics; arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): Graphics; beginFill(color: number, alpha?: number): Graphics; endFill(): Graphics; drawRect(x: number, y: number, width: number, height: number): Graphics; drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics; drawCircle(x: number, y: number, radius: number): Graphics; drawEllipse(x: number, y: number, width: number, height: number): Graphics; drawPolygon(path: number[] | Point[]): Graphics; clear(): Graphics; isFastRect(): boolean; protected _renderCanvas(renderer: CanvasRenderer): void; protected _calculateBounds(): Rectangle; protected _renderSpriteRect(renderer: PIXI.SystemRenderer): void; containsPoint(point: Point): boolean; updateLocalBounds(): void; drawShape(shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any): GraphicsData; generateCanvasTexture(scaleMode?: number, resolution?: number): Texture; protected closePath(): Graphics; protected addHole(): Graphics; destroy(options?: DestroyOptions | boolean): void; } class CanvasGraphicsRenderer { constructor(renderer: SystemRenderer); render(graphics: Graphics): void; protected updateGraphicsTint(graphics: Graphics): void; protected renderPolygon(points: Point[], close: boolean, context: CanvasRenderingContext2D): void; destroy(): void; } class GraphicsRenderer extends ObjectRenderer { constructor(renderer: PIXI.CanvasRenderer); protected graphicsDataPool: GraphicsData[]; protected primitiveShader: PrimitiveShader; gl: WebGLRenderingContext; CONTEXT_UID: number; destroy(): void; render(graphics: Graphics): void; protected updateGraphics(graphics: PIXI.Graphics): void; getWebGLData(webGL: WebGLRenderingContext, type: number, nativeLines: number): WebGLGraphicsData; } class WebGLGraphicsData { constructor(gl: WebGLRenderingContext, shader: glCore.GLShader, attribsState: glCore.AttribState); gl: WebGLRenderingContext; color: number[]; points: Point[]; indices: number[]; buffer: WebGLBuffer; indexBuffer: WebGLBuffer; dirty: boolean; glPoints: number[]; glIndices: number[]; shader: glCore.GLShader; vao: glCore.VertexArrayObject; nativeLines: boolean; reset(): void; upload(): void; destroy(): void; } class PrimitiveShader extends glCore.GLShader { } // math namespace GroupD8 { const E: number; const SE: number; const S: number; const SW: number; const W: number; const NW: number; const N: number; const NE: number; const MIRROR_HORIZONTAL: number; const MIRROR_VERTICAL: number; function uX(ind: number): number; function uY(ind: number): number; function vX(ind: number): number; function vY(ind: number): number; function inv(rotation: number): number; function add(rotationSecond: number, rotationFirst: number): number; function sub(rotationSecond: number, rotationFirst: number): number; function rotate180(rotation: number): number; function isSwapWidthHeight(rotation: number): boolean; function byDirection(dx: number, dy: number): number; function matrixAppendRotationInv(matrix: Matrix, rotation: number, tx: number, ty: number): void; } class Matrix { constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number); a: number; b: number; c: number; d: number; tx: number; ty: number; fromArray(array: number[]): void; set(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix; toArray(transpose?: boolean, out?: number[]): number[]; apply(pos: Point, newPos?: Point): Point; applyInverse(pos: Point, newPos?: Point): Point; translate(x: number, y: number): Matrix; scale(x: number, y: number): Matrix; rotate(angle: number): Matrix; append(matrix: Matrix): Matrix; setTransform(x: number, y: number, pivotX: number, pivotY: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number): PIXI.Matrix; prepend(matrix: Matrix): Matrix; invert(): Matrix; identity(): Matrix; decompose(transform: TransformBase): TransformBase; clone(): Matrix; copy(matrix: Matrix): Matrix; static IDENTITY: Matrix; static TEMP_MATRIX: Matrix; } class PointLike { x: number; y: number; set(x?: number, y?: number): void; copy(point: PointLike): void; } class ObservablePoint extends PointLike { constructor(cb: () => any, scope?: any, x?: number, y?: number); cb: () => any; scope: any; } class Point extends PointLike { constructor(x?: number, y?: number); clone(): Point; equals(p: PointLike): boolean; } interface HitArea { contains(x: number, y: number): boolean; } class Circle { constructor(x?: number, y?: number, radius?: number); x: number; y: number; radius: number; type: number; clone(): Circle; contains(x: number, y: number): boolean; getBounds(): Rectangle; } class Ellipse { constructor(x?: number, y?: number, width?: number, height?: number); x: number; y: number; width: number; height: number; type: number; clone(): Ellipse; contains(x: number, y: number): boolean; getBounds(): Rectangle; } class Polygon { constructor(points: Point[] | number[]); // Note - Rest Params cannot be combined with | //tslint:disable-next-line:unified-signatures constructor(...points: Point[]); //tslint:disable-next-line:unified-signatures constructor(...points: number[]); closed: boolean; points: number[]; type: number; clone(): Polygon; contains(x: number, y: number): boolean; close(): void; } class Rectangle { constructor(x?: number, y?: number, width?: number, height?: number); x: number; y: number; width: number; height: number; type: number; left: number; right: number; top: number; bottom: number; static EMPTY: Rectangle; clone(): Rectangle; copy(rectangle: Rectangle): Rectangle; contains(x: number, y: number): boolean; pad(paddingX: number, paddingY: number): void; fit(rectangle: Rectangle): void; enlarge(rectangle: Rectangle): void; } class RoundedRectangle { constructor(x?: number, y?: number, width?: number, height?: number, radius?: number); x: number; y: number; width: number; height: number; radius: number; type: number; clone(): RoundedRectangle; contains(x: number, y: number): boolean; } // renderers interface RendererOptions { /** * the width of the renderers view [default=800] */ width?: number; /** * the height of the renderers view [default=600] */ height?: number; /** * the canvas to use as a view, optional */ view?: HTMLCanvasElement; /** * If the render view is transparent, [default=false] */ transparent?: boolean; /** * sets antialias (only applicable in chrome at the moment) [default=false] */ antialias?: boolean; /** * enables drawing buffer preservation, enable this if you need to call toDataUrl on the webgl context [default=false] */ preserveDrawingBuffer?: boolean; /** * The resolution / device pixel ratio of the renderer, retina would be 2 [default=1] */ resolution?: number; /** * prevents selection of WebGL renderer, even if such is present [default=false] */ forceCanvas?: boolean; /** * The background color of the rendered area (shown if not transparent) [default=0x000000] */ backgroundColor?: number; /** * This sets if the renderer will clear the canvas or not before the new render pass. [default=true] */ clearBeforeRender?: boolean; /** * If true Pixi will Math.floor() x/ y values when rendering, stopping pixel interpolation. [default=false] */ roundPixels?: boolean; /** * forces FXAA antialiasing to be used over native FXAA is faster, but may not always look as great ** webgl only** [default=false] */ forceFXAA?: boolean; /** * `true` to ensure compatibility with older / less advanced devices. If you experience unexplained flickering try setting this to true. **webgl only** [default=false] */ legacy?: boolean; /** * Depricated */ context?: WebGLRenderingContext; /** * Depricated */ autoResize?: boolean; } interface ApplicationOptions extends RendererOptions { /** * `true` to use PIXI.ticker.shared, `false` to create new ticker. [default=false] */ sharedTicker?: boolean; /** * `true` to use PIXI.loaders.shared, `false` to create new Loader. */ sharedLoader?: boolean; } class SystemRenderer extends utils.EventEmitter { constructor(system: string, options?: RendererOptions); constructor(system: string, screenWidth?: number, screenHeight?: number, options?: RendererOptions); type: number; options: RendererOptions; screen: Rectangle; readonly width: number; readonly height: number; view: HTMLCanvasElement; resolution: number; transparent: boolean; autoResize: boolean; blendModes: any; // todo? preserveDrawingBuffer: boolean; clearBeforeRender: boolean; roundPixels: boolean; protected _backgroundColor: number; protected _backgroundColorRgba: number[]; protected _backgroundColorString: string; protected _tempDisplayObjectParent: Container; protected _lastObjectRendered: DisplayObject; resize(screenWidth: number, screenHeight: number): void; generateTexture(displayObject: DisplayObject, scaleMode?: number, resolution?: number): RenderTexture; render(...args: any[]): void; destroy(removeView?: boolean): void; } class CanvasRenderer extends SystemRenderer { // plugintarget mixin start static __plugins: any; //tslint:disable-next-line:ban-types forbidden-types static registerPlugin(pluginName: string, ctor: Function): void; plugins: any; initPlugins(): void; destroyPlugins(): void; // plugintarget mixin end // from InteractionManager interaction?: interaction.InteractionManager; constructor(options?: RendererOptions); constructor(screenWidth?: number, screenHeight?: number, options?: RendererOptions); rootContext: CanvasRenderingContext2D; rootResolution?: number; refresh: boolean; maskManager: CanvasMaskManager; smoothProperty: string; extract: extract.CanvasExtract; context: CanvasRenderingContext2D | null; render(displayObject: PIXI.DisplayObject, renderTexture?: PIXI.RenderTexture, clear?: boolean, transform?: PIXI.Transform, skipUpdateTransform?: boolean): void; setBlendMode(blendMode: number): void; destroy(removeView?: boolean): void; clear(clearColor?: string): void; on(event: "prerender" | "postrender", fn: () => void, context?: any): this; once(event: "prerender" | "postrender", fn: () => void, context?: any): this; removeListener(event: "prerender" | "postrender", fn?: () => void, context?: any): this; removeAllListeners(event: "prerender" | "postrender"): this; off(event: "prerender" | "postrender", fn?: () => void, context?: any): this; addListener(event: "prerender" | "postrender", fn: () => void, context?: any): this; } class CanvasMaskManager { constructor(renderer: CanvasRenderer); pushMask(maskData: any): void; protected renderGraphicsShape(graphics: Graphics): void; popMask(renderer: WebGLRenderer | CanvasRenderer): void; destroy(): void; } class CanvasRenderTarget { constructor(width: number, height: number, resolution: number); canvas: HTMLCanvasElement; context: CanvasRenderingContext2D; resolution: number; width: number; height: number; clear(): void; resize(width: number, height: number): void; destroy(): void; } interface WebGLRendererOptions extends RendererOptions { } class WebGLRenderer extends SystemRenderer { // plugintarget mixin start static __plugins: any; //tslint:disable-next-line:ban-types forbidden-types static registerPlugin(pluginName: string, ctor: Function): void; plugins: any; initPlugins(): void; destroyPlugins(): void; // plugintarget mixin end // from InteractionManager interaction: interaction.InteractionManager; constructor(options?: WebGLRendererOptions); constructor(screenWidth?: number, screenHeight?: number, options?: WebGLRendererOptions); protected _contextOptions: { alpha: boolean; antiAlias?: boolean; premultipliedAlpha: boolean; stencil: boolean; preseveDrawingBuffer?: boolean; }; protected _backgroundColorRgba: number[]; maskManager: MaskManager; stencilManager?: StencilManager; emptyRenderer: ObjectRenderer; currentRenderer: ObjectRenderer; gl: WebGLRenderingContext; CONTEXT_UID: number; state?: WebGLState; renderingToScreen: boolean; boundTextures: Texture[]; filterManager: FilterManager; textureManager?: TextureManager; textureGC?: TextureGarbageCollector; extract: extract.WebGLExtract; protected drawModes: any; protected _activeShader: Shader; _activeRenderTarget: RenderTarget; protected _initContext(): void; render(displayObject: PIXI.DisplayObject, renderTexture?: PIXI.RenderTexture, clear?: boolean, transform?: PIXI.Transform, skipUpdateTransform?: boolean): void; setObjectRenderer(objectRenderer: ObjectRenderer): void; flush(): void; setBlendMode(blendMode: number): void; clear(clearColor?: number): void; setTransform(matrix: Matrix): void; clearRenderTexture(renderTexture: RenderTexture, clearColor?: number): WebGLRenderer; bindRenderTexture(renderTexture: RenderTexture, transform: Transform): WebGLRenderer; bindRenderTarget(renderTarget: RenderTarget): WebGLRenderer; bindShader(shader: Shader, autoProject?: boolean): WebGLRenderer; bindTexture(texture: Texture | BaseTexture, location?: number, forceLocation?: boolean): number; unbindTexture(texture: Texture | BaseTexture): WebGLRenderer | undefined; createVao(): glCore.VertexArrayObject; bindVao(vao: glCore.VertexArrayObject): WebGLRenderer; reset(): WebGLRenderer; handleContextLost: (event: WebGLContextEvent) => void; handleContextRestored: () => void; destroy(removeView?: boolean): void; on(event: "prerender" | "postrender", fn: () => void, context?: any): this; on(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this; once(event: "prerender" | "postrender", fn: () => void, context?: any): this; once(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this; removeListener(event: "prerender" | "postrender", fn?: () => void, context?: any): this; removeListener(event: "context", fn?: (gl: WebGLRenderingContext) => void, context?: any): this; removeAllListeners(event: "prerender" | "postrender" | "context"): this; off(event: "prerender" | "postrender", fn?: () => void, context?: any): this; off(event: "context", fn?: (gl: WebGLRenderingContext) => void, context?: any): this; addListener(event: "prerender" | "postrender", fn: () => void, context?: any): this; addListener(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this; } class WebGLState { constructor(gl: WebGLRenderingContext); activeState: number[]; defaultState: number[]; stackIndex: number; stack: number[]; gl: WebGLRenderingContext; maxAttribs: number; attribState: glCore.AttribState; nativeVaoExtension: any; push(): void; pop(): void; setState(state: number[]): void; setBlend(value: number): void; setBlendMode(value: number): void; setDepthTest(value: number): void; setCullFace(value: number): void; setFrontFace(value: number): void; resetAttributes(): void; resetToDefault(): void; } class TextureManager { constructor(renderer: WebGLRenderer); renderer: WebGLRenderer; gl: WebGLRenderingContext; protected _managedTextures: Texture[]; bindTexture(): void; getTexture(): WebGLTexture; updateTexture(texture: BaseTexture | Texture): WebGLTexture; destroyTexture(texture: BaseTexture, _skipRemove?: boolean): void; removeAll(): void; destroy(): void; } class TextureGarbageCollector { constructor(renderer: WebGLRenderer); renderer: WebGLRenderer; count: number; checkCount: number; maxIdle: number; checkCountMax: number; mode: number; update(): void; run(): void; unload(): void; } abstract class ObjectRenderer extends WebGLManager { constructor(renderer: WebGLRenderer); start(): void; stop(): void; flush(): void; render(...args: any[]): void; } class Quad { constructor(gl: WebGLRenderingContext); gl: WebGLRenderingContext; vertices: number[]; uvs: number[]; interleaved: number[]; indices: number[]; vertexBuffer: WebGLBuffer; vao: glCore.VertexArrayObject; initVao(shader: glCore.GLShader): void; map(targetTextureFrame: Rectangle, destinationFrame: Rectangle): Quad; upload(): Quad; destroy(): void; } interface FilterDataStackItem { renderTarget: RenderTarget; filter: any[]; bounds: Rectangle; } class RenderTarget { constructor(gl: WebGLRenderingContext, width: number, height: number, scaleMode: number, resolution: number, root?: boolean); gl: WebGLRenderingContext; frameBuffer: glCore.GLFramebuffer; texture: Texture; clearColor: number[]; size: Rectangle; resolution: number; projectionMatrix: Matrix; transform: Matrix; frame: Rectangle; defaultFrame: Rectangle; destinationFrame: Rectangle; sourceFrame?: Rectangle; stencilBuffer: glCore.GLFramebuffer; stencilMaskStack: Graphics[]; filterData: { index: number, stack: FilterDataStackItem[]; }; scaleMode: number; root: boolean; clear(clearColor?: number[]): void; attachStencilBuffer(): void; setFrame(destinationFrame: Rectangle, sourceFrame: Rectangle): void; activate(): void; calculateProjection(destinationFrame: Rectangle, sourceFrame: Rectangle): void; resize(width: number, height: number): void; destroy(): void; } class BlendModeManager extends WebGLManager { constructor(renderer: WebGLRenderer); currentBlendMode: number; setBlendMode(blendMode: number): boolean; } interface FilterManagerStackItem { renderTarget: RenderTarget; sourceFrame: Rectangle; destinationFrame: Rectangle; filters: Filter[]; target: any; resolution: number; } class FilterManager extends WebGLManager { constructor(renderer: WebGLRenderer); gl: WebGLRenderingContext; quad: Quad; stack: FilterManagerStackItem[]; stackIndex: number; shaderCache: any; filterData: any; pushFilter(target: RenderTarget, filters: Filter[]): void; popFilter(): void; applyFilter(shader: glCore.GLShader | Filter, inputTarget: RenderTarget, outputTarget: RenderTarget, clear?: boolean): void; syncUniforms(shader: glCore.GLShader, filter: Filter): void; getRenderTarget(clear?: boolean, resolution?: number): RenderTarget; returnRenderTarget(renderTarget: RenderTarget): RenderTarget; calculateScreenSpaceMatrix(outputMatrix: Matrix): Matrix; calculateNormalizedScreenSpaceMatrix(outputMatrix: Matrix): Matrix; calculateSpriteMatrix(outputMatrix: Matrix, sprite: Sprite): Matrix; destroy(): void; emptyPool(): void; getPotRenderTarget(gl: WebGLRenderingContext, minWidth: number, minHeight: number, resolution: number): RenderTarget; freePotRenderTarget(renderTarget: RenderTarget): void; } class StencilMaskStack { stencilStack: any[]; reverse: boolean; count: number; } class MaskManager extends WebGLManager { scissor: boolean; scissorData: any; scissorRenderTarget: RenderTarget; enableScissor: boolean; alphaMaskPool: number[]; alphaMaskIndex: number; pushMask(target: RenderTarget, maskData: Sprite | Graphics): void; popMask(target: RenderTarget, maskData: Sprite | Graphics): void; pushSpriteMask(target: RenderTarget, maskData: Sprite | Graphics): void; popSpriteMask(): void; pushStencilMask(maskData: Sprite | Graphics): void; popStencilMask(): void; pushScissorMask(target: RenderTarget, maskData: Sprite | Graphics): void; popScissorMask(): void; } class StencilManager extends WebGLManager { constructor(renderer: WebGLRenderer); stencilMaskStack: Graphics[]; setMaskStack(stencilMasStack: Graphics[]): void; pushStencil(graphics: Graphics): void; popStencil(): void; destroy(): void; } class WebGLManager { constructor(renderer: WebGLRenderer); renderer: SystemRenderer; onContextChange(): void; destroy(): void; } interface UniformData { type: string; value: any; // name is set by pixi if uniforms were automatically extracted from shader code, but not used anywhere name?: string; } class Filter { constructor(vertexSrc?: string, fragmentSrc?: string, uniforms?: { [name: string]: UniformData }); vertextSrc?: string; fragmentSrc: string; blendMode: number; protected uniformData: { [name: string]: UniformData }; uniforms: { [name: string]: any } | any; glShaders: any; glShaderKey?: number; padding: number; resolution: number; enabled: boolean; autoFit: boolean; apply(filterManager: FilterManager, input: RenderTarget, output: RenderTarget, clear?: boolean, currentState?: any): void; static defaultVertexSrc: string; static defaultFragmentSrc: string; } class SpriteMaskFilter extends Filter { constructor(sprite: Sprite); maskSprite: Sprite; maskMatrix: Matrix; apply(filterManager: FilterManager, input: RenderTarget, output: RenderTarget): void; } // sprites class Sprite extends Container { constructor(texture?: Texture); protected _anchor: ObservablePoint; anchor: ObservablePoint; protected _texture: Texture; protected _transformTrimmedID: number; protected _textureTrimmedID: number; protected _width: number; protected _height: number; tint: number; protected _tint: number; protected _tintRGB: number; blendMode: number; pluginName: string; protected cachedTint: number; texture: Texture; protected textureDirty: boolean; protected _textureID: number; protected _transformID: number; protected vertexTrimmedData: Float32Array; vertexData: Float32Array; width: number; height: number; protected _onTextureUpdate(): void; calculateVertices(): void; protected _calculateBounds(): void; protected calculateTrimmedVertices(): void; protected onAnchorUpdate(): void; protected _renderWebGL(renderer: WebGLRenderer): void; protected _renderCanvas(renderer: CanvasRenderer): void; getLocalBounds(): Rectangle; containsPoint(point: Point): boolean; destroy(options?: DestroyOptions | boolean): void; static from(source: number | string | BaseTexture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement): Sprite; static fromFrame(frameId: string): Sprite; static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite; } class BatchBuffer { vertices: ArrayBuffer; float32View: number[]; uint32View: number[]; destroy(): void; } class SpriteRenderer extends ObjectRenderer { constructor(renderer: PIXI.WebGLRenderer); vertSize: number; vertByteSize: number; size: number; buffers: BatchBuffer[]; indices: number[]; shaders: Shader[]; currentIndex: number; tick: number; groups: any[]; sprites: Sprite[]; vertexBuffers: number[]; vaos: glCore.VertexArrayObject[]; vaoMax: number; vertexCount: number; protected onContextChanged: () => void; protected onPrerender: () => void; render(sprite: Sprite): void; flush(): void; start(): void; stop(): void; destroy(): void; } class CanvasSpriteRenderer extends ObjectRenderer { constructor(renderer: WebGLRenderer); render(sprite: Sprite): void; destroy(): void; } namespace CanvasTinter { function getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement; function tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void; function tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void; function tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void; function roundColor(color: number): number; let cacheStepsPerColorChannel: number; let convertTintToImage: boolean; let canUseMultiply: boolean; let tintMethod: number; } // text interface TextStyleOptions { align?: string; breakWords?: boolean; dropShadow?: boolean; dropShadowAlpha?: number; dropShadowAngle?: number; dropShadowBlur?: number; dropShadowColor?: string | number; dropShadowDistance?: number; fill?: string | string[] | number | number[] | CanvasGradient | CanvasPattern; fillGradientType?: number; fillGradientStops?: number[]; fontFamily?: string | string[]; fontSize?: number | string; fontStyle?: string; fontVariant?: string; fontWeight?: string; letterSpacing?: number; lineHeight?: number; lineJoin?: string; miterLimit?: number; padding?: number; stroke?: string | number; strokeThickness?: number; textBaseline?: string; trim?: boolean; wordWrap?: boolean; wordWrapWidth?: number; } class TextStyle implements TextStyleOptions { constructor(style: TextStyleOptions) styleID: number; clone(): TextStyle; reset(): void; protected _align: string; align: string; protected _breakWords: boolean; breakWords: boolean; protected _dropShadow: boolean; dropShadow: boolean; protected _dropShadowAlpha: number; dropShadowAlpha: number; protected _dropShadowAngle: number; dropShadowAngle: number; protected _dropShadowBlur: number; dropShadowBlur: number; protected _dropShadowColor: string | number; dropShadowColor: string | number; protected _dropShadowDistance: number; dropShadowDistance: number; protected _fill: string | string[] | number | number[] | CanvasGradient | CanvasPattern; fill: string | string[] | number | number[] | CanvasGradient | CanvasPattern; protected _fillGradientType: number; fillGradientType: number; protected _fillGradientStops: number[]; fillGradientStops: number[]; protected _fontFamily: string | string[]; fontFamily: string | string[]; protected _fontSize: number | string; fontSize: number | string; protected _fontStyle: string; fontStyle: string; protected _fontVariant: string; fontVariant: string; protected _fontWeight: string; fontWeight: string; protected _letterSpacing: number; letterSpacing: number; protected _lineHeight: number; lineHeight: number; protected _lineJoin: string; lineJoin: string; protected _miterLimit: number; miterLimit: number; protected _padding: number; padding: number; protected _stroke: string | number; stroke: string | number; protected _strokeThickness: number; strokeThickness: number; protected _textBaseline: string; textBaseline: string; protected _trim: boolean; trim: boolean; protected _wordWrap: boolean; wordWrap: boolean; protected _wordWrapWidth: number; wordWrapWidth: number; toFontString(): string; } class TextMetrics { protected _canvas: HTMLCanvasElement; protected _context: CanvasRenderingContext2D; protected _fonts: FontMetrics; text: string; style: TextStyle; width: number; height: number; lines: number[]; lineWidgets: number[]; lineHeight: number; maxLineWidth: number; fontProperties: any; constructor(text: string, style: TextStyle, width: number, height: number, lines: number[], lineWidths: number[], lineHeight: number, maxLineWidth: number, fontProperties: any); static measureText(text: string, style: TextStyle, wordWrap?: boolean, canvas?: HTMLCanvasElement): TextMetrics; static wordWrap(text: string, style: TextStyle, canvas?: HTMLCanvasElement): string; static measureFont(font: string): FontMetrics; } interface FontMetrics { ascent: number; descent: number; fontSize: number; } class Text extends Sprite { constructor(text?: string, style?: TextStyleOptions, canvas?: HTMLCanvasElement); canvas: HTMLCanvasElement; context: CanvasRenderingContext2D; resolution: number; protected _text: string; protected _style: TextStyle; //tslint:disable-next-line:ban-types forbidden-types protected _styleListener: Function; protected _font: string; protected localStyleID: number; width: number; height: number; style: TextStyle; text: string; protected updateText(respectDirty?: boolean): void; protected drawLetterSpacing(text: string, x: number, y: number, isStroke?: boolean): void; protected updateTexture(): void; renderWebGL(renderer: WebGLRenderer): void; protected _renderCanvas(renderer: CanvasRenderer): void; getLocalBounds(rect?: Rectangle): Rectangle; protected _calculateBounds(): void; protected _onStyleChange: () => void; protected _generateFillStyle(style: TextStyle, lines: string[]): string | number | CanvasGradient; destroy(options?: DestroyOptions | boolean): void; dirty: boolean; } // textures class BaseRenderTexture extends BaseTexture { constructor(width?: number, height?: number, scaleMode?: number, resolution?: number); height: number; width: number; realHeight: number; realWidth: number; resolution: number; scaleMode: number; hasLoaded: boolean; protected _glRenderTargets: { [n: number]: WebGLTexture; }; protected _canvasRenderTarget: { [n: number]: WebGLTexture; }; valid: boolean; resize(width: number, height: number): void; destroy(): void; on(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this; once(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this; removeListener(event: "update", fn?: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this; removeAllListeners(event: "update"): this; off(event: "update", fn?: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this; addListener(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this; } class BaseTexture extends utils.EventEmitter { static from(source: string | HTMLImageElement | HTMLCanvasElement, scaleMode?: number, sourceScale?: number): BaseTexture; constructor(source?: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, scaleMode?: number, resolution?: number); protected uuid?: number; protected touched: number; resolution: number; width: number; height: number; realWidth: number; realHeight: number; scaleMode: number; hasLoaded: boolean; isLoading: boolean; wrapMode: number; source: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | null; origSource: HTMLImageElement | null; imageType: string | null; sourceScale: number; premultipliedAlpha: boolean; imageUrl: string | null; protected isPowerOfTwo: boolean; mipmap: boolean; wrap?: boolean; protected _glTextures: any; protected _enabled: number; protected _id?: number; protected _virtualBoundId: number; protected readonly _destroyed: boolean; textureCacheIds: string[]; update(): void; protected _updateDimensions(): void; protected _updateImageType(): void; protected _loadSvgSource(): void; protected _loadSvgSourceUsingDataUri(dataUri: string): void; protected _loadSvgSourceUsingXhr(): void; protected _loadSvgSourceUsingString(svgString: string): void; protected loadSource(source: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement): void; protected _sourceLoaded(): void; destroy(): void; dispose(): void; updateSourceImage(newSrc: string): void; static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: number, sourceScale?: number): BaseTexture; static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number, origin?: string): BaseTexture; static addToCache(baseTexture: BaseTexture, id: string): void; static removeFromCache(baseTexture: string | BaseTexture): BaseTexture; on(event: "update" | "loaded" | "error" | "dispose", fn: (baseTexture: BaseTexture) => void, context?: any): this; once(event: "update" | "loaded" | "error" | "dispose", fn: (baseTexture: BaseTexture) => void, context?: any): this; removeListener(event: "update" | "loaded" | "error" | "dispose", fn?: (baseTexture: BaseTexture) => void, context?: any): this; removeAllListeners(event: "update" | "loaded" | "error" | "dispose"): this; off(event: "update" | "loaded" | "error" | "dispose", fn?: (baseTexture: BaseTexture) => void, context?: any): this; addListener(event: "update" | "loaded" | "error" | "dispose", fn: (baseTexture: BaseTexture) => void, context?: any): this; } class RenderTexture extends Texture { constructor(baseRenderTexture: BaseRenderTexture, frame?: Rectangle); protected legacyRenderer: any; valid: boolean; resize(width: number, height: number, doNotResizeBaseTexture?: boolean): void; static create(width?: number, height?: number, scaleMode?: number, resolution?: number): RenderTexture; } class Texture extends utils.EventEmitter { constructor(baseTexture: BaseTexture, frame?: Rectangle, orig?: Rectangle, trim?: Rectangle, rotate?: number); noFrame: boolean; baseTexture: BaseTexture; protected _frame: Rectangle; trim?: Rectangle; valid: boolean; requiresUpdate: boolean; protected _uvs: TextureUvs; orig: Rectangle; protected _updateID: number; transform: any; textureCacheIds: string[]; update(): void; protected onBaseTextureLoaded(baseTexture: BaseTexture): void; protected onBaseTextureUpdated(baseTexture: BaseTexture): void; destroy(destroyBase?: boolean): void; clone(): Texture; protected _updateUvs(): void; static fromImage(imageUrl: string, crossOrigin?: boolean, scaleMode?: number, sourceScale?: number): Texture; static fromFrame(frameId: string): Texture; static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number, origin?: string): Texture; static fromVideo(video: HTMLVideoElement | string, scaleMode?: number): Texture; static fromVideoUrl(videoUrl: string, scaleMode?: number): Texture; static from(source: number | string | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | BaseTexture): Texture; static fromLoader(source: HTMLImageElement | HTMLCanvasElement, imageUrl: string, name?: string): Texture; static addToCache(texture: Texture, id: string): void; static removeFromCache(texture: string | Texture): Texture; // depreciation static addTextureToCache(texture: Texture, id: string): void; static removeTextureFromCache(id: string): Texture; frame: Rectangle; protected _rotate: boolean | 0; rotate: number; width: number; height: number; static EMPTY: Texture; static WHITE: Texture; on(event: "update", fn: (texture: Texture) => void, context?: any): this; once(event: "update", fn: (texture: Texture) => void, context?: any): this; removeListener(event: "update", fn?: (texture: Texture) => void, context?: any): this; removeAllListeners(event: "update"): this; off(event: "update", fn?: (texture: Texture) => void, context?: any): this; addListener(event: "update", fn: (texture: Texture) => void, context?: any): this; } class TextureUvs { x0: number; y0: number; x1: number; y1: number; x2: number; y2: number; x3: number; y3: number; uvsUint32: Uint32Array; protected set(frame: Rectangle, baseFrame: Rectangle, rotate: number): void; } class Spritesheet { static BATCH_SIZE: number; constructor(baseTexture: BaseTexture, data: any, resolutionFilename?: string); baseTexture: BaseTexture; textures: { [key: string]: Texture; }; data: any; resolution: number; protected _frames: any; protected _frameKeys: string; protected _batchIndex: number; protected _callback: (spriteSheet: this, textures: { [key: string]: Texture; }) => void; protected _updateResolution(resolutionFilename: string): number; parse(callback: (spriteSheet: this, textures: { [key: string]: Texture; }) => void): void; protected _processFrames(initialFrameIndex: number): void; protected _parseComplete(): void; protected _nextBatch(): void; destroy(destroyBase?: boolean): void; } class VideoBaseTexture extends BaseTexture { constructor(source: HTMLVideoElement, scaleMode?: number); autoUpdate: boolean; autoPlay: boolean; protected _isAutoUpdating: boolean; update(): void; protected _onCanPlay(): void; protected _onPlayStart(): void; protected _onPlayStop(): void; destroy(): void; protected _isSourcePlaying(): boolean; protected _isSourceReady(): boolean; static fromVideo(video: HTMLVideoElement, scaleMode?: number): VideoBaseTexture; static fromUrl(videoSrc: string | any | string[] | any[]): VideoBaseTexture; static fromUrls(videoSrc: string | any | string[] | any[]): VideoBaseTexture; source: HTMLVideoElement; protected loadSource(source: HTMLVideoElement): void; } // ticker namespace ticker { const shared: Ticker; class TickerListener { constructor(fn: (deltaTime: number) => void, context?: any, priority?: number, once?: boolean); fn: (deltaTime: number) => void; context: any; priority: number; once: boolean; next: TickerListener; previous: TickerListener; protected _destroyed: boolean; match(fn: (deltaTime: number) => void, context?: any): boolean; emit(deltaTime: number): TickerListener; connect(previous: TickerListener): void; destroy(hard?: boolean): void; } class Ticker { protected _tick: (time: number) => void; protected _head: TickerListener; protected _requestId: number | null; protected _maxElapsedMS: number; autoStart: boolean; deltaTime: number; elapsedMS: number; lastTime: number; speed: number; started: boolean; protected _requestIfNeeded(): void; protected _cancelIfNeeded(): void; protected _startIfPossible(): void; add(fn: (deltaTime: number) => void, context?: any, priority?: number): Ticker; addOnce(fn: (deltaTime: number) => void, context?: any, priority?: number): Ticker; //tslint:disable-next-line:ban-types forbidden-types remove(fn: Function, context?: any, priority?: number): Ticker; protected _addListener(listener: TickerListener): Ticker; readonly FPS: number; minFPS: number; start(): void; stop(): void; destroy(): void; update(currentTime?: number): void; } } // shader class Shader extends glCore.GLShader { } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////EXTRACT/////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace extract { class CanvasExtract { protected renderer: CanvasRenderer; constructor(renderer: CanvasRenderer); image(target?: DisplayObject | RenderTexture): HTMLImageElement; base64(target?: DisplayObject | RenderTexture): string; canvas(target?: DisplayObject | RenderTexture): HTMLCanvasElement; pixels(renderTexture?: DisplayObject | RenderTexture): number[]; destroy(): void; } class WebGLExtract { protected renderer: WebGLRenderer; constructor(renderer: WebGLRenderer); image(target?: DisplayObject | RenderTexture): HTMLImageElement; base64(target?: DisplayObject | RenderTexture): string; canvas(target?: DisplayObject | RenderTexture): HTMLCanvasElement; pixels(renderTexture?: DisplayObject | RenderTexture): number[]; destroy(): void; } } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////EXTRAS//////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace extras { interface BitmapTextStyle { font?: string | { name?: string; size?: number; }; align?: string; tint?: number; } class BitmapText extends Container { static registerFont(xml: XMLDocument, texture: Texture): any; constructor(text: string, style?: BitmapTextStyle); protected _textWidth: number; protected _textHeight: number; textWidth: number; textHeight: number; protected _glyphs: Sprite[]; protected _font: string | { name?: string; size?: number; }; font: string | { name?: string; size?: number; }; protected _text: string; protected _maxWidth: number; maxWidth: number; protected _maxLineHeight: number; maxLineHeight: number; protected _anchor: ObservablePoint; dirty: boolean; tint: number; align: string; text: string; anchor: PIXI.Point | number; protected updateText(): void; updateTransform(): void; getLocalBounds(): Rectangle; protected validate(): void; static fonts: any; } interface AnimatedSpriteTextureTimeObject { texture: Texture; time?: number; } class AnimatedSprite extends Sprite { constructor(textures: Texture[] | AnimatedSpriteTextureTimeObject[], autoUpdate?: boolean); protected _autoUpdate: boolean; protected _textures: Texture[]; protected _durations: number[]; textures: Texture[] | AnimatedSpriteTextureTimeObject[]; animationSpeed: number; loop: boolean; onComplete: () => void; onFrameChange: (currentFrame: number) => void; onLoop: () => void; protected _currentTime: number; playing: boolean; totalFrames: number; currentFrame: number; stop(): void; play(): void; gotoAndStop(frameNumber: number): void; gotoAndPlay(frameNumber: number): void; protected update(deltaTime: number): void; destroy(options?: DestroyOptions | boolean): void; static fromFrames(frame: string[]): AnimatedSprite; static fromImages(images: string[]): AnimatedSprite; } class TextureTransform { constructor(texture: Texture, clampMargin?: number); protected _texture: Texture; protected mapCoord: Matrix; protected uClampFrame: Float32Array; protected uClampOffset: Float32Array; protected _lastTextureID: number; clampOffset: number; clampMargin: number; texture: Texture; update(forceUpdate?: boolean): boolean; } class TilingSprite extends Sprite { constructor(texture: Texture, width?: number, height?: number); tileTransform: TransformStatic; protected _width: number; protected _height: number; protected _canvasPattern: CanvasPattern; uvTransform: TextureTransform; uvRespectAnchor: boolean; clampMargin: number; tileScale: Point | ObservablePoint; tilePosition: Point | ObservablePoint; multiplyUvs(uvs: Float32Array, out: Float32Array): Float32Array; protected _onTextureUpdate(): void; protected _renderWebGL(renderer: WebGLRenderer): void; protected _renderCanvas(renderer: CanvasRenderer): void; protected _calculateBounds(): void; getLocalBounds(rect?: Rectangle): Rectangle; containsPoint(point: Point): boolean; destroy(options?: DestroyOptions | boolean): void; static from(source: number | string | BaseTexture | HTMLCanvasElement | HTMLVideoElement, width?: number, height?: number): TilingSprite; static fromFrame(frameId: string, width?: number, height?: number): TilingSprite; // if you remove the next line, the class will break. https://github.com/pixijs/pixi-typescript/issues/96 static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite; static fromImage(imageId: string, width?: number, height?: number, crossorigin?: boolean, scaleMode?: number): TilingSprite; width: number; height: number; } class TilingSpriteRenderer extends ObjectRenderer { constructor(renderer: WebGLRenderer); render(ts: TilingSprite): void; } } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////FILTERS/////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace filters { class FXAAFilter extends Filter { } class BlurFilter extends Filter { constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number); blurXFilter: BlurXFilter; blurYFilter: BlurYFilter; resolution: number; padding: number; passes: number; blur: number; blurX: number; blurY: number; quality: number; } class BlurXFilter extends Filter { constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number); protected _quality: number; quality: number; passes: number; resolution: number; strength: number; firstRun: boolean; blur: number; } class BlurYFilter extends Filter { constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number); protected _quality: number; quality: number; passes: number; resolution: number; strength: number; firstRun: boolean; blur: number; } class ColorMatrixFilter extends Filter { constructor(); protected _loadMatrix(matrix: number[], multiply?: boolean): void; protected _multiply(out: number[], a: number[], b: number[]): void; protected _colorMatrix(matrix: number[]): void; matrix: number[]; alpha: number; brightness(b: number, multiply?: boolean): void; greyscale(scale: number, multiply?: boolean): void; blackAndWhite(multiply?: boolean): void; hue(rotation: number, multiply?: boolean): void; contrast(amount: number, multiply?: boolean): void; saturate(amount: number, multiply?: boolean): void; desaturate(multiply?: boolean): void; negative(multiply?: boolean): void; sepia(multiply?: boolean): void; technicolor(multiply?: boolean): void; polaroid(multiply?: boolean): void; toBGR(multiply?: boolean): void; kodachrome(multiply?: boolean): void; browni(multiply?: boolean): void; vintage(multiply?: boolean): void; colorTone(desaturation: number, toned: number, lightColor: string, darkColor: string, multiply?: boolean): void; night(intensity: number, multiply?: boolean): void; predator(amount: number, multiply?: boolean): void; lsd(multiply?: boolean): void; reset(): void; } class DisplacementFilter extends Filter { constructor(sprite: Sprite, scale?: number); scale: Point; map: Texture; } class VoidFilter extends Filter { glShaderKey: number; } // pixi-filters.d.ts todo // https://github.com/pixijs/pixi-filters/ class NoiseFilter extends Filter { constructor(noise?: number, seed?: number); noise: number; seed: number; } } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////INTERACTION/////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace interaction { interface InteractiveTarget { interactive: boolean; interactiveChildren: boolean; hitArea: PIXI.Rectangle | PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.RoundedRectangle; buttonMode: boolean; cursor: string; trackedPointers(): { [key: number]: InteractionTrackingData; }; // depricated defaultCursor: string; } interface InteractionTrackingData { readonly pointerId: number; flags: number; none: number; over: boolean; rightDown: boolean; leftDown: boolean; } interface InteractionEvent { stopped: boolean; target: DisplayObject; currentTarget: DisplayObject; type: string; data: InteractionData; stopPropagation(): void; } class InteractionData { global: Point; target: DisplayObject; originalEvent: MouseEvent | TouchEvent | PointerEvent; identifier: number; isPrimary: boolean; button: number; buttons: number; width: number; height: number; tiltX: number; tiltY: number; pointerType: string; pressure: number; rotationAngle: number; twist: number; tangentialPressure: number; readonly pointerID: number; protected _copyEvent(event: Touch | MouseEvent | PointerEvent): void; protected _reset(): void; getLocalPosition(displayObject: DisplayObject, point?: Point, globalPos?: Point): Point; } type InteractionPointerEvents = "pointerdown" | "pointercancel" | "pointerup" | "pointertap" | "pointerupoutside" | "pointermove" | "pointerover" | "pointerout"; type InteractionTouchEvents = "touchstart" | "touchcancel" | "touchend" | "touchendoutside" | "touchmove" | "tap"; type InteractionMouseEvents = "rightdown" | "mousedown" | "rightup" | "mouseup" | "rightclick" | "click" | "rightupoutside" | "mouseupoutside" | "mousemove" | "mouseover" | "mouseout" | "mouseover"; type InteractionEventTypes = InteractionPointerEvents | InteractionTouchEvents | InteractionMouseEvents; interface InteractionManagerOptions { autoPreventDefault?: boolean; interactionFrequency?: number; } class InteractionManager extends utils.EventEmitter { constructor(renderer: CanvasRenderer | WebGLRenderer | SystemRenderer, options?: InteractionManagerOptions); renderer: SystemRenderer; autoPreventDefault: boolean; interactionFrequency: number; mouse: InteractionData; activeInteractionData: { [key: number]: InteractionData; }; interactionDataPool: InteractionData[]; eventData: InteractionEvent; protected interactionDOMElement: HTMLElement; moveWhenInside: boolean; eventsAdded: boolean; protected mouseOverRenderer: boolean; readonly supportsTouchEvents: boolean; readonly supportsPointerEvents: boolean; protected onPointerUp: (event: PointerEvent) => void; protected processPointerUp: (interactionEvent: InteractionEvent, displayObject: Container | PIXI.Sprite | PIXI.extras.TilingSprite, hit: boolean) => void; protected onPointerCancel: (event: PointerEvent) => void; protected processPointerCancel: (interactionEvent: InteractionEvent, displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite) => void; protected onPointerDown: (event: PointerEvent) => void; protected processPointerDown: (interactionEvent: InteractionEvent, displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite, hit: boolean) => void; protected onPointerMove: (event: PointerEvent) => void; protected processPointerMove: (interactionEvent: InteractionEvent, displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite, hit: boolean) => void; protected onPointerOut: (event: PointerEvent) => void; protected processPointerOverOut: (interactionEvent: InteractionEvent, displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite, hit: boolean) => void; protected onPointerOver: (event: PointerEvent) => void; cursorStyles: { default: string; pointer: string; }; currentCursorMode: string; cursor: string; protected _tempPoint: Point; resolution: number; hitTest(globalPoint: Point, root?: Container): DisplayObject; protected setTargetElement(element: HTMLCanvasElement, resolution?: number): void; protected addEvents(): void; protected removeEvents(): void; update(deltaTime?: number): void; setCursorMode(mode: string): void; protected dispatchEvent(displayObject: Container | Sprite | extras.TilingSprite, eventString: string, eventData: any): void; mapPositionToPoint(point: Point, x: number, y: number): void; //tslint:disable-next-line:ban-types forbidden-types protected processInteractive( interactionEvent: InteractionEvent, displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite, func?: Function, hitTest?: boolean, interactive?: boolean ): boolean; //tslint:disable-next-line:ban-types forbidden-types protected onPointerComplete( originalEvent: PointerEvent, cancelled: boolean, func: Function ): void; protected getInteractionDataForPointerId(pointerId: number): InteractionData; protected releaseInteractionDataForPointerId(event: PointerEvent): void; protected configureInteractionEventForDOMEvent(interactionEvent: InteractionEvent, pointerEvent: PointerEvent, interactionData: InteractionData): InteractionEvent; protected normalizeToPointerData(event: TouchEvent | MouseEvent | PointerEvent): PointerEvent[]; destroy(): void; // depricated defaultCursorStyle: string; currentCursorStyle: string; } } ////////////////////////////////////////////////////////////////////////////// ///////////////////////////////LOADER///////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // pixi loader extends // https://github.com/englercj/resource-loader/ // 2.0.6 class MiniSignalBinding { //tslint:disable-next-line:ban-types forbidden-types constructor(fn: Function, once?: boolean, thisArg?: any); //tslint:disable-next-line:ban-types forbidden-types protected _fn: Function; protected _once: boolean; protected _thisArg: any; protected _next: MiniSignalBinding; protected _prev: MiniSignalBinding; protected _owner: MiniSignal; detach(): boolean; } class MiniSignal { constructor(); protected _head: MiniSignalBinding; protected _tail: MiniSignalBinding; handlers(exists?: boolean): MiniSignalBinding[] | boolean; handlers(exists?: true): boolean; handlers(exists?: false): MiniSignalBinding[]; has(node: MiniSignalBinding): boolean; dispatch(): boolean; //tslint:disable-next-line:ban-types forbidden-types add(fn: Function, thisArg?: any): any; //tslint:disable-next-line:ban-types forbidden-types once(fn: Function, thisArg?: any): any; detach(node: MiniSignalBinding): MiniSignal; detachAll(): MiniSignal; } namespace loaders { interface LoaderOptions { crossOrigin?: boolean | string; loadType?: number; xhrType?: string; metaData?: any; loadElement?: HTMLImageElement | HTMLAudioElement | HTMLVideoElement; skipSource?: boolean; } interface ResourceDictionary { [index: string]: PIXI.loaders.Resource; } // As of ResourceLoader v2 we no longer require EventEmitter // However, for depreciation reasons, it remains. class Loader extends utils.EventEmitter { // pixi overrides here //tslint:disable-next-line:ban-types forbidden-types static addPixiMiddleware(fn: Function): void; // below this line is the original non-pixi loader static Resource: any; static async: any; static base64: any; constructor(baseUrl?: string, concurrency?: number); baseUrl: string; progress: number; loading: boolean; defaultQueryString: string; //tslint:disable-next-line:ban-types forbidden-types protected _beforeMiddleware: Function[]; //tslint:disable-next-line:ban-types forbidden-types protected _afterMiddleware: Function[]; protected _resourcesParsing: Resource[]; //tslint:disable-next-line:ban-types forbidden-types protected _boundLoadResource: (r: Resource, d: Function) => void; protected _queue: any; resources: ResourceDictionary; onProgress: MiniSignal; onError: MiniSignal; onLoad: MiniSignal; onStart: MiniSignal; onComplete: MiniSignal; add(...params: any[]): this; //tslint:disable-next-line:ban-types forbidden-types add(name: string, url: string, options?: LoaderOptions, cb?: Function): this; //tslint:disable-next-line:ban-types forbidden-types add(obj: string | any | any[], options?: LoaderOptions, cb?: Function): this; //tslint:disable-next-line:ban-types forbidden-types pre(fn: Function): this; //tslint:disable-next-line:ban-types forbidden-types use(fn: Function): this; reset(): this; //tslint:disable-next-line:ban-types forbidden-types load(cb?: Function): this; protected _prepareUrl(url: string): string; //tslint:disable-next-line:ban-types forbidden-types protected _loadResource(resource: Resource, dequeue: Function): void; protected _onComplete(): void; protected _onLoad(resource: Resource): void; destroy(): void; // depreciation on(event: "complete", fn: (loader: loaders.Loader, object: any) => void, context?: any): this; on(event: "error", fn: (error: Error, loader: loaders.Loader, resource: Resource) => void, context?: any): this; on(event: "load" | "progress", fn: (loader: loaders.Loader, resource: Resource) => void, context?: any): this; on(event: "start", fn: (loader: loaders.Loader) => void, context?: any): this; once(event: "complete", fn: (loader: loaders.Loader, object: any) => void, context?: any): this; once(event: "error", fn: (error: Error, loader: loaders.Loader, resource: Resource) => void, context?: any): this; once(event: "load" | "progress", fn: (loader: loaders.Loader, resource: Resource) => void, context?: any): this; once(event: "start", fn: (loader: loaders.Loader) => void, context?: any): this; //tslint:disable-next-line:ban-types forbidden-types off(event: "complete" | "error" | "load" | "progress" | "start" | string, fn?: Function, context?: any): this; } interface TextureDictionary { [index: string]: PIXI.Texture; } class Resource { static setExtensionLoadType(extname: string, loadType: number): void; static setExtensionXhrType(extname: string, xhrType: string): void; constructor(name: string, url: string | string[], options?: LoaderOptions); protected _flags: number; name: string; url: string; extension: string; data: any; crossOrigin: boolean | string; loadType: number; xhrType: string; metadata: any; error: Error; xhr: XMLHttpRequest | null; children: Resource[]; type: number; progressChunk: number; //tslint:disable-next-line:ban-types forbidden-types protected _dequeue: Function; //tslint:disable-next-line:ban-types forbidden-types protected _onLoadBinding: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundComplete: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundOnError: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundOnProgress: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundXhrOnError: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundXhrOnAbort: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundXhrOnLoad: Function; //tslint:disable-next-line:ban-types forbidden-types protected _boundXdrOnTimeout: Function; onStart: MiniSignal; onProgress: MiniSignal; onComplete: MiniSignal; onAfterMiddleware: MiniSignal; isDataUrl: boolean; isComplete: boolean; isLoading: boolean; complete(): void; abort(message?: string): void; //tslint:disable-next-line:ban-types forbidden-types load(cb?: Function): void; protected _hasFlag(flag: number): boolean; protected _setFlag(flag: number, value: boolean): void; protected _loadElement(type: string): void; protected _loadSourceElement(type: string): void; protected _loadXhr(): void; protected _loadXdr(): void; protected _createSource(type: string, url: string, mime?: string): HTMLSourceElement; protected _onError(event?: any): void; protected _onProgress(event?: any): void; protected _xhrOnError(): void; protected _xhrOnAbort(): void; protected _xdrOnTimeout(): void; protected _xhrOnLoad(): void; protected _determineCrossOrigin(url: string, loc: any): string; protected _determineXhrType(): number; protected _determineLoadType(): number; protected _getExtension(): string; protected _getMimeXhrType(type: number): string; static STATUS_FLAGS: { NONE: number; DATA_URL: number; COMPLETE: number; LOADING: number; }; static TYPE: { UNKNOWN: number; JSON: number; XML: number; IMAGE: number; AUDIO: number; VIDEO: number; TEXT: number; }; static LOAD_TYPE: { XHR: number; IMAGE: number; AUDIO: number; VIDEO: number; }; static XHR_RESPONSE_TYPE: { DEFAULT: string; BUFFER: string; BLOB: string; DOCUMENT: string; JSON: string; TEXT: string; }; static EMPTY_GIF: string; texture: Texture; spineAtlas: any; spineData: any; textures?: TextureDictionary; } } ////////////////////////////////////////////////////////////////////////////// ///////////////////////////////MESH/////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace mesh { class Mesh extends Container { constructor(texture: Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number); protected _texture: Texture; uvs: Float32Array; vertices: Float32Array; indices: Uint16Array; dirty: number; indexDirty: number; dirtyVertex: boolean; protected _geometryVersion: number; blendMode: number; pluginName: string; canvasPadding: number; drawMode: number; texture: Texture; tintRgb: Float32Array; protected _glDatas: { [n: number]: any; }; protected _uvTransform: extras.TextureTransform; uploadUvTransform: boolean; multiplyUvs(): void; refresh(forceUpdate?: boolean): void; protected _refresh(): void; protected _renderWebGL(renderer: WebGLRenderer): void; protected _renderCanvas(renderer: CanvasRenderer): void; protected _onTextureUpdate(): void; protected _calculateBounds(): void; containsPoint(point: Point): boolean; tint: number; static DRAW_MODES: { TRIANGLE_MESH: number; TRIANGLES: number; }; } class CanvasMeshRenderer { constructor(renderer: CanvasRenderer); renderer: CanvasRenderer; render(mesh: Mesh): void; protected _renderTriangleMesh(mesh: Mesh): void; protected _renderTriangles(mesh: Mesh): void; protected _renderDrawTriangle(mesh: Mesh, index0: number, index1: number, index2: number): void; protected renderMeshFlat(mesh: Mesh): void; destroy(): void; } class MeshRenderer extends ObjectRenderer { constructor(renderer: WebGLRenderer); shader: Shader; render(mesh: Mesh): void; } class Plane extends Mesh { constructor(texture: Texture, verticesX?: number, verticesY?: number); protected _ready: boolean; verticesX: number; verticesY: number; drawMode: number; refresh(): void; protected _onTexureUpdate(): void; } class NineSlicePlane extends Plane { constructor(texture: Texture, leftWidth?: number, topHeight?: number, rightWidth?: number, bottomHeight?: number); width: number; height: number; leftWidth: number; rightWidth: number; topHeight: number; bottomHeight: number; protected _leftWidth: number; protected _rightWidth: number; protected _topHeight: number; protected _bottomHeight: number; protected _height: number; protected _width: number; protected _origHeight: number; protected _origWidth: number; protected _uvh: number; protected _uvw: number; updateHorizontalVertices(): void; updateVerticalVertices(): void; protected drawSegment(context: CanvasRenderingContext2D | WebGLRenderingContext, textureSource: any, w: number, h: number, x1: number, y1: number, x2: number, y2: number): void; protected _refresh(): void; } class Rope extends Mesh { constructor(texture: Texture, points: Point[]); points: Point[]; colors: number[]; autoUpdate: boolean; protected _refresh(): void; refreshVertices(): void; } } ////////////////////////////////////////////////////////////////////////////// /////////////////////////////PARTICLES//////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace particles { interface ParticleContainerProperties { scale?: boolean; position?: boolean; rotation?: boolean; uvs?: boolean; alpha?: boolean; } class ParticleContainer extends Container { constructor(size?: number, properties?: ParticleContainerProperties, batchSize?: number); protected _tint: number; protected tintRgb: number | any[]; tint: number; protected _properties: boolean[]; protected _maxSize: number; protected _batchSize: number; protected _glBuffers: { [n: number]: WebGLBuffer; }; protected _bufferToUpdate: number; interactiveChildren: boolean; blendMode: number; roundPixels: boolean; baseTexture: BaseTexture; setProperties(properties: ParticleContainerProperties): void; protected onChildrenChange: (smallestChildIndex?: number) => void; destroy(options?: DestroyOptions | boolean): void; } class ParticleBuffer { constructor(gl: WebGLRenderingContext, properties: any, dynamicPropertyFlags: any[], size: number); gl: WebGLRenderingContext; vertSize: number; vertByteSize: number; size: number; dynamicProperties: any[]; staticProperties: any[]; staticStride: number; staticBuffer: any; staticData: any; dynamicStride: number; dynamicBuffer: any; dynamicData: any; destroy(): void; } interface ParticleRendererProperty { attribute: number; size: number; uploadFunction(children: PIXI.DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; offset: number; } class ParticleRenderer extends ObjectRenderer { constructor(renderer: WebGLRenderer); shader: glCore.GLShader; indexBuffer: WebGLBuffer; properties: ParticleRendererProperty[]; protected tempMatrix: Matrix; start(): void; generateBuffers(container: ParticleContainer): ParticleBuffer[]; uploadVertices(children: DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; uploadPosition(children: DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; uploadRotation(children: DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; uploadUvs(children: DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; uploadAlpha(children: DisplayObject[], startIndex: number, amount: number, array: number[], stride: number, offset: number): void; destroy(): void; indices: Uint16Array; } } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////PREPARE/////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// namespace prepare { type AddHook = (item: any, queue: any[]) => boolean; type UploadHook = (prepare: UploadHookSource, item: any) => boolean; abstract class BasePrepare{ constructor(renderer: SystemRenderer); limiter: CountLimiter | TimeLimiter; protected renderer: SystemRenderer; protected uploadHookHelper: UploadHookSource; protected queue: any[]; protected addHooks: AddHook[]; protected uploadHooks: Array>; //tslint:disable-next-line:ban-types forbidden-types protected completes: Function[]; protected ticking: boolean; protected delayedTick: () => void; //tslint:disable-next-line:ban-types forbidden-types upload(item: Function | DisplayObject | Container | BaseTexture | Texture | Graphics | Text | any, done?: () => void): void; protected tick(): void; protected prepareItems(): void; registerFindHook(addHook: AddHook): this; registerUploadHook(uploadHook: UploadHook): this; protected findMultipleBaseTextures(item: PIXI.DisplayObject, queue: any[]): boolean; protected findBaseTexture(item: PIXI.DisplayObject, queue: any[]): boolean; protected findTexture(item: PIXI.DisplayObject, queue: any[]): boolean; add(item: PIXI.DisplayObject | PIXI.Container | PIXI.BaseTexture | PIXI.Texture | PIXI.Graphics | PIXI.Text | any): this; destroy(): void; } class CanvasPrepare extends BasePrepare { constructor(renderer: CanvasRenderer); protected canvas: HTMLCanvasElement; protected ctx: CanvasRenderingContext2D; } class WebGLPrepare extends BasePrepare { constructor(renderer: WebGLRenderer); } class CountLimiter { constructor(maxItemsPerFrame: number); protected maxItemsPerFrame: number; protected itemsLeft: number; beginFrame(): void; allowedToUpload(): boolean; } class TimeLimiter { constructor(maxMilliseconds: number); protected maxMilliseconds: number; protected frameStart: number; beginFrame(): void; allowedToUpload(): boolean; } } ////////////////////////////////////////////////////////////////////////////// /////////////////////////////pixi-gl-core///////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // pixi-gl-core https://github.com/pixijs/pixi-gl-core // sharedArrayBuffer as a type is not available yet. // need to fully define what an `Attrib` is. namespace glCore { interface ContextOptions { /** * Boolean that indicates if the canvas contains an alpha buffer. */ alpha?: boolean; /** * Boolean that indicates that the drawing buffer has a depth buffer of at least 16 bits. */ depth?: boolean; /** * Boolean that indicates that the drawing buffer has a stencil buffer of at least 8 bits. */ stencil?: boolean; /** * Boolean that indicates whether or not to perform anti-aliasing. */ antialias?: boolean; /** * Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha. */ premultipliedAlpha?: boolean; /** * If the value is true the buffers will not be cleared and will preserve their values until cleared or overwritten by the author. */ preserveDrawingBuffer?: boolean; /** * Boolean that indicates if a context will be created if the system performance is low. */ failIfMajorPerformanceCaveat?: boolean; } function createContext(view: HTMLCanvasElement, options?: ContextOptions): WebGLRenderingContext; function setVertexAttribArrays(gl: WebGLRenderingContext, attribs: Attrib[], state?: WebGLState): WebGLRenderingContext | undefined; class GLBuffer { constructor(gl: WebGLRenderingContext, type: number, data: ArrayBuffer | ArrayBufferView | any, drawType: number); protected _updateID?: number; gl: WebGLRenderingContext; buffer: WebGLBuffer; type: number; drawType: number; data: ArrayBuffer | ArrayBufferView | any; upload(data: ArrayBuffer | ArrayBufferView | any, offset?: number, dontBind?: boolean): void; bind(): void; static createVertexBuffer(gl: WebGLRenderingContext, data: ArrayBuffer | ArrayBufferView | any, drawType: number): GLBuffer; static createIndexBuffer(gl: WebGLRenderingContext, data: ArrayBuffer | ArrayBufferView | any, drawType: number): GLBuffer; static create(gl: WebGLRenderingContext, type: number, data: ArrayBuffer | ArrayBufferView | any, drawType: number): GLBuffer; destroy(): void; } class GLFramebuffer { constructor(gl: WebGLRenderingContext, width: number, height: number); gl: WebGLRenderingContext; frameBuffer: WebGLFramebuffer; stencil: WebGLRenderbuffer; texture: GLTexture; width: number; height: number; enableTexture(texture: GLTexture): void; enableStencil(): void; clear(r: number, g: number, b: number, a: number): void; bind(): void; unbind(): void; resize(width: number, height: number): void; destroy(): void; static createRGBA(gl: WebGLRenderingContext, width: number, height: number, data: ArrayBuffer | ArrayBufferView | any): GLFramebuffer; static createFloat32(gl: WebGLRenderingContext, width: number, height: number, data: ArrayBuffer | ArrayBufferView | any): GLFramebuffer; } class GLShader { constructor(gl: WebGLRenderingContext, vertexSrc: string | string[], fragmentSrc: string | string[], precision?: string, attributeLocations?: { [key: string]: number }); gl: WebGLRenderingContext; program?: WebGLProgram | null; uniformData: any; uniforms: any; attributes: any; bind(): void; destroy(): void; } class GLTexture { constructor(gl: WebGLRenderingContext, width?: number, height?: number, format?: number, type?: number); gl: WebGLRenderingContext; texture: WebGLTexture; mipmap: boolean; premultiplyAlpha: boolean; width: number; height: number; format: number; type: number; upload(source: HTMLImageElement | ImageData | HTMLVideoElement | HTMLCanvasElement): void; uploadData(data: ArrayBuffer | ArrayBufferView, width: number, height: number): void; bind(location?: number): void; unbind(): void; minFilter(linear: boolean): void; magFilter(linear: boolean): void; enableMipmap(): void; enableLinearScaling(): void; enableNearestScaling(): void; enableWrapClamp(): void; enableWrapRepeat(): void; enableWrapMirrorRepeat(): void; destroy(): void; static fromSource(gl: WebGLRenderingContext, source: HTMLImageElement | ImageData | HTMLVideoElement | HTMLCanvasElement, premultipleAlpha?: boolean): GLTexture; static fromData(gl: WebGLRenderingContext, data: number[], width: number, height: number): GLTexture; } interface Attrib { attribute: { location: number; size: number; }; normalized: boolean; stride: number; start: number; buffer: ArrayBuffer; } interface WebGLRenderingContextAttribute { buffer: WebGLBuffer; attribute: any; type: number; normalized: boolean; stride: number; start: number; } interface AttribState { tempAttribState: Attrib[]; attribState: Attrib[]; } class VertexArrayObject { static FORCE_NATIVE: boolean; constructor(gl: WebGLRenderingContext, state: WebGLState); protected nativeVaoExtension: any; protected nativeState: AttribState; protected nativeVao: VertexArrayObject; gl: WebGLRenderingContext; attributes: Attrib[]; indexBuffer: GLBuffer; dirty: boolean; bind(): VertexArrayObject; unbind(): VertexArrayObject; activate(): VertexArrayObject; addAttribute(buffer: GLBuffer, attribute: Attrib, type: number, normalized: boolean, stride: number, start: number): VertexArrayObject; addIndex(buffer: GLBuffer, options?: any): VertexArrayObject; clear(): VertexArrayObject; draw(type: number, size: number, start: number): VertexArrayObject; destroy(): void; } } ////////////////////////////////////////////////////////////////////////////// ///////////////////////////////UTILS////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// interface DecomposedDataUri { mediaType: string; subType: string; encoding: string; data: any; } namespace utils { function uid(): number; function hex2rgb(hex: number, out?: number[]): number[]; function hex2string(hex: number): string; function rgb2hex(rgb: number[]): number; function canUseNewCanvasBlendModes(): boolean; function getResolutionOfUrl(url: string, defaultValue?: number): number; function getSvgSize(svgString: string): any; function decomposeDataUri(dataUri: string): DecomposedDataUri | void; function getUrlFileExtension(url: string): string | void; function sayHello(type: string): void; function skipHello(): void; function isWebGLSupported(): boolean; function sign(n: number): number; function removeItems(arr: T[], startIdx: number, removeCount: number): void; function correctBlendMode(blendMode: number, premultiplied: boolean): number; function premultiplyTint(tint: number, alpha: number): number; function premultiplyRgba(rgb: Float32Array | number[], alpha: number, out?: Float32Array, premultiply?: boolean): Float32Array; function premultiplyTintToRgba(tint: number, alpha: number, out?: Float32Array, premultiply?: boolean): Float32Array; const premultiplyBlendMode: number[][]; const TextureCache: any; const BaseTextureCache: any; // https://github.com/kaimallea/isMobile namespace isMobile { const apple: { phone: boolean; ipod: boolean; tablet: boolean; device: boolean; }; const android: { phone: boolean; tablet: boolean; device: boolean; }; const amazon: { phone: boolean; tablet: boolean; device: boolean; }; const windows: { phone: boolean; tablet: boolean; device: boolean; }; const seven_inch: boolean; const other: { blackberry10: boolean; blackberry: boolean; opera: boolean; firefox: boolean; chrome: boolean; device: boolean; }; const any: boolean; const phone: boolean; const tablet: boolean; } // https://github.com/primus/eventemitter3 class EventEmitter { static prefixed: string | boolean; static EventEmitter: { new(): EventEmitter; prefixed: string | boolean; }; /** * Minimal EventEmitter interface that is molded against the Node.js * EventEmitter interface. * * @constructor * @api public */ constructor(); /** * Return an array listing the events for which the emitter has registered listeners. * * @returns {(string | symbol)[]} */ eventNames(): Array<(string | symbol)>; /** * Return the listeners registered for a given event. * * @param {(string | symbol)} event The event name. * @returns {Function[]} */ //tslint:disable-next-line:ban-types forbidden-types listeners(event: string | symbol): Function[]; /** * Check if there listeners for a given event. * If `exists` argument is not `true` lists listeners. * * @param {(string | symbol)} event The event name. * @param {boolean} exists Only check if there are listeners. * @returns {boolean} */ listeners(event: string | symbol, exists: boolean): boolean; /** * Calls each of the listeners registered for a given event. * * @param {(string | symbol)} event The event name. * @param {...*} args Arguments that are passed to registered listeners * @returns {boolean} `true` if the event had listeners, else `false`. */ emit(event: string | symbol, ...args: any[]): boolean; /** * Add a listener for a given event. * * @param {(string | symbol)} event The event name. * @param {Function} fn The listener function. * @param {*} [context=this] The context to invoke the listener with. * @returns {EventEmitter} `this`. */ //tslint:disable-next-line:ban-types forbidden-types on(event: string | symbol, fn: Function, context?: any): this; /** * Add a one-time listener for a given event. * * @param {(string | symbol)} event The event name. * @param {Function} fn The listener function. * @param {*} [context=this] The context to invoke the listener with. * @returns {EventEmitter} `this`. */ //tslint:disable-next-line:ban-types forbidden-types once(event: string | symbol, fn: Function, context?: any): this; /** * Remove the listeners of a given event. * * @param {(string | symbol)} event The event name. * @param {Function} fn Only remove the listeners that match this function. * @param {*} context Only remove the listeners that have this context. * @param {boolean} once Only remove one-time listeners. * @returns {EventEmitter} `this`. */ //tslint:disable-next-line:ban-types forbidden-types removeListener(event: string | symbol, fn?: Function, context?: any, once?: boolean): this; /** * Remove all listeners, or those of the specified event. * * @param {(string | symbol)} event The event name. * @returns {EventEmitter} `this`. */ removeAllListeners(event?: string | symbol): this; /** * Alias method for `removeListener` */ //tslint:disable-next-line:ban-types forbidden-types off(event: string | symbol, fn?: Function, context?: any, once?: boolean): this; /** * Alias method for `on` */ //tslint:disable-next-line:ban-types forbidden-types addListener(event: string | symbol, fn: Function, context?: any): this; /** * This function doesn't apply anymore. * @deprecated */ setMaxListeners(): this; } } ////////////////////////////////////////////////////////////////////////////// /////////////////////////////depreciation///////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // not sure how to handle blendmodes scalemodes basetexturecache namespace core { /** * @class * @private * @name SpriteBatch * @memberof PIXI * @see PIXI.ParticleContainer * @throws {ReferenceError} SpriteBatch does not exist any more, please use the new ParticleContainer instead. * @deprecated since version 3.0.0 */ type SpriteBatch = ParticleContainer; /** * @class * @private * @name AssetLoader * @memberof PIXI * @see PIXI.loaders.Loader * @throws {ReferenceError} The loader system was overhauled in pixi v3, please see the new PIXI.loaders.Loader class. * @deprecated since version 3.0.0 */ type AssetLoader = loaders.Loader; /** * @class * @private * @name Stage * @memberof PIXI * @see PIXI.Container * @deprecated since version 3.0.0 */ type Stage = Container; /** * @class * @private * @name DisplayObjectContainer * @memberof PIXI * @see PIXI.Container * @deprecated since version 3.0.0 */ type DisplayObjectContainer = Container; /** * @class * @private * @name Strip * @memberof PIXI * @see PIXI.mesh.Mesh * @deprecated since version 3.0.0 */ type Strip = mesh.Mesh; /** * @class * @private * @name Rope * @memberof PIXI * @see PIXI.mesh.Rope * @deprecated since version 3.0.0 */ type Rope = mesh.Rope; /** * @class * @private * @name ParticleContainer * @memberof PIXI * @see PIXI.particles.ParticleContainer * @deprecated since version 4.0.0 */ type ParticleContainer = particles.ParticleContainer; /** * @class * @private * @name MovieClip * @memberof PIXI * @see PIXI.extras.MovieClip * @deprecated since version 3.0.0 */ type MovieClip = extras.AnimatedSprite; /** * @class * @private * @name TilingSprite * @memberof PIXI * @see PIXI.extras.TilingSprite * @deprecated since version 3.0.0 */ type TilingSprite = extras.TilingSprite; /** * @class * @private * @name BaseTextureCache * @memberof PIXI * @see PIXI.utils.BaseTextureCache * @deprecated since version 3.0.0 */ type BaseTextureCache = any; /** * @class * @private * @name BitmapText * @memberof PIXI * @see PIXI.extras.BitmapText * @deprecated since version 3.0.0 */ type BitmapText = extras.BitmapText; /** * @namespace * @private * @name math * @memberof PIXI * @see PIXI * @deprecated since version 3.0.6 */ type math = any; /** * @class * @private * @name PIXI.AbstractFilter * @see PIXI.Filter * @deprecated since version 3.0.6 */ type AbstractFilter = Filter; /** * @class * @private * @name PIXI.TransformManual * @see PIXI.TransformBase * @deprecated since version 4.0.0 */ type TransformManual = TransformBase; /** * @static * @constant * @name PIXI.TARGET_FPMS * @see PIXI.settings.TARGET_FPMS * @deprecated since version 4.2.0 */ type TARGET_FPMS = number; /** * @static * @constant * @name PIXI.FILTER_RESOLUTION * @see PIXI.settings.FILTER_RESOLUTION * @deprecated since version 4.2.0 */ type FILTER_RESOLUTION = number; /** * @static * @constant * @name PIXI.RESOLUTION * @see PIXI.settings.RESOLUTION * @deprecated since version 4.2.0 */ type RESOLUTION = number; /** * @static * @constant * @name PIXI.MIPMAP_TEXTURES * @see PIXI.settings.MIPMAP_TEXTURES * @deprecated since version 4.2.0 */ type MIPMAP_TEXTURES = any; /** * @static * @constant * @name PIXI.SPRITE_BATCH_SIZE * @see PIXI.settings.SPRITE_BATCH_SIZE * @deprecated since version 4.2.0 */ type SPRITE_BATCH_SIZE = number; /** * @static * @constant * @name PIXI.SPRITE_MAX_TEXTURES * @see PIXI.settings.SPRITE_MAX_TEXTURES * @deprecated since version 4.2.0 */ type SPRITE_MAX_TEXTURES = number; /** * @static * @constant * @name PIXI.RETINA_PREFIX * @see PIXI.settings.RETINA_PREFIX * @deprecated since version 4.2.0 */ type RETINA_PREFIX = RegExp | string; /** * @static * @constant * @name PIXI.DEFAULT_RENDER_OPTIONS * @see PIXI.settings.RENDER_OPTIONS * @deprecated since version 4.2.0 */ type DEFAULT_RENDER_OPTIONS = number; /** * @static * @name PRECISION * @memberof PIXI.settings * @see PIXI.PRECISION * @deprecated since version 4.4.0 */ type PRECISION = string; } namespace extras { /** * @class * @name MovieClip * @memberof PIXI.extras * @see PIXI.extras.AnimatedSprite * @deprecated since version 4.2.0 */ type MovieClip = extras.AnimatedSprite; } namespace settings { /** * @static * @name PRECISION * @memberof PIXI.settings * @see PIXI.PRECISION * @deprecated since version 4.4.0 */ type PRECISION = number; } } declare namespace pixi { const gl: typeof PIXI.glCore; } //tslint:disable-next-line:no-single-declare-module declare module "pixi.js" { export = PIXI; } /* tslint:disable */// Generated by Haxe TypeScript Declaration Generator :) /** * Allows you to map pixels to the screen or draw rectangles. */ declare class Bitmap { /** * The basic object that represents an image. * * @class Bitmap * @constructor * @param {Int} width The width of the bitmap * @param {Int} height The height of the bitmap */ constructor(width?: number, height?: number); /** * The face name of the font. * * @property fontFace * @type String */ fontFace: string; /** * The size of the font in pixels. * * @property fontSize * @type Number */ fontSize: number; /** * Whether the font is italic. * * @property fontItalic * @type Boolean */ fontItalic: number; /** * The color of the text in CSS format. * * @property textColor * @type String */ textColor: string; /** * The color of the outline of the text in CSS format. * * @property outlineColor * @type String */ outlineColor: string; /** * The width of the outline of the text. * * @property outlineWidth * @type Number */ outlineWidth: number; /** * [read-only] The url of the image file. * * @property url * @type String */ url: string; /** * [read-only] The base texture that holds the image. * * @property baseTexture * @type PIXI.BaseTexture */ baseTexture: PIXI.BaseTexture; /** * [read-only] The bitmap canvas. * * @property canvas * @type HTMLCanvasElement */ canvas: HTMLCanvasElement; /** * [read-only] The 2d context of the bitmap canvas. * * @property context * @type CanvasRenderingContext2D */ context: CanvasRenderingContext2D; /** * [read-only] The width of the bitmap. * * @property width * @type Number */ width: number; /** * [read-only] The height of the bitmap. * * @property height * @type Number */ height: number; /** * [read-only] The rectangle of the bitmap. * * @property rect * @type Rectangle */ rect: Rectangle; /** * Whether the smooth scaling is applied. * * @property smooth * @type Boolean */ smooth: boolean; /** * The opacity of the drawing object in the range (0, 255). * * @property paintOpacity * @type Number */ paintOpacity: number; /** * Cache entry, for images. In all cases _url is the same as cacheEntry.key * @type CacheEntry */ cacheEntry: CacheEntry; /** * Checks whether the bitmap is ready to render. * * @method isReady * @return {Boolean} True if the bitmap is ready to render */ isReady(): boolean; /** * Checks whether a loading error has occurred. * * @method isError * @return {Boolean} True if a loading error has occurred */ isError(): boolean; /** * Resizes the bitmap. * * @method resize * @param {Number} width The new width of the bitmap * @param {Number} height The new height of the bitmap */ resize(width: number, height: number): void; /** * Performs a block transfer. * * @method blt * @param {Bitmap} source The bitmap to draw * @param {Number} sx The x coordinate in the source * @param {Number} sy The y coordinate in the source * @param {Number} sw The width of the source image * @param {Number} sh The height of the source image * @param {Number} dx The x coordinate in the destination * @param {Number} dy The y coordinate in the destination * @param {Number} [dw=sw] The width to draw the image in the destination * @param {Number} [dh=sh] The height to draw the image in the destination */ blt(source: Bitmap, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw?: number, dh?: number): void; /** * Returns pixel color at the specified point. * * @method getPixel * @param {Number} x The x coordinate of the pixel in the bitmap * @param {Number} y The y coordinate of the pixel in the bitmap * @return {String} The pixel color (hex format) */ getPixel(x: number, y: number): string; /** * Returns alpha pixel value at the specified point. * * @method getAlphaPixel * @param {Number} x The x coordinate of the pixel in the bitmap * @param {Number} y The y coordinate of the pixel in the bitmap * @return {String} The alpha value */ getAlphaPixel(x: number, y: number): string; /** * Clears the specified rectangle. * * @method clearRect * @param {Number} x The x coordinate for the upper-left corner * @param {Number} y The y coordinate for the upper-left corner * @param {Number} width The width of the rectangle to clear * @param {Number} height The height of the rectangle to clear */ clearRect(x: number, y: number, width: number, height: number): void; /** * Clears the entire bitmap. * * @method clear */ clear(): void; /** * Fills the specified rectangle. * * @method fillRect * @param {Number} x The x coordinate for the upper-left corner * @param {Number} y The y coordinate for the upper-left corner * @param {Number} width The width of the rectangle to clear * @param {Number} height The height of the rectangle to clear * @param {String} color The color of the rectangle in CSS format */ fillRect(x: number, y: number, width: number, height: number, color: string): void; /** * Fills the entire bitmap. * * @method fillAll * @param {String} color The color of the rectangle in CSS format */ fillAll(color: string): void; /** * Draws the rectangle with a gradation. * * @method gradientFillRect * @param {Number} x The x coordinate for the upper-left corner * @param {Number} y The y coordinate for the upper-left corner * @param {Number} width The width of the rectangle to clear * @param {Number} height The height of the rectangle to clear * @param {String} color1 The start color of the gradation * @param {String} color2 The end color of the gradation * @param {Boolean} vertical Whether it draws a vertical gradient */ gradientFillRect(x: number, y: number, width: number, height: number, color1: string, color2: string, vertical?: boolean): void; /** * Draw the filled circle. * * @method drawCircle * @param {Number} x The x coordinate of the center of the circle * @param {Number} y The y coordinate of the center of the circle * @param {Number} radius The radius of the circle * @param {String} color The color of the circle in CSS format */ drawCircle(x: number, y: number, radius: number, color: string): void; /** * Draws the outline text to the bitmap. * * @method drawText * @param {String} text The text that will be drawn * @param {Number} x The x coordinate for the left of the text * @param {Number} y The y coordinate for the top of the text * @param {Number} maxWidth The maximum allowed width of the text * @param {Number} lineHeight The height of the text line * @param {String} align The alignment of the text */ drawText(text: string, x: number, y: number, maxWidth: number, lineHeight: number, align?: string): void; /** * Returns the width of the specified text. * * @method measureTextWidth * @param {String} text The text to be measured * @return {Number} The width of the text in pixels */ measureTextWidth(text: string): number; /** * Changes the color tone of the entire bitmap. * * @method adjustTone * @param {Number} r The red strength in the range (-255, 255) * @param {Number} g The green strength in the range (-255, 255) * @param {Number} b The blue strength in the range (-255, 255) */ adjustTone(r: number, g: number, b: number): void; /** * Rotates the hue of the entire bitmap. * * @method rotateHue * @param {Number} offset The hue offset in 360 degrees */ rotateHue(offset: number): void; /** * Applies a blur effect to the bitmap. * * @method blur */ blur(): void; /** * Add a callback function that will be called when the bitmap is loaded. * * @method addLoadListener * @param {Function} listner The callback function */ addLoadListener(listner: (bitmap: Bitmap) => void): void; /** * touch the resource * @method touch */ touch(): void; /** * Performs a block transfer, using assumption that original image was not modified (no hue) * * @method blt * @param {Bitmap} source The bitmap to draw * @param {Int} sx The x coordinate in the source * @param {Int} sy The y coordinate in the source * @param {Int} sw The width of the source image * @param {Int} sh The height of the source image * @param {Int} dx The x coordinate in the destination * @param {Int} dy The y coordinate in the destination * @param {Int} [dw=sw] The width to draw the image in the destination * @param {Int} [dh=sh] The height to draw the image in the destination */ bltImage(source: Bitmap, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw?: number, dh?: number): void; /** * Loads a image file and returns a new bitmap object. * * @static * @method load * @param {String} url The image url of the texture * @return Bitmap */ static load(url: string): Bitmap; /** * Takes a snapshot of the game screen and returns a new bitmap object. * * @static * @method snap * @param {Stage} stage The stage object * @return Bitmap */ static snap(stage: Stage): Bitmap; } declare class CacheEntry { /** * The resource class. Allows to be collected as a garbage if not use for some time or ticks * * @class CacheEntry * @constructor * @param {ResourceManager} resource manager * @param {string} key, url of the resource * @param {string} item - Bitmap, HTML5Audio, WebAudio - whatever you want to store in the cache */ constructor(cache: CacheMap, key: string, item: string); /** * frees the resource */ free(byTTL?: boolean): void; /** * Allocates the resource * @returns {CacheEntry} */ allocate(): CacheEntry; /** * Sets the time to live * @param {number} ticks TTL in ticks, 0 if not set * @param {number} time TTL in seconds, 0 if not set * @returns {CacheEntry} */ setTimeToLive(ticks?: number, seconds?: number): CacheEntry; isStillAlive(): boolean; /** * makes sure that resource wont freed by Time To Live * if resource was already freed by TTL, put it in cache again */ touch(): void; } declare class CacheMap { /** * Cache for images, audio, or any other kind of resource * @param manager * @constructor */ constructor(manager: ImageManager); /** * checks ttl of all elements and removes dead ones */ checkTTL(): void; /** * cache item * @param key url of cache element * @returns {*|null} */ getItem(key: string): any; clear(): void; setItem(key: string, item: any): CacheEntry; update(ticks: number, delta: number): void; } /** * The static class that carries out graphics processing. * * @class Graphics */ declare class Graphics { protected constructor(); /** * The total frame count of the game screen. * * @static * @property frameCount * @type Number */ static frameCount: number; /** * The alias of PIXI.blendModes.NORMAL. * * @static * @property BLEND_NORMAL * @type Number * @final */ static BLEND_NORMAL: number; /** * The alias of PIXI.blendModes.ADD. * * @static * @property BLEND_ADD * @type Number * @final */ static BLEND_ADD: number; /** * The alias of PIXI.blendModes.MULTIPLY. * * @static * @property BLEND_MULTIPLY * @type Number * @final */ static BLEND_MULTIPLY: number; /** * The alias of PIXI.blendModes.SCREEN. * * @static * @property BLEND_SCREEN * @type Number * @final */ static BLEND_SCREEN: number; /** * The width of the game screen. * * @static * @property width * @type Number */ static width: number; /** * The height of the game screen. * * @static * @property height * @type Number */ static height: number; /** * The width of the window display area. * * @static * @property boxWidth * @type Number */ static boxWidth: number; /** * The height of the window display area. * * @static * @property boxHeight * @type Number */ static boxHeight: number; /** * The zoom scale of the game screen. * * @static * @property scale * @type Number */ static scale: number; /** * Initializes the graphics system. * * @static * @method initialize * @param {Number} width The width of the game screen * @param {Number} height The height of the game screen * @param {String} type The type of the renderer. * 'canvas', 'webgl', or 'auto'. */ static initialize(width?: number, height?: number, type?: string): void; /** * Marks the beginning of each frame for FPSMeter. * * @static * @method tickStart */ static tickStart(): void; /** * Marks the end of each frame for FPSMeter. * * @static * @method tickEnd */ static tickEnd(): void; /** * Renders the stage to the game screen. * * @static * @method render * @param {Stage} stage The stage object to be rendered */ static render(stage?: Stage): void; /** * Checks whether the renderer type is WebGL. * * @static * @method isWebGL * @return {Boolean} True if the renderer type is WebGL */ static isWebGL(): boolean; /** * Checks whether the current browser supports WebGL. * * @static * @method hasWebGL * @return {Boolean} True if the current browser supports WebGL. */ static hasWebGL(): boolean; /** * Checks whether the canvas blend mode 'difference' is supported. * * @static * @method canUseDifferenceBlend * @return {Boolean} True if the canvas blend mode 'difference' is supported */ static canUseDifferenceBlend(): boolean; /** * Checks whether the canvas blend mode 'saturation' is supported. * * @static * @method canUseSaturationBlend * @return {Boolean} True if the canvas blend mode 'saturation' is supported */ static canUseSaturationBlend(): boolean; /** * Sets the source of the "Now Loading" image. * * @static * @method setLoadingImage * @param {String} Path of image */ static setLoadingImage(src: string): void; /** * Initializes the counter for displaying the "Now Loading" image. * * @static * @method startLoading */ static startLoading(): void; /** * Increments the loading counter and displays the "Now Loading" image if necessary. * * @static * @method updateLoading */ static updateLoading(): void; /** * Erases the "Now Loading" image. * * @static * @method endLoading */ static endLoading(): void; /** * Displays the error text to the screen. * * @static * @method printError * @param {String} name The name of the error * @param {String} message The message of the error */ static printError(name: string, message: string): void; /** * Shows the FPSMeter element. * * @static * @method showFps */ static showFps(): void; /** * Hides the FPSMeter element. * * @static * @method hideFps */ static hideFps(): void; /** * Loads a font file. * * @static * @method loadFont * @param {String} name The face name of the font * @param {String} url The url of the font file */ static loadFont(name: string, url: string): void; /** * Checks whether the font file is loaded. * * @static * @method isFontLoaded * @param {String} name The face name of the font * @return {Boolean} True if the font file is loaded */ static isFontLoaded(name: string): boolean; /** * Starts playback of a video. * * @static * @method playVideo * @param {String} src */ static playVideo(src: string): void; /** * Checks whether the video is playing. * * @static * @method isVideoPlaying * @return {Boolean} True if the video is playing */ static isVideoPlaying(): boolean; /** * Checks whether the browser can play the specified video type. * * @static * @method canPlayVideoType * @param {String} type The video type to test support for * @return {Boolean} True if the browser can play the specified video type */ static canPlayVideoType(type: string): boolean; /** * Converts an x coordinate on the page to the corresponding * x coordinate on the canvas area. * * @static * @method pageToCanvasX * @param {Number} x The x coordinate on the page to be converted * @return {Number} The x coordinate on the canvas area */ static pageToCanvasX(x: number): number; /** * Converts a y coordinate on the page to the corresponding * y coordinate on the canvas area. * * @static * @method pageToCanvasY * @param {Number} y The y coordinate on the page to be converted * @return {Number} The y coordinate on the canvas area */ static pageToCanvasY(y: number): number; /** * Checks whether the specified point is inside the game canvas area. * * @static * @method isInsideCanvas * @param {Number} x The x coordinate on the canvas area * @param {Number} y The y coordinate on the canvas area * @return {Boolean} True if the specified point is inside the game canvas area */ static isInsideCanvas(x: number, y: number): boolean; /** * Calls pixi.js garbage collector */ static callGC(): void; static _renderer: PIXI.AbstractRenderer; } declare class HTML5Audio { protected constructor(); _initialized: boolean; _unlocked: boolean; _audioElement: HTMLAudioElement; _gainTweenInterval: number; _tweenGain: number; _tweenTargetGain: number; _tweenGainStep: number; _staticSePath: boolean; _volume: number; _loadListeners: (() => void)[]; _hasError: boolean; __autoPlay: boolean; _isLoading: boolean; _buffered: boolean; /** * [read-only] The url of the audio file. * * @property url * @type String */ url: string; /** * The volume of the audio. * * @property volume * @type Number */ volume: number; /** * Sets up the Html5 Audio. * * @static * @method setup * @param {String} url The url of the audio file */ setup(url: string): void; /** * Initializes the audio system. * * @static * @method initialize * @return {Boolean} True if the audio system is available */ initialize(): void; /** * Clears the audio data. * * @static * @method clear */ clear(): void; /** * Set the URL of static se. * * @static * @param {String} url */ setStaticSe(url: string): void; /** * Checks whether the audio data is ready to play. * * @static * @method isReady * @return {Boolean} True if the audio data is ready to play */ isReady(): boolean; /** * Checks whether a loading error has occurred. * * @static * @method isError * @return {Boolean} True if a loading error has occurred */ isError(): boolean; /** * Checks whether the audio is playing. * * @static * @method isPlaying * @return {Boolean} True if the audio is playing */ isPlaying(): boolean; /** * Plays the audio. * * @static * @method play * @param {Boolean} loop Whether the audio data play in a loop * @param {Number} offset The start position to play in seconds */ play(loop: boolean, offset: number): void; /** * Stops the audio. * * @static * @method stop */ stop(): void; /** * Performs the audio fade-in. * * @static * @method fadeIn * @param {Number} duration Fade-in time in seconds */ fadeIn(duration: number): void; /** * Performs the audio fade-out. * * @static * @method fadeOut * @param {Number} duration Fade-out time in seconds */ fadeOut(duration: number): void; /** * Gets the seek position of the audio. * * @static * @method seek */ seek(): void; } declare class Input { protected constructor(); /** * The wait time of the key repeat in frames. * * @static * @property keyRepeatWait * @type Number */ static keyRepeatWait: number; /** * The interval of the key repeat in frames. * * @static * @property keyRepeatInterval * @type Number */ static keyRepeatInterval: number; /** * A hash table to convert from a virtual key code to a mapped key name. * * @static * @property keyMapper * @type Object * ``` * { * [key:number]:string * } * ``` */ static keyMapper: Object; /** * A hash table to convert from a gamepad button to a mapped key name. * * @static * @property gamepadMapper * @type Object * ``` * { * [key:number]:String * } * ``` */ static gamepadMapper: Object; /** * [read-only] The four direction value as a number of the numpad, or 0 for neutral. * * @static * @property dir4 * @type Number */ static dir4: number; /** * [read-only] The eight direction value as a number of the numpad, or 0 for neutral. * * @static * @property dir8 * @type Number */ static dir8: number; /** * [read-only] The time of the last input in milliseconds. * * @static * @property date * @type Number */ static date: number; /** * Initializes the input system. * * @static * @method initialize */ static initialize(): void; /** * Clears all the input data. * * @static * @method clear */ static clear(): void; /** * Updates the input data. * * @static * @method update */ static update(): void; /** * Checks whether a key is currently pressed down. * * @static * @method isPressed * @param {String} keyName The mapped name of the key * @return {Boolean} True if the key is pressed */ static isPressed(keyName: string): boolean; /** * Checks whether a key is just pressed. * * @static * @method isTriggered * @param {String} keyName The mapped name of the key * @return {Boolean} True if the key is triggered */ static isTriggered(keyName: string): boolean; /** * Checks whether a key is just pressed or a key repeat occurred. * * @static * @method isRepeated * @param {String} keyName The mapped name of the key * @return {Boolean} True if the key is repeated */ static nisRepeated(keyName: string): boolean; /** * Checks whether a key is kept depressed. * * @static * @method isLongPressed * @param {String} keyName The mapped name of the key * @return {Boolean} True if the key is long-pressed */ static isLongPressed(keyName: string): boolean; } /** * The static class that handles JSON with object information. * * @class JsonEx */ declare class JsonEx { protected constructor(); /** * The maximum depth of objects. * * @static * @property maxDepth * @type Number * @default 100 */ maxDepth: number; /** * Makes a deep copy of the specified object. * * @static * @method makeDeepCopy * @param {Object} object The object to be copied * @return {Object} The copied object */ static makeDeepCopy(object: any): any; /** * Converts an object to a JSON string with object information. * * @static * @method stringify * @param {Object} object The object to be converted * @return {String} The JSON string */ static stringify(object: any): string; /** * Parses a JSON string and reconstructs the corresponding object. * * @static * @method parse * @param {String} json The JSON string * @return {Object} The reconstructed object */ static parse(json: string): any; } declare namespace PIXI { declare class Point { /** * The Point object represents a location in a two-dimensional coordinate system, where x represents * the horizontal axis and y represents the vertical axis. * * @class * @namespace PIXI * @param [x=0] {number} position of the point on the x axis * @param [y=0] {number} position of the point on the y axis */ constructor(x?: number, y?: number); /** * Copies x and y from the given point * * @param {Point} The point to copy from * @return {Point} Returns itself. */ copyFrom(p: PIXI.Point): PIXI.Point; /** * Copies x and y into the given point * * @param {Point} p - The point to copy. * @return {Point} Given point with values updated */ copyTo(p: PIXI.Point): PIXI.Point; /** * Returns true if the given point is equal to this point * * @method copy * @param {Point} the point to compare * @return {Bool} the result of the comparison */ equals(p: PIXI.Point): boolean; /** * Sets the point to a new x and y position. * If y is ommited, both x and y will be set to x. * * @method set * @param [x=0] {Float} position of the point on the x axis * @param [y=0] {Float} position of the point on the y axis */ set(x?: number, y?: number): void; /** * @property x * @type Float * @default 0 */ x: number; /** * @property y * @type Float * @default 0 */ y: number; } } declare class Point extends PIXI.Point { /** * The point class. * * @class Point * @constructor * @param {Number} x The x coordinate * @param {Number} y The y coordinate */ constructor(x?: number, y?: number); /** * The x coordinate. * * @property x * @type Number */ x: number; /** * The y coordinate. * * @property y * @type Number */ y: number; } declare namespace pixi.core.math.shapes { declare class Shape { protected constructor(); /** * Defines the type of the shape to avoid instanceof (Std.is) checks */ type: any; /** * Checks whether the x and y coordinates passed to this function are contained within this Shape * * @method contains * @param x {Float} The X coordinate of the point to test * @param y {Float} The Y coordinate of the point to test * @return {Bool} Whether the x/y coords are within this Rectangle */ contains(x: number, y: number): boolean; } } declare namespace PIXI { declare class Rectangle extends pixi.core.math.shapes.Shape { /** * the Rectangle object is an area defined by its position, as indicated by its top-left corner point (x, y) and by its width and its height. * * @class Rectangle * @constructor * @param x {Float} The X coord of the upper-left corner of the rectangle * @param y {Float} The Y coord of the upper-left corner of the rectangle * @param width {Float} The overall width of this rectangle * @param height {Float} The overall height of this rectangle */ constructor(x?: number, y?: number, width?: number, height?: number); /** * Creates a clone of this Rectangle instance * * @method clone * @return {Rectangle} a copy of the rectangle */ clone(): PIXI.Rectangle; /** * Copies another Rectangle to this one. * * @param rectangle {Rectangle} The rectangle to copy * @return {Rectangle} Returns itself. */ copy(rectangle: PIXI.Rectangle): PIXI.Rectangle; /** * Checks whether the x and y coordinates given are contained within the rectangle. * * @param x {Float} x coordinate of the point to test. * @param y {Float} y coordinate of the point to test. * @return {Bool} whether the x and y coordinates are within this Rectangle. */ contains(x: number, y: number): boolean; /** * Pads this rectangle, making it grow in all directions. * * @param padX {Float} The horizontal padding amount. * @param padY {Float} The vertical padding amount. */ pad(padX: number, padY: number): void; /** * Fits this rectangle around the passed one. * * @param rectangle {Rectangle} The rectangle to fit. */ fit(rectangle: PIXI.Rectangle): void; /** * Enlarges this rectangle to fit around the passed one. * * @param rectangle {Rectangle} The rectangle to include. */ enlarge(rectangle: PIXI.Rectangle): void; /** * @property x * @type Float * @default 0 */ x: number; /** * @property y * @type Float * @default 0 */ y: number; /** * @property width * @type Float * @default 0 */ width: number; /** * @property height * @type Float * @default 0 */ height: number; /** * @property left * @type Float * @default 0 */ left: number; /** * @property right * @type Float * @default 0 */ right: number; /** * @property top * @type Float * @default 0 */ top: number; /** * @property bottom * @type Float * @default 0 */ bottom: number; } } declare class Rectangle extends PIXI.Rectangle { /** * The rectangle class. * * @class Rectangle * @constructor * @param {Number} x The x coordinate for the upper-left corner * @param {Number} y The y coordinate for the upper-left corner * @param {Number} width The width of the rectangle * @param {Number} height The height of the rectangle */ constructor(x?: number, y?: number, width?: number, height?: number); /** * @static * @property emptyRectangle * @type Rectangle */ static emptyRectangle: Rectangle; } declare namespace PIXI.utils { declare class EventEmitter { /** * Minimal EventEmitter interface that is molded against the Node.js * EventEmitter interface. * * @constructor */ constructor(); /** * Return a list of assigned event listeners. * * @param {String} eventName * @return {Array} */ listeners(event: string): any[]; /** * Emit an event to all registered event listeners. * * @alias dispatchEvent * @param eventName {String} The name of the event. * @return {Bool} Indication if we've emitted an event. */ emit(event: string, a1?: any, a2?: any, a3?: any, a4?: any, a5?: any): boolean; /** * Register a new EventListener for the given event. * * @param {String} event Name of the event. * @param {function} fn Callback function. * @param {Mixed} context The context of the function. */ on(event: string, fn: (arg0: PIXI.interaction.InteractionEvent) => void, context?: any): void; /** * Add an EventListener that's only called once. * * @param {String} event Name of the event. * @param {function} fn Callback function. * @param {Mixed} context The context of the function. */ once(event: string, fn: (arg0: PIXI.interaction.InteractionEvent) => void, context?: any): void; /** * Register a new EventListener for the given event. * * @param {String} event Name of the event. * @param {function} fn Callback function. * @param {Mixed} context The context of the function. */ addListener(event: string, fn: (arg0: PIXI.interaction.InteractionEvent) => void, context?: any): void; /** * Remove event listeners. * * @param {String} event The event we want to remove. * @param {function} fn The listener that we need to find. * @param {Bool} once Only remove once listeners. */ off(event: string, fn: (arg0: PIXI.interaction.InteractionEvent) => void, once?: boolean): void; /** * Remove event listeners. * * @param {String} event The event we want to remove. * @param {function} fn The listener that we need to find. * @param {Bool} once Only remove once listeners. */ removeListener(event: string, fn: (arg0: PIXI.interaction.InteractionEvent) => void, once?: boolean): void; /** * Remove all listeners or only the listeners for the specified event. * * @param {String} event The event want to remove all listeners for. */ removeAllListeners(event?: string): void; } } declare namespace PIXI.interaction { declare class interactiveTarget extends PIXI.utils.EventEmitter { protected constructor(); /** * Fired when a pointer device button (usually a mouse button) is pressed on the display * object. * * @event mousedown * @memberof InteractiveTarget# */ mousedown(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device secondary button (usually a mouse right-button) is pressed * on the display object. * * @event rightdown * @memberof InteractiveTarget# */ rightdown(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button (usually a mouse button) is released over the display * object. * * @event mouseup * @memberof InteractiveTarget# */ mouseup(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device secondary button (usually a mouse right-button) is released * over the display object. * * @event rightup * @memberof InteractiveTarget# */ rightup(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button (usually a mouse button) is pressed and released on * the display object. * * @event click * @memberof InteractiveTarget# */ click(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device secondary button (usually a mouse right-button) is pressed * and released on the display object. * * @event rightclick * @memberof InteractiveTarget# */ rightclick(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button (usually a mouse button) is released outside the * display object that initially registered a * [mousedown]{@link PIXI.interaction.InteractionManager#event:mousedown}. * * @event mouseupoutside * @memberof InteractiveTarget# */ mouseupoutside(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device secondary button (usually a mouse right-button) is released * outside the display object that initially registered a * [rightdown]{@link PIXI.interaction.InteractionManager#event:rightdown}. * * @event rightupoutside * @memberof InteractiveTarget# */ rightupoutside(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device (usually a mouse) is moved while over the display object * * @event mousemove * @memberof InteractiveTarget# */ mousemove(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device (usually a mouse) is moved onto the display object * * @event mouseover * @memberof InteractiveTarget# */ mouseover(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device (usually a mouse) is moved off the display object * * @event mouseout * @memberof InteractiveTarget# */ mouseout(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button is pressed on the display object. * * @event pointerdown * @memberof InteractiveTarget# */ pointerdown(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button is released over the display object. * * @event pointerup * @memberof InteractiveTarget# */ pointerup(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button is pressed and released on the display object. * * @event pointertap * @memberof InteractiveTarget# */ pointertap(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device button is released outside the display object that initially * registered a [pointerdown]{@link PIXI.interaction.InteractionManager#event:pointerdown}. * * @event pointerupoutside * @memberof InteractiveTarget# */ pointerupoutside(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device is moved while over the display object * * @event pointermove * @memberof InteractiveTarget# */ pointermove(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device is moved onto the display object * * @event pointerover * @memberof InteractiveTarget# */ pointerover(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a pointer device is moved off the display object * * @event pointerout * @memberof InteractiveTarget# */ pointerout(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a touch point is placed on the display object. * * @event touchstart * @memberof InteractiveTarget# */ touchstart(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a touch point is removed from the display object. * * @event touchend * @memberof InteractiveTarget# */ touchend(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a touch point is placed and removed from the display object. * * @event tap * @memberof InteractiveTarget# */ tap(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a touch point is removed outside of the display object that initially * registered a [touchstart]{@link PIXI.interaction.InteractionManager#event:touchstart}. * * @event touchendoutside * @memberof InteractiveTarget# */ touchendoutside(event: PIXI.interaction.InteractionEvent): void; /** * Fired when a touch point is moved along the display object. * * @event touchmove * @memberof InteractiveTarget# */ touchmove(event: PIXI.interaction.InteractionEvent): void; /** * Indicates if the displayObject is interactive or not. * * @member {Bool} * @default false * @memberof InteractiveTarget# */ interactive: boolean; /** * Indicates if the children of displayObject are interactive or not. * * @member {Bool} * @default true * @memberof InteractiveTarget# */ interactiveChildren: boolean; /** * Interaction shape. Children will be hit first, then this shape will be checked. * * @member {Shape} * @memberof InteractiveTarget# * @default null */ hitArea: pixi.core.math.shapes.Shape; /** * Indicates if the displayObject uses button mode or normal mode. * * @member {Bool} * @default false * @memberof InteractiveTarget# */ buttonMode: boolean; /** * Default cursor. * * @member {String} * @default pointer * @memberof InteractiveTarget# */ defaultCursor: string; /** * Internal check to detect if the mouse cursor is hovered over the displayObject * * @member {Bool} * @private */ _over: boolean; /** * Internal check to detect if the left mouse button is pressed on the displayObject * * @member {Bool} * @private */ _isLeftDown: boolean; /** * Internal check to detect if the right mouse button is pressed on the displayObject * * @member {Bool} * @private */ _isRightDown: boolean; /** * Internal check to detect if the pointer cursor is hovered over the displayObject * * @member {Bool} * @private */ _pointerOver: boolean; /** * Internal check to detect if the pointer is down on the displayObject * * @member {Bool} * @private */ _pointerDown: boolean; /** * Internal check to detect if a user has touched the displayObject * * @member {Bool} * @private */ _touchDown: boolean; } } declare namespace pixi.core.display { export type DestroyOptions = { /** * {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true * Should it destroy the base texture of the child sprite */ baseTexture: boolean; /** * {boolean} [options.children=false] - if set to true, all the children will have their destroy * method called as well. 'options' will be passed on to those calls. */ children: boolean; /** * {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true * Should it destroy the texture of the child sprite */ texture: boolean; } } declare namespace PIXI { declare class DisplayObject extends PIXI.interaction.interactiveTarget { /** * The base class for all objects that are rendered on the screen. * This is an abstract class and should not be used on its own rather it should be extended. * * @class * @namespace PIXI */ constructor(); /** * Retrieves the bounds of the displayObject as a rectangle object * * @param skipUpdate {Matrix} setting to true will stop the transforms of the scene graph from being updated. * This means the calculation returned MAY be out of date BUT will give you a nice performance boost * @param rect {Rectangle} Optional rectangle to store the result of the bounds calculation * @return {Rectangle} the rectangular bounding area */ getBounds(skipUpdate?: boolean, rect?: PIXI.Rectangle): PIXI.Rectangle; /** * Retrieves the local bounds of the displayObject as a rectangle object * * @param rect {Rectangle} Optional rectangle to store the result of the bounds calculation * @return {Rectangle} the rectangular bounding area */ getLocalBounds(rect?: PIXI.Rectangle): PIXI.Rectangle; /** * Calculates the global position of the display object * * @param position {Point} The world origin to calculate from * @param point {Point} A Point in which to store the value, optional (otherwise a new Point is created) * @param skipUpdate {Bool} Should we skip the update transform * @return {Point} A point object representing the position of this object */ toGlobal(position: PIXI.Point, point?: PIXI.Point, skipUpdate?: boolean): PIXI.Point; /** * Calculates the local position of the display object relative to another point * * @param position {Point} The world origin to calculate from * @param [from] {DisplayObject} The DisplayObject to calculate the global position from * @param [point] {Point} A Point object in which to store the value, optional (otherwise will create a new Point) * @return {Point} A point object representing the position of this object */ toLocal(position: PIXI.Point, frm?: PIXI.DisplayObject, point?: PIXI.Point): PIXI.Point; updateTransform(): void; displayObjectUpdateTransform(): void; /** * Set the parent Container of this DisplayObject * * @param container {Container} The Container to add this DisplayObject to * @return {Container} The Container that this DisplayObject was added to */ setParent(container: PIXI.Container): PIXI.Container; /** * Convenience function to set the postion, scale, skew and pivot at once. * * @param [x=0] {Float} The X position * @param [y=0] {Float} The Y position * @param [scaleX=1] {Float} The X scale value * @param [scaleY=1] {Float} The Y scale value * @param [skewX=0] {Float} The X skew value * @param [skewY=0] {Float} The Y skew value * @param [pivotX=0] {Float} The X pivot value * @param [pivotY=0] {Float} The Y pivot value * @return {DisplayObject} */ setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, pivotX?: number, pivotY?: number): PIXI.DisplayObject; /** * Base destroy method for generic display objects * Removes all internal references and listeners as well as removes children from the display list. * * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options * have been set to that value * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy * method called as well. 'options' will be passed on to those calls. * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true * Should it destroy the texture of the child sprite * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true * Should it destroy the base texture of the child sprite */ destroy(options?: boolean | pixi.core.display.DestroyOptions): void; /** * The instance name of the object. * * @member {String} */ name: string; /** * Set this to true if you want this display object to be cached as a bitmap. * This basically takes a snap shot of the display object as it is at that moment. It can provide a performance benefit for complex static displayObjects. * To remove simply set this property to 'null' * * @member {Bool} * @memberof DisplayObject# */ cacheAsBitmap: boolean; /** * The opacity of the object. * * @member {Float} */ alpha: number; /** * World transform and local transform of this object. This will become read-only later, * please do not assign anything there unless you know what are you doing. * * @member {Transform} */ transform: PIXI.Transform; /** * The visibility of the object. If false the object will not be drawn, and * the updateTransform function will not be called. * * @member {Bool} */ visible: boolean; /** * Can this object be rendered, if false the object will not be drawn but the updateTransform * methods will still be called. * * @member {Bool} */ renderable: boolean; /** * The display object container that contains this display object. * * @member {Container} * @readOnly */ parent: PIXI.Container; /** * The multiplied alpha of the displayObject * * @member {Float} * @readOnly */ worldAlpha: number; /** * The area the filter is applied to. This is used as more of an optimisation * rather than figuring out the dimensions of the displayObject each frame you can set this rectangle * * Also works as an interaction mask * * @member {Rectangle} */ filterArea: PIXI.Rectangle; /** * The position of the displayObject on the x axis relative to the local coordinates of the parent. * * @member {Float} * @memberof DisplayObject# */ x: number; /** * The position of the displayObject on the y axis relative to the local coordinates of the parent. * * @member {Float} * @memberof DisplayObject# */ y: number; /** * Current transform of the object based on world (parent) factors * * @member {Matrix} * @readOnly */ worldTransform: PIXI.Matrix; /** * Current transform of the object based on local factors: position, scale, other stuff * * @member {PIXI.Matrix} * @readOnly */ localTransform: PIXI.Matrix; /** * The coordinate of the object relative to the local coordinates of the parent. * * @member {Point} */ position: PIXI.Point; /** * The scale factor of the object. * * @member {Point} */ scale: PIXI.Point; /** * The pivot point of the displayObject that it rotates around * * @member {Point} */ pivot: PIXI.Point; /** * The skew factor for the object in radians. * * @member {Point} */ skew: PIXI.Point; /** * The rotation of the object in radians. * * @member {Float} */ rotation: number; /** * Indicates if the displayObject is globally visible. * * @member {Bool} * @memberof DisplayObject# * @readonly */ worldVisible: boolean; /** * Sets a mask for the displayObject. A mask is an object that limits the visibility of an object to the shape of the mask applied to it. * In PIXI a regular mask must be a PIXI.Graphics or a PIXI.Sprite object. This allows for much faster masking in canvas as it utilises shape clipping. * To remove a mask, set this property to null. * * For the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask. * * @member {Graphics|Sprite} * @memberof DisplayObject# */ mask: PIXI.Sprite | PIXI.Graphics; /** * Sets the filters for the displayObject. * * IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer. * To remove filters simply set this property to 'null' * * @member {Array} * @memberof DisplayObject# */ filters: PIXI.Filter[]; /** * Flag for if the object is accessible. If true AccessibilityManager will overlay a * shadow div with attributes set * * @member {Bool} */ accessible: boolean; /** * Sets the title attribute of the shadow div * If accessibleTitle AND accessibleHint has not been this will default to 'displayObject [tabIndex]' * * @member {String} */ accessibleTitle: string; /** * Sets the aria-label attribute of the shadow div * * @member {String} */ accessibleHint: string; tabIndex: number; } } declare namespace PIXI { declare class Container extends PIXI.DisplayObject { /** * A Container represents a collection of display objects. * It is the base class of all display objects that act as a container for other objects. * * @class * @extends DisplayObject * @namespace PIXI */ constructor(); /** * The array of children of this container. * * @member {DisplayObject[]} * @readonly */ children: PIXI.DisplayObject[]; /** * The width of the Container, setting this will actually modify the scale to achieve the value set * * @member {Float} * @memberof Container# */ width: number; /** * The height of the Container, setting this will actually modify the scale to achieve the value set * * @member {Float} * @memberof Container# */ height: number; /** * Adds a child to the container. * * You can also add multple items like so: myContainer.addChild(thinkOne, thingTwo, thingThree) * * @param child {DisplayObject} The DisplayObject to add to the container * @return {DisplayObject} The child that was added. */ addChild(child: T): T; /** * Adds a child to the container at a specified index. * If the index is out of bounds an error will be thrown. * * @param child {DisplayObject} The child to add * @param index {Int} The index to place the child in * @return {DisplayObject} The child that was added. */ addChildAt(child: T, index: number): T; /** * Swaps the position of 2 Display Objects within this container. * * @param child1 {DisplayObject} * @param child2 {DisplayObject} */ swapChildren(child1: PIXI.DisplayObject, child2: PIXI.DisplayObject): void; /** * Returns the index position of a child DisplayObject instance * * @param child {DisplayObject} The DisplayObject instance to identify * @return {Int} The index position of the child display object to identify */ getChildIndex(child: PIXI.DisplayObject): number; /** * Changes the position of an existing child in the display object container * * @param child {DisplayObject} The child DisplayObject instance for which you want to change the index number * @param index {Int} The resulting index number for the child display object */ setChildIndex(child: PIXI.DisplayObject, index: number): void; /** * Returns the child at the specified index * * @param index {Int} The index to get the child from * @return {DisplayObject} The child at the given index, if any. */ getChildAt(index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @param child {DisplayObject} The DisplayObject to remove * @return {DisplayObject} The child that was removed. */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @param index {Int} The index to get the child from * @return {DisplayObject} The child that was removed. */ removeChildAt(index: number): PIXI.DisplayObject; /** * Removes all children from this container that are within the begin and end indexes. * * @param beginIndex {Int} The beginning position. Default value is 0. * @param endIndex {Int} The ending position. Default value is size of the container. * @return {Array} The children that are removed. */ removeChildren(beginIndex?: number, endIndex?: number): PIXI.DisplayObject[]; /** * Returns the display object in the container * * @param name {string} instance name * @return {DisplayObject} */ getChildByName(name: string): PIXI.DisplayObject; } } declare namespace PIXI { declare class Sprite extends PIXI.Container { /** * The Sprite object is the base for all textured objects that are rendered to the screen * * A sprite can be created directly from an image like this: * * ```haxe * var sprite = new Sprite.fromImage('assets/image.png'); * ``` * * @class Sprite * @extends Container * @namespace PIXI * @param texture {Texture} The texture for this sprite */ constructor(texture?: PIXI.Texture); /** * The anchor sets the origin point of the texture. * The default is 0,0 this means the texture's origin is the top left * Setting than anchor to 0.5,0.5 means the textures origin is centered * Setting the anchor to 1,1 would mean the textures origin points will be the bottom right corner * * @member {ObservablePoint} */ anchor: PIXI.ObservablePoint; /** * The texture that the sprite is using * * @member {Texture} */ texture: PIXI.Texture; /** * The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect. * * @member {Int} * @default 0xFFFFFF */ tint: number; /** * The blend mode to be applied to the sprite. Set to CONST.blendModes.NORMAL to remove any blend mode. * * @member {Int} * @default CONST.blendModes.NORMAL; */ blendMode: any; /** * The shader that will be used to render the sprite. Set to null to remove a current shader. * * @member {Shader|Filter} */ shader: PIXI.Shader | PIXI.Filter; /** * Plugin that is responsible for rendering this element. * Allows to customize the rendering process without overriding '_render' & '_renderCanvas' methods. * * @member {String} * @default 'sprite' */ pluginName: string; /** * Tests if a point is inside this sprite * * @param {Point} point - the point to test * @return {Bool} the result of the test */ containsPoint(point: PIXI.Point): boolean; /** * Helper function that creates a new sprite based on the source you provide. * The source can be - frame id, image url, video url, canvas element, video element, base texture * * @static * @param {Int|String|BaseTexture|HTMLCanvasElement|HTMLVideoElement} source Source to create texture from * @return {Sprite} The newly created sprite */ static from(source: any): PIXI.Sprite; /** * Helper function that creates a sprite that will contain a texture from the TextureCache based on the frameId * The frame ids are created when a Texture packer file has been loaded * * @static * @param frameId {String} The frame Id of the texture in the cache * @return {Sprite} A new Sprite using a texture from the texture cache matching the frameId */ static fromFrame(frameId: string): PIXI.Sprite; /** * Helper function that creates a sprite that will contain a texture based on an image url * If the image is not in the texture cache it will be loaded * * @static * @param imageId {String} The image url of the texture * @param [crossorigin=(auto)] {Bool} Should use anonymouse CORS? Defaults to true if the URL is not a data-URI. * @param [scaleMode=scaleModes.DEFAULT] {ScaleModes} See {@link scaleModes} for possible values * @return {Sprite} A new Sprite using a texture from the texture cache matching the image id */ static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: any): PIXI.Sprite; } } declare class ScreenSprite extends PIXI.Sprite { /** * The sprite which covers the entire game screen. * * @class ScreenSprite * @constructor */ constructor(); /** * The opacity of the sprite (0 to 255). * * @property opacity * @type Number */ opacity: number; /** * Sets black to the color of the screen sprite. * * @method setBlack */ setBlack(): void; /** * Sets white to the color of the screen sprite. * * @method setWhite */ setWhite(): void; /** * Sets the color of the screen sprite by values. * * @method setColor * @param {Number} r The red value in the range (0, 255) * @param {Number} g The green value in the range (0, 255) * @param {Number} b The blue value in the range (0, 255) */ setColor(r?: number, g?: number, b?: number): void; } declare class Tilemap extends PIXI.Container { /** * [read-only] The array of children of the sprite. * * @property children * @type Array */ constructor(); /** * The bitmaps used as a tileset. * * @property bitmaps * @type Array */ bitmaps: Bitmap[]; /** * The origin point of the tilemap for scrolling. * * @property origin * @type Point */ origin: Point; /** * The tileset flags. * * @property flags * @type Array */ flags: number[]; /** * The animation count for autotiles. * * @property animationCount * @type Number */ animationCount: number; /** * Whether the tilemap loops horizontal. * * @property horizontalWrap * @type Boolean */ horizontalWrap: boolean; /** * Whether the tilemap loops vertical. * * @property verticalWrap * @type Boolean */ verticalWrap: boolean; /** * The width of the screen in pixels. * * @property width * @type Number */ tileWidth: number; /** * The height of a tile in pixels. * * @property tileHeight * @type Number */ tileHeight: number; /** * Sets the tilemap data. * * @method setData * @param {Number} width The width of the map in number of tiles * @param {Number} height The height of the map in number of tiles * @param {Array} data The one dimensional array for the map data */ setData(width: number, height: number, data: number[]): void; /** * Checks whether the tileset is ready to render. * * @method isReady * @type Boolean * @return {Boolean} True if the tilemap is ready */ isReady(): boolean; /** * Updates the tilemap for each frame. * * @method update */ update(): void; /** * @method updateTransform * @private */ updateTransform(): void; /** * Forces to repaint the entire static * * @method refresh */ refresh(): void; /** * Adds a child to the container. * * @method addChild * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container at a specified index. * * @method addChildAt * @param {PIXI.DisplayObject} child The child to add * @param {Number} index The index to place the child in * @return {PIXI.DisplayObject} The child that was added */ addChildAt(child: PIXI.DisplayObject, index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @method removeChild * @param {PIXI.DisplayObject} child The child to remove * @return {PIXI.DisplayObject} The child that was removed */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @method removeChildAt * @param {Number} index The index to get the child from * @return {PIXI.DisplayObject} The child that was removed */ removeChildAt(index: number): PIXI.DisplayObject; /** * Forces to refresh the tileset * * @method refresh */ refreshTileset(): void; static TILE_ID_A1: number; static TILE_ID_A2: number; static TILE_ID_A3: number; static TILE_ID_A4: number; static TILE_ID_A5: number; static TILE_ID_B: number; static TILE_ID_C: number; static TILE_ID_D: number; static TILE_ID_E: number; static TILE_ID_MAX: number; static FLOOR_AUTOTILE_TABLE: number[][][]; static WALL_AUTOTILE_TABLE: number[][][]; static WATERFALL_AUTOTILE_TABLE: number[][][]; static isVisibleTile(tileId: number): boolean; static isAutotile(tileId: number): boolean; static getAutotileKind(tileId: number): number; static getAutotileShape(tileId: number): number; static makeAutotileId(kind: number, shape: number): number; static isSameKindTile(tileID1: number, tileID2: number): boolean; static isTileA1(tileId: number): boolean; static isTileA2(tileId: number): boolean; static isTileA3(tileId: number): boolean; static isTileA4(tileId: number): boolean; static isTileA5(tileId: number): boolean; static isWaterTile(tileId: number): boolean; static isWaterfallTile(tileId: number): boolean; static isGroundTile(tileId: number): boolean; static isShadowingTile(tileId: number): boolean; static isRoofTile(tileId: number): boolean; static isWallTopTile(tileId: number): boolean; static isWallSideTile(tileId: number): boolean; static isWallTile(tileId: number): boolean; static isFloorTypeAutotile(tileId: number): boolean; static isWallTypeAutotile(tileId: number): boolean; static isWaterfallTypeAutotile(tileId: number): boolean; } declare class ShaderTilemap extends Tilemap { protected constructor(); /** * PIXI render method * * @method renderWebGL * @param {PIXI.WebGLRenderer} pixi renderer */ renderWebGL(renderer: PIXI.Renderer): void; /** * PIXI render method * * @method renderCanvas * @param {PIXI.CanvasRenderer} pixi renderer */ renderCanvas(renderer: PIXI.CanvasRenderer): void; /** * Forces to repaint the entire tilemap AND update bitmaps list if needed * * @method refresh */ refresh(): void; /** * Call after you update tileset * * @method refreshTileset */ refreshTileset(): void; } declare class Sprite extends PIXI.Sprite { /** * The basic object that is rendered to the game screen. * * @class Sprite * @constructor * @param {Bitmap} bitmap The image for the sprite */ constructor(bitmap?: Bitmap); /** * The image for the sprite. * * @property bitmap * @type Bitmap */ bitmap: Bitmap; /** * The width of the sprite without the scale. * * @property width * @type Number */ opacity: number; /** * The visibility of the sprite. * * @property visible * @type Boolean */ visible: boolean; /** * The x coordinate of the sprite. * * @property x * @type Number */ x: number; /** * The y coordinate of the sprite. * * @property y * @type Number */ y: number; /** * The origin point of the sprite. (0,0) to (1,1). * * @property anchor * @type Point */ point: PIXI.Point; /** * The scale factor of the sprite. * * @property scale * @type Point */ scale: PIXI.Point; /** * The rotation of the sprite in radians. * * @property rotation * @type Number */ rotation: number; /** * The blend mode to be applied to the sprite. * * @property blendMode * @type Number */ blendMode: number; /** * Sets the filters for the sprite. * * @property filters * @type Array */ filters: PIXI.Filter[]; /** * [read-only] The array of children of the sprite. * * @property children * @type Array */ spriteId: number; opaque: boolean; voidFilter: PIXI.Filter; initialize(bitmap?: Bitmap): void; /** * Updates the sprite for each frame. * * @method update */ update(): void; /** * @method updateTransform * @private */ updateTransform(): void; /** * Sets the x and y at once. * * @method move * @param {Number} x The x coordinate of the sprite * @param {Number} y The y coordinate of the sprite */ move(x: number, y: number): void; /** * Sets the rectagle of the bitmap that the sprite displays. * * @method setFrame * @param {Number} x The x coordinate of the frame * @param {Number} y The y coordinate of the frame * @param {Number} width The width of the frame * @param {Number} height The height of the frame */ setFrame(x: number, y: number, width: number, height: number): void; /** * Gets the blend color for the sprite. * * @method getBlendColor * @return {Array} The blend color [r, g, b, a] */ getBlendColor(): number[]; /** * Sets the blend color for the sprite. * * @method setBlendColor * @param {Array} color The blend color [r, g, b, a] */ setBlendColor(color: number[]): void; /** * Gets the color tone for the sprite. * * @method getColorTone * @return {Array} The color tone [r, g, b, gray] */ getColorTone(): number[]; /** * Sets the color tone for the sprite. * * @method setColorTone * @param {Array} tone The color tone [r, g, b, gray] */ setColorTone(tone: number[]): void; /** * Adds a child to the container. * * @method addChild * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container at a specified index. * * @method addChildAt * @param {PIXI.DisplayObject} child The child to add * @param {Number} index The index to place the child in * @return {PIXI.DisplayObject} The child that was added */ addChildAt(child: PIXI.DisplayObject, index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @method removeChild * @param {PIXI.DisplayObject} child The child to remove * @return {PIXI.DisplayObject} The child that was removed */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @method removeChildAt * @param {Number} index The index to get the child from * @return {PIXI.DisplayObject} The child that was removed */ removeChildAt(index: number): PIXI.DisplayObject; /** * Number of the created objects. * * @static * @property _counter * @type Number */ static _counter: number; } declare class Stage extends PIXI.Container { /** * The root object of the display tree. * * @class Stage * @constructor */ constructor(); /** * Adds a child to the container. * * @method addChild * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container at a specified index. * * @method addChildAt * @param {PIXI.DisplayObject} child The child to add * @param {Number} index The index to place the child in * @return {PIXI.DisplayObject} The child that was added */ addChildAt(child: PIXI.DisplayObject, index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @method removeChild * @param {PIXI.DisplayObject} child The child to remove * @return {PIXI.DisplayObject} The child that was removed */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @method removeChildAt * @param {Number} index The index to get the child from * @return {PIXI.DisplayObject} The child that was removed */ removeChildAt(index: number): PIXI.DisplayObject; } declare namespace PIXI { declare class TilingSprite extends PIXI.Sprite { /** * A tiling sprite is a fast way of rendering a tiling image * * @class * @extends Sprite * @memberof PIXI.extras * @param texture {Texture} the texture of the tiling sprite * @param width {Float} [width=100] the width of the tiling sprite * @param height {Float} [height=100] the height of the tiling sprite */ constructor(texture: PIXI.Texture, width?: number, height?: number); /** * Tile transform * * @member {Transform} */ tileTransform: PIXI.Transform; /** * Whether or not anchor affects uvs * * @member {Bool} * @default false */ uvRespectAnchor: boolean; /** * The scaling of the image that is being tiled * * @member {ObservablePoint} */ tileScale: PIXI.ObservablePoint; /** * The offset position of the image that is being tiled * * @member {ObservablePoint} */ tilePosition: PIXI.ObservablePoint; /** * Changes frame clamping in corresponding textureTransform, shortcut * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas * @default 0.5 */ clampMargin: number; /** * Helper function that creates a new sprite based on the source you provide. * The source can be - frame id, image url, video url, canvas element, video element, base texture * * @static * @param {Int|String|BaseTexture|HTMLCanvasElement|HTMLVideoElement} source Source to create texture from * @param {Float} width - the width of the tiling sprite * @param {Float} height - the height of the tiling sprite * @return {TilingSprite} The newly created sprite */ static from(source: any, width: number, height: number): PIXI.TilingSprite; /** * Helper function that creates a tiling sprite that will use a texture from the TextureCache based on the frameId * The frame ids are created when a Texture packer file has been loaded * * @static * @param {String} frameId - The frame Id of the texture in the cache * @param {Float} width - the width of the tiling sprite * @param {Float} height - the height of the tiling sprite * @return {TilingSprite} A new TilingSprite using a texture from the texture cache matching the frameId */ static fromFrame(frameId: string, width: number, height: number): PIXI.TilingSprite; /** * Helper function that creates a sprite that will contain a texture based on an image url * If the image is not in the texture cache it will be loaded * * @static * @param {String} imageId - The image url of the texture * @param {Float} width - the width of the tiling sprite * @param {Float} height - the height of the tiling sprite * @param {Bool} [crossorigin] - if you want to specify the cross-origin parameter * @param {ScaleModes} [scaleMode=PIXI.settings.SCALE_MODE] - if you want to specify the scale mode, * see {@link PIXI.SCALE_MODES} for possible values * @return {TilingSprite} A new TilingSprite using a texture from the texture cache matching the image id */ static fromImage(imageId: string, width: number, height: number, crossorigin?: boolean, scaleMode?: any): PIXI.TilingSprite; } } declare class TilingSprite extends PIXI.TilingSprite { /** * The sprite object for a tiling image. * * @class TilingSprite * @constructor * @param {Bitmap} bitmap The image for the tiling sprite */ constructor(bitmap: Bitmap); /** * The origin point of the tiling sprite for scrolling. * * @property origin * @type Point */ origin: Point; /** * The image for the tiling sprite. * * @property bitmap * @type Bitmap */ bitmap: Bitmap; /** * The opacity of the tiling sprite (0 to 255). * * @property opacity * @type Number */ opacity: number; /** * The visibility of the tiling sprite. * * @property visible * @type Boolean */ visibility: boolean; /** * The x coordinate of the tiling sprite. * * @property x * @type Number */ x: number; /** * The y coordinate of the tiling sprite. * * @property y * @type Number */ y: number; spriteId: number; /** * Updates the tiling sprite for each frame. * * @method update */ update(): void; /** * @method updateTransform * @private */ updateTransform(): void; /** * Sets the x, y, width, and height all at once. * * @method move * @param {Number} x The x coordinate of the tiling sprite * @param {Number} y The y coordinate of the tiling sprite * @param {Number} width The width of the tiling sprite * @param {Number} height The height of the tiling sprite */ move(x?: number, y?: number, width?: number, height?: number): void; /** * Specifies the region of the image that the tiling sprite will use. * * @method setFrame * @param {Number} x The x coordinate of the frame * @param {Number} y The y coordinate of the frame * @param {Number} width The width of the frame * @param {Number} height The height of the frame */ setFrame(x: number, y: number, width: number, height: number): void; updateTransformTS(): void; /** * @method generateTilingTexture * @param {Boolean} arg */ generateTilingTexture(arg: boolean): void; } declare namespace PIXI { declare class Filter { /** * @class * @memberof PIXI * @param [vertexSrc] {String} The source of the vertex shader. * @param [fragmentSrc] {String} The source of the fragment shader. * @param [uniforms] {Dynamic} Custom uniforms to use to augment the built-in ones. */ constructor(vertexSrc?: string, fragmentSrc?: string, uniforms?: any); /** * Legacy filters use position and uvs from attributes */ readonly legacy: boolean; /** * Sets the blendmode of the filter. Default: PIXI.BLEND_MODES.NORMAL */ blendMode: any; /** * Program that the shader uses */ program: PIXI.Program; /** * The WebGL state the filter requires to render */ state: PIXI.State; /** * The vertex shader. * * @member {String} */ vertexSrc: string; /** * The fragment shader. * * @member {String} */ fragmentSrc: string; /** * An object containing the current values of custom uniforms. * @example Updating the value of a custom uniform * filter.uniforms.time = performance.now(); * * @member {Dynamic} */ uniforms: any; /** * The padding of the filter. Some filters require extra space to breath such as a blur. * Increasing this will add extra width and height to the bounds of the object that the * filter is applied to. * * @member {Float} */ padding: number; /** * The resolution of the filter. Setting this to be lower will lower the quality but * increase the performance of the filter. * * @member {Float} */ resolution: number; /** * If enabled is true the filter is applied, if false it will not. * * @member {Bool} */ enabled: boolean; /** * If enabled, PixiJS will fit the filter area into boundaries for better performance. Switch it off if it does not work for specific shader. * Workaround for http://jsfiddle.net/xbmhh207/1/ * @default true * @member {Bool} */ autoFit: boolean; apply(filterManager: PIXI.systems.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clear?: boolean, currentState?: pixi.core.renderers.webgl.filters.CurrentState): void; /** * The default vertex shader source * * @static * @constant */ static defaultVertexSrc: any; /** * The default fragment shader source * * @static * @constant */ static defaultFragmentSrc: any; } } declare namespace PIXI.filters { declare class ColorMatrixFilter extends PIXI.Filter { /** * The ColorMatrixFilter class lets you apply a 5x5 matrix transformation on the RGBA * color and alpha values of every pixel on your displayObject to produce a result * with a new set of RGBA color and alpha values. It's pretty powerful! * * ```js * var colorMatrix = new ColorMatrixFilter(); * container.filters = [colorMatrix]; * colorMatrix.contrast(2); * ``` * @author Clément Chenebault * @class * @extends AbstractFilter * @memberof PIXI.filters */ constructor(); /** * Sets the matrix of the color matrix filter * * @member {number[]} * @memberof ColorMatrixFilter# * @default [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] */ matrix: number[]; /** * Adjusts brightness * * Multiply the current matrix * @param b {Float} value of the brigthness (0 is black) * @param multiply {Bool} refer to ._loadMatrix() method */ brightness(b: number, multiply: boolean): void; /** * Set the matrices in grey scales * * Multiply the current matrix * @param scale {Float} value of the grey (0 is black) * @param multiply {Bool} refer to ._loadMatrix() method */ greyscale(scale: number, multiply: boolean): void; /** * Set the black and white matrice * Multiply the current matrix * * @param multiply {Bool} refer to ._loadMatrix() method */ blackAndWhite(multiply: boolean): void; /** * Set the hue propertie of the color * * Multiply the current matrix * @param rotation {Float} in degrees * @param multiply {Bool} refer to ._loadMatrix() method */ hue(rotation: number, multiply: boolean): void; /** * Set the contrast matrix, increase the separation between dark and bright * Increase contrast : shadows darker and highlights brighter * Decrease contrast : bring the shadows up and the highlights down * * @param amount {Float} value of the contrast * @param multiply {Bool} refer to ._loadMatrix() method */ contrast(amount: number, multiply: boolean): void; /** * Set the saturation matrix, increase the separation between colors * Increase saturation : increase contrast, brightness, and sharpness * @param amount {Float} * @param multiply {Bool} refer to ._loadMatrix() method */ saturation(amount: number, multiply: boolean): void; /** * Desaturate image (remove color) * * Call the saturate function * * @param multiply {Bool} refer to ._loadMatrix() method */ desaturate(multiply: boolean): void; /** * Negative image (inverse of classic rgb matrix) * * @param multiply {Bool} refer to ._loadMatrix() method */ negative(multiply: boolean): void; /** * Sepia image * * @param multiply {Bool} refer to ._loadMatrix() method */ sepia(multiply: boolean): void; /** * Color motion picture process invented in 1916 (thanks Dominic Szablewski) * * @param multiply {Bool} refer to ._loadMatrix() method */ technicolor(multiply: boolean): void; /** * Polaroid filter * * @param multiply {boolean} refer to ._loadMatrix() method */ polaroid(multiply: boolean): void; /** * Filter who transforms : Red -> Blue and Blue -> Red * * @param multiply {Bool} refer to ._loadMatrix() method */ toBGR(multiply: boolean): void; /** * Color reversal film introduced by Eastman Kodak in 1935. (thanks Dominic Szablewski) * * @param multiply {Bool} refer to ._loadMatrix() method */ kodachrome(multiply: boolean): void; /** * Brown delicious browni filter (thanks Dominic Szablewski) * * @param multiply {Bool} refer to ._loadMatrix() method */ browni(multiply: boolean): void; vintage(multiply: boolean): void; colorTone(desaturation: number, toned: number, lightColor: number, darkColor: number, multiply: boolean): void; night(intensity: number, multiply: boolean): void; predator(amount: number, multiply: boolean): void; lsd(multiply: boolean): void; reset(): void; } } declare class ToneFilter extends PIXI.filters.ColorMatrixFilter { /** * The color matrix filter for WebGL. * * @class ToneFilter * @extends PIXI.Filter * @constructor */ constructor(); /** * Changes the hue. * * @method adjustHue * @param {Number} value The hue value in the range (-360, 360) */ adjustHue(value?: number): void; /** * Changes the saturation. * * @method adjustSaturation * @param {Number} value The saturation value in the range (-255, 255) */ adjustSaturation(value?: number): void; /** * Changes the tone. * * @method adjustTone * @param {Number} r The red strength in the range (-255, 255) * @param {Number} g The green strength in the range (-255, 255) * @param {Number} b The blue strength in the range (-255, 255) */ adjustTone(r?: number, g?: number, b?: number): void; } declare class ToneSprite extends PIXI.Container { /** * The sprite which changes the screen color in 2D canvas mode. * * @class ToneSprite * @constructor */ constructor(); /** * Clears the tone. * * @method reset */ clear(): void; /** * Sets the tone. * * @method setTone * @param {Number} r The red strength in the range (-255, 255) * @param {Number} g The green strength in the range (-255, 255) * @param {Number} b The blue strength in the range (-255, 255) * @param {Number} gray The grayscale level in the range (0, 255) */ setTone(r: number, g: number, b: number, gray: number): void; } declare namespace rm.types { export const enum Frames { base = -1, } } declare class TouchInput { protected constructor(); static _mousePressed: boolean; static _screenPressed: boolean; static _pressedTime: number; static _date: number; static _x: number; static _y: number; /** * The wait time of the pseudo key repeat in frames. * * @static * @property keyRepeatWait * @type Number */ static keyRepeatWait: rm.types.Frames; /** * The interval of the pseudo key repeat in frames. * * @static * @property keyRepeatInterval * @type Number */ static keyRepeatInterval: rm.types.Frames; /** * [read-only] The horizontal scroll amount. * * @static * @property wheelX * @type Number */ static wheelX: number; /** * [read-only] The vertical scroll amount. * * @static * @property wheelY * @type Number */ static wheelY: number; /** * [read-only] The x coordinate on the canvas area of the latest touch event. * * @static * @property x * @type Number */ static x: number; /** * [read-only] The y coordinate on the canvas area of the latest touch event. * * @static * @property y * @type Number */ static y: number; /** * [read-only] The time of the last input in milliseconds. * * @static * @property date * @type Number */ static date: number; /** * Initializes the touch system. * * @static * @method initialize */ static initialize(): void; /** * Clears all the touch data. * * @static * @method clear */ static clear(): void; /** * Updates the touch data. * * @static * @method update */ static update(): void; /** * Checks whether the mouse button or touchscreen is currently pressed down. * * @static * @method isPressed * @return {Boolean} True if the mouse button or touchscreen is pressed */ static isPressed(): boolean; /** * Checks whether the left mouse button or touchscreen is just pressed. * * @static * @method isTriggered * @return {Boolean} True if the mouse button or touchscreen is triggered */ static isTriggered(): boolean; /** * Checks whether the left mouse button or touchscreen is just pressed * or a pseudo key repeat occurred. * * @static * @method isRepeated * @return {Boolean} True if the mouse button or touchscreen is repeated */ static isRepeated(): boolean; /** * Checks whether the left mouse button or touchscreen is kept depressed. * * @static * @method isLongPressed * @return {Boolean} True if the left mouse button or touchscreen is long-pressed */ static isLongPressed(): boolean; /** * Checks whether the right mouse button is just pressed. * * @static * @method isCancelled * @return {Boolean} True if the right mouse button is just pressed */ static isCancelled(): boolean; /** * Checks whether the mouse or a finger on the touchscreen is moved. * * @static * @method isMoved * @return {Boolean} True if the mouse or a finger on the touchscreen is moved */ static isMoved(): boolean; /** * Checks whether the left mouse button or touchscreen is released. * * @static * @method isReleased * @return {Boolean} True if the mouse button or touchscreen is released */ static isReleased(): boolean; } declare class Utils { protected constructor(); /** * The name of the RPG Maker. 'MV' in the current version. */ static RPGMAKER_NAME: string; /** * The version of the RPG Maker. * * @static * @property RPGMAKER_VERSION * @type String * @final */ static RPGMAKER_VERSION: string; /** * Checks whether the option is in the query string. * * @param {String} name The option name * @return {Boolean} True if the option is in the query string */ static isOptionValid(name: string): boolean; /** * Checks whether the platform is NW.js. * * @return {Boolean} True if the platform is NW.js */ static isNwjs(): boolean; /** * Checks whether the platform is a mobile device. * * @static * @method isMobileDevice * @return {Boolean} True if the platform is a mobile device */ static isMobileDevice(): boolean; /** * Checks whether the browser is Mobile Safari. * * @static * @method isMobileSafari * @return {Boolean} True if the browser is Mobile Safari */ static isMobileSafari(): boolean; /** * Checks whether the browser is Android Chrome. * * @return {Boolean} True if the browser is Android Chrome */ static isAndroidChrome(): boolean; /** * Checks whether the browser can read files in the game folder. * * @return {Boolean} True if the browser can read files in the game folder */ static canReadGameFiles(): boolean; /** * Makes a CSS color string from RGB values. * * @static * @method rgbToCssColor * @param {Int} r The red value in the range (0, 255) * @param {Int} g The green value in the range (0, 255) * @param {Int} b The blue value in the range (0, 255) * @return {String} CSS color string */ static rgbToCssColor(r: number, g: number, b: number): string; static isSupportPassiveEvent(): boolean; static generateRuntimeId(): number; } declare class Weather extends PIXI.Container { /** * The weather effect which displays rain, storm, or snow. * * @class Weather * @constructor */ constructor(); /** * The type of the weather in ['none', 'rain', 'storm', 'snow']. * * @property type * @type String */ type: string; /** * The power of the weather in the range (0, 9). * * @property power * @type Number */ power: number; /** * The origin point of the weather for scrolling. * * @property origin * @type Point */ origin: Point; /** * Updates the weather for each frame. * * @method update */ update(): void; } declare class WindowLayer extends PIXI.Container { /** * The layer which contains game windows. * * @class WindowLayer * @constructor */ constructor(); /** * The width of the window layer in pixels. * * @property width * @type Number */ voidFilter: PIXI.Filter; /** * Sets the x, y, width, and height all at once. * * @method move * @param {Number} x The x coordinate of the window layer * @param {Number} y The y coordinate of the window layer * @param {Number} width The width of the window layer * @param {Number} height The height of the window layer */ move(x: number, y: number, width: number, height: number): void; /** * Updates the window layer for each frame. * * @method update */ update(): void; /** * Adds a child to the container. * * @method addChild * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container at a specified index. * * @method addChildAt * @param {PIXI.DisplayObject} child The child to add * @param {Number} index The index to place the child in * @return {PIXI.DisplayObject} The child that was added */ addChildAt(child: PIXI.DisplayObject, index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @method removeChild * @param {PIXI.DisplayObject} child The child to remove * @return {PIXI.DisplayObject} The child that was removed */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @method removeChildAt * @param {Number} index The index to get the child from * @return {PIXI.DisplayObject} The child that was removed */ removeChildAt(index: number): PIXI.DisplayObject; /** * @method _renderCanvas * @param {PIXI.CanvasRenderer} renderer * @private */ _renderCanvas(renderer: PIXI.CanvasRenderer): void; /** * @method _renderWebGL * @param {PIXI.WebGLRenderer} renderer * @private */ _renderWebGL(renderer: PIXI.Renderer): void; } declare class Window extends PIXI.Container { /** * The visibility of the sprite. * * @property visible * @type Boolean */ constructor(); /** * The origin point of the window for scrolling. * * @property origin * @type Point */ origin: PIXI.Point; /** * The active state for the window. * * @property active * @type Boolean */ active: boolean; /** * The visibility of the down scroll arrow. * * @property downArrowVisible * @type Boolean */ downArrowVisible: boolean; /** * The visibility of the up scroll arrow. * * @property upArrowVisible * @type Boolean */ upArrowVisible: boolean; /** * The visibility of the pause sign. * * @property pause * @type Boolean */ pause: boolean; /** * The image used as a window skin. * * @property windowskin * @type Bitmap */ windowskin: Bitmap; /** * The bitmap used for the window contents. * * @property contents * @type Bitmap */ contents: Bitmap; /** * The width of the window in pixels. * * @property width * @type Number */ padding: number; /** * The size of the margin for the window background. * * @property margin * @type Number */ margin: number; /** * The opacity of the window without contents (0 to 255). * * @property opacity * @type Number */ opacity: number; /** * The opacity of the window background (0 to 255). * * @property backOpacity * @type Number */ backOpacity: number; /** * The opacity of the window contents (0 to 255). * * @property contentsOpacity * @type Number */ contentsOpacity: number; /** * The openness of the window (0 to 255). * * @property openness * @type Number */ openness: number; /** * The width of the content area in pixels. */ innerWidth: number; /** * The height of the content area in pixels. */ innerHeight: number; /** * The rectangle of the content area */ innerRect: Rectangle; /** * Updates the window for each frame. * * @method update */ update(): void; /** * Sets the x, y, width, and height all at once. * * @method move * @param {Number} x The x coordinate of the window * @param {Number} y The y coordinate of the window * @param {Number} width The width of the window * @param {Number} height The height of the window */ move(x?: number, y?: number, width?: number, height?: number): void; /** * Returns true if the window is completely open (openness == 255). * * @method isOpen * @return {Boolean} */ isOpen(): boolean; /** * Returns true if the window is completely closed (openness == 0). * * @method isClosed * @return {Boolean} */ isClosed(): boolean; /** * Sets the position of the command cursor. * * @method setCursorRect * @param {Number} x The x coordinate of the cursor * @param {Number} y The y coordinate of the cursor * @param {Number} width The width of the cursor * @param {Number} height The height of the cursor */ setCursorRect(x?: number, y?: number, width?: number, height?: number): void; /** * Changes the color of the background. * * @method setTone * @param {Number} r The red value in the range (-255, 255) * @param {Number} g The green value in the range (-255, 255) * @param {Number} b The blue value in the range (-255, 255) */ setTone(r: number, g: number, b: number): void; /** * Adds a child between the background and contents. * * @method addChildToBack * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChildToBack(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container. * * @method addChild * @param {PIXI.DisplayObject} child The child to add * @return {PIXI.DisplayObject} The child that was added */ addChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Adds a child to the container at a specified index. * * @method addChildAt * @param {PIXI.DisplayObject} child The child to add * @param {Number} index The index to place the child in * @return {PIXI.DisplayObject} The child that was added */ addChildAt(child: PIXI.DisplayObject, index: number): PIXI.DisplayObject; /** * Removes a child from the container. * * @method removeChild * @param {PIXI.DisplayObject} child The child to remove * @return {PIXI.DisplayObject} The child that was removed */ removeChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Removes a child from the specified index position. * * @method removeChildAt * @param {Number} index The index to get the child from * @return {PIXI.DisplayObject} The child that was removed */ removeChildAt(index: number): PIXI.DisplayObject; /** * Move the cursor position by the given amount * @param x * @param y */ moveCursorBy(x: number, y: number): void; /** * Moves the inner children by the given amount. * @param x * @param y */ moveInnerChildrenBy(x: number, y: number): void; /** * Adds a child to the client area. * @param child * @return DisplayObject */ addInnerChild(child: PIXI.DisplayObject): PIXI.DisplayObject; /** * Draws the window shape into PIXI.Graphics object. Used by WindowLayer. * @param graphics */ drawShape(graphics: PIXI.Graphics): void; /** * Destroys the window */ destroy(): void; /** * @method updateTransform * @private */ updateTransform(): void; } declare namespace rm.types { export type AudioParameters = { name: string; pan: number; pitch: number; pos: number; volume: number; } } /** * Static class that handles BGM, BGS, ME, and SE. */ declare class AudioManager { protected constructor(); static _bgmVolume: number; static _bgsVolume: number; static _meVolume: number; static _seVolume: number; static _currentBgm: rm.types.AudioParameters; static _currentBgs: rm.types.AudioParameters; static _bgmBuffer: HTML5Audio; static _bgsBuffer: HTML5Audio; static _meBuffer: HTML5Audio; static _seBuffers: HTML5Audio[]; static _staticBuffers: HTML5Audio[]; static _replayFadeTime: number; static _path: string; static _blobUrl: string; static bgmVolume: number; static bgsVolume: number; static meVolume: number; static seVolume: number; static playBgm(bgm: rm.types.AudioParameters, pos?: number): void; static replayBgm(bgm: rm.types.AudioParameters): void; static isCurrentBgm(bgm: rm.types.AudioParameters): boolean; static updateBgmParameters(bgm: rm.types.AudioParameters): void; static pdateCurrentBgm(bgm: rm.types.AudioParameters, pos: number): void; static stopBgm(): void; static fadeOutBgm(duration: number): void; static fadeInBgm(duration: number): void; static playBgs(bgs: rm.types.AudioParameters, pos?: number): void; static replayBgs(bgs: rm.types.AudioParameters): void; static isCurrentBgs(bgs: rm.types.AudioParameters): boolean; static updateBgsParameters(bgs: rm.types.AudioParameters): void; static updateCurrentBgs(bgs: rm.types.AudioParameters, pos: number): void; static stopBgs(): void; static fadeOutBgs(duration: number): void; static fadeInBgs(duration: number): void; static playMe(me: rm.types.AudioParameters): void; static updateMeParameters(me: rm.types.AudioParameters): void; static fadeOutMe(duration: number): void; static stopMe(): void; static playSe(se: rm.types.AudioParameters): void; static updateSeParameters(buffer: rm.types.AudioParameters, se: rm.types.AudioParameters): void; static stopSe(): void; static playStaticSe(se: rm.types.AudioParameters): void; static loadStaticSe(se: rm.types.AudioParameters): void; static isStaticSe(se: rm.types.AudioParameters): boolean; static stopAll(): void; static saveBgm(): rm.types.AudioParameters; static saveBgs(): rm.types.AudioParameters; static makeEmptyAudioObject(): rm.types.AudioParameters; static createBuffer(): HTML5Audio; static updateBufferParameters(buffer: rm.types.AudioParameters, configVolume: number, audio: rm.types.AudioParameters): void; static audioFileExt(): string; static shouldUseHtml5Audio(): string; static checkErrors(): void; static checkWebAudioError(webAudio?: HTML5Audio): void; static playEncryptedBgm(bgm: rm.types.AudioParameters, pos?: number): void; static createDecryptBuffer(url: string, bgm: rm.types.AudioParameters, pos?: number): void; } declare namespace rm.types { /** * A superclass of actor, class, skill, item, weapon, armor, enemy, and state. * * Some items are unnecessary depending on the type of data, but they are included for convenience sake. */ export type BaseItem = { /** * The description text. */ description: string; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; meta: Object; /** * The item name. */ name: string; note: string; } } declare namespace rm.types { export type BattleRewards = { exp: number; gold: number; items: rm.types.BaseItem[]; } } declare namespace rm.types { export const enum BattleResult { base = -1, } } /** * Manages the game battles to process all of the * events that happen within. */ declare class BattleManager { protected constructor(); _phase: string; _canEscape: boolean; _canLose: boolean; _battleTest: boolean; _eventCallback: () => void; _preemptive: boolean; _surprise: boolean; _actorIndex: number; _actionForceBattler: Game_Battler; _mapBgm: rm.types.AudioParameters; _mapBgs: rm.types.AudioParameters; _actionBattlers: Game_Battler[]; _subject: Game_Battler; _action: Game_Action; _targets: Game_Battler[]; _logWindow: Window_BattleLog; _statusWindow: Window_BattleStatus; _spriteset: Spriteset_Battle; _escapeRatio: number; _escaped: boolean; _rewards: rm.types.BattleRewards; static setup(troopId: number, canEscape: boolean, canLose: boolean): void; static initMembers(): void; static isBattleTest(): boolean; static setBattleTest(battleTest: boolean): void; static setEventCallback(callback: () => void): void; static setLogWindow(logWindow: Window_BattleLog): void; static setStatusWindow(statusWindow: Window_BattleStatus): void; static setSpriteset(spriteset: Spriteset_Battle): void; static onEncounter(): void; static ratePreemptive(): number; static rateSurprise(): number; static saveBgmAndBgs(): void; static playBattleBgm(): void; static playVictoryMe(): void; static playDefeatMe(): void; static replayBgmAndBgs(): void; static makeEscapeRatio(): void; static update(): void; static updateEvent(): boolean; static updateEventMain(): boolean; static isBusy(): boolean; static isInputting(): boolean; static isInTurn(): boolean; static isTurnEnd(): boolean; static isAborting(): boolean; static isBattleEnd(): boolean; static canEscape(): boolean; static canLose(): boolean; static isEscaped(): boolean; static actor(): Game_Actor; static clearActor(): void; static changeActor(newActorIndex: number, lastActorActionState: string): void; static startBattle(): void; static displayStartMessages(): void; static startInput(): void; static inputtingAction(): Game_Action; static selectNextCommand(): void; static selectPreviousCommand(): void; static refreshStatus(): void; static startTurn(): void; static updateTurn(): void; static processTurn(): void; static endTurn(): void; static updateTurnEnd(): void; static getNextSubject(): Game_Battler; static allBattleMembers(): Game_Battler[]; static makeActionOrders(): void; static startAction(): void; static updateAction(): void; static endAction(): void; static invokeAction(): void; static invokeNormalAction(): void; static invokeCounterAttack(): void; static invokeMagicReflection(): void; static applySubstitute(target: Game_Battler): Game_Battler; static checkSubstitute(target: Game_Battler): boolean; static isActionForced(): boolean; static forceAction(battler: Game_Battler): void; static processForcedAction(): void; static abort(): void; static checkBattleEnd(): boolean; static checkAbort(): boolean; static processVictory(): void; static processEscape(): boolean; static processAbort(): void; static processDefeat(): void; static endBattle(result: rm.types.BattleResult): void; static updateBattleEnd(): void; static makeRewards(): void; static displayVictoryMessage(): void; static displayDefeatMessage(): void; static displayEscapeSuccessMessage(): void; static displayEscapeFailureMessage(): void; static displayRewards(): void; static displayExp(): void; static displayGold(): void; static displayDropItems(): void; static gainRewards(): void; static gainExp(): void; static gainGold(): void; static gainDropItems(): void; } declare namespace rm.types { export type TextState = { index: number; left: number; startX: number; text: string; x: number; y: number; } } declare namespace rm.types { } declare class Window_Base extends Window { /** * Creates an instance of Window_Base. * @param {number} x * @param {number} y * @param {number} width * @param {number} height * @memberof Window_Base */ constructor(x: number, y: number, width: number, height: number); /** * Initializes the window. * * @memberof Window_Base */ initialize(x?: number, y?: number, width?: number, height?: number): void; /** * Returns the standard line height of the current window; * default is 36. * @returns {number} * @memberof Window_Base */ lineHeight(): number; /** * Returns the standard font face of the * game based on what language the game is in. * @returns {String} * @memberof Window_Base */ standardFontFace(): string; /** * Returns the standard font size of the text * in window; default is 28. * @returns {number} * @memberof Window_Base */ standardFontSize(): number; /** * Returns the standard padding of the window; * default is 18. * @returns {number} * @memberof Window_Base */ standardPadding(): number; /** * Returns the text padding of the window; * default is 6. * @returns {number} * @memberof Window_Base */ textPadding(): number; /** * Returns the standard back opacity of the window; this is the * opacity of the area behind the window's text content. * Default is 192. * @returns {number} * @memberof Window_Base */ standardBackOpacity(): number; /** * Loads the window skin from the img/system directory. * * @memberof Window_Base */ loadWindowSkin(): void; /** * Updates the window padding based on the * standardPadding method. * @memberof Window_Base */ updatePadding(): void; /** * Updates the back opacity of the window * based on the standardBackOpacity method. * @memberof Window_Base */ updateBackOpacity(): void; /** * Returns the inner content width of the window. * * @returns {number} * @memberof Window_Base */ contentsWidth(): number; /** * Returns the inner content height of the window. * * @returns {number} * @memberof Window_Base */ contentsHeight(): number; /** * Returns the fitting height given a number of lines based on * the line height plus standard padding of the window. * Default formula: numLines * lineHeight + standardPadding * 2 * * @param {number} numLines * @returns {number} * @memberof Window_Base */ fittingHeight(numLines: number): number; /** * Updates the tone of the window based on the * game system window tone defined in the database. * @memberof Window_Base */ updateTone(): void; /** * Creates the contents of the window; this is the area * of the window which text is drawn to. * @memberof Window_Base */ createContents(): void; /** * Resets the font settings of the window back to the * default. * @memberof Window_Base */ resetFontSettings(): void; /** * Resets the text color of the window back to the * default. * @memberof Window_Base */ resetTextColor(): void; /** * The update method of the window; this is * run every frame to do logic processing for the window. * @memberof Window_Base */ update(): void; /** * Updates the openness of the window when the * _opening property is set to true. * Openness is increased. * @memberof Window_Base */ updateOpen(): void; /** * Updates the openness of the window when the * _closing property is set to true. * Openness is decreased. * @memberof Window_Base */ updateClose(): void; /** * Opens the window. * * @memberof Window_Base */ open(): void; /** * Closes the window. * * @memberof Window_Base */ close(): void; /** * Returns true if the window is currently opening. * * @returns {boolean} * @memberof Window_Base */ isOpening(): boolean; /** * Returns true if the window is currently closing. * * @returns {boolean} * @memberof Window_Base */ isClosing(): boolean; /** * Shows the window, making it visible. * * @memberof Window_Base */ show(): void; /** * Hides the window, making it invisible; * the window is not closed when hidden. * * @memberof Window_Base */ hide(): void; /** * Activates the window, allowing it to be processed * and to update. * @memberof Window_Base */ activate(): void; /** * Deactives the window, preventing further processing. * * @memberof Window_Base */ deactivate(): void; /** * Returns a text color given a numbered index * as a css color String; this index maps * directly to the img/system/window.png colors * by default. * @param {number} n * @returns {*} * @memberof Window_Base */ textColor(n: number): string; /** * Returns the normal color as a css * color String. * @returns {String} * @memberof Window_Base */ normalColor(): string; /** * Returns the system color as a * css color String. * @returns {String} * @memberof Window_Base */ systemColor(): string; /** * Returns the crisis color as a * css color String. * @returns {String} * @memberof Window_Base */ crisisColor(): string; /** * Returns the death color as a * css color String. * @returns {String} * @memberof Window_Base */ deathColor(): string; /** * Returns the gauage back color as * a css color String. * @returns {String} * @memberof Window_Base */ gaugeBackColor(): string; /** * Returns the hp gauge color 1 * as a css color String. * @returns {String} * @memberof Window_Base */ hpGaugeColor1(): string; /** * Returns the hp gauge color 2 * as a css color String. * @returns {String} * @memberof Window_Base */ hpGaugeColor2(): string; /** * Returns the mp gauge color 1 * as a css color String. * @returns {String} * @memberof Window_Base */ mpGaugeColor1(): string; /** * Returns the mp gauge color 2 * as a css color String. * @returns {String} * @memberof Window_Base */ mpGaugeColor2(): string; /** * Returns the mp cost color as a * css color String. * @returns {String} * @memberof Window_Base */ mpCostColor(): string; /** * Returns the power up color as a * css color String. * @returns {String} * @memberof Window_Base */ powerUpColor(): string; /** * Returns the power down color as a * css color String. * @returns {String} * @memberof Window_Base */ powerDownColor(): string; /** * Returns the tp gauge color 1 as a * css color String. * @returns {String} * @memberof Window_Base */ tpGaugeColor1(): string; /** * Returns tp gauge color 2 as a * css color String. * @returns {String} * @memberof Window_Base */ tpGaugeColor2(): string; /** * Returns the tp cost color as a * css color String. * @returns {String} * @memberof Window_Base */ tpCostColor(): string; /** * Returns the pending color as a * css color String. * @returns {String} * @memberof Window_Base */ pendingColor(): string; /** * Returns the translucentOpacity for the window; * The default is 160. * * @returns {number} * @memberof Window_Base */ translucentOpacity(): number; /** * Changes the text color property given a css color String. * * @param {String} color * @memberof Window_Base */ changeTextColor(color: string): void; /** * Changes the paintOpacity (the opacity of the text drawn to the window); * if true the opacity is set to 255, otherwise the opacity is set to 160. * @param {boolean} enabled * @memberof Window_Base */ changePaintOpacity(enabled: boolean): void; /** * Given text or a number, draws the content to the window's contents * layer at the specified x and y coordinate within the max width. * The text content can also be aligned with the align property. * The possible alignments are: "left", "center", "right". * @param {(String | number)} text * @param {number} x * @param {number} y * @param {number} maxWidth * @param {String} align * @memberof Window_Base */ drawText(text: string | number, x: number, y: number, maxWidth: number, align: string): void; /** * Calculates the width of a text String and * returns a number. * @param {String} text * @returns {number} * @memberof Window_Base */ textWidth(text: string): number; /** * Draws text with text codes included; this will draw * icons, increase text height, and more. * @param text * @param x * @param y * @param width * @returns Int * @memberof Window_Base */ drawTextEx(text: string, x: number, y: number): number; /** * Converts the escape characters and returns the text content * after processing the characters. * @param {String} text * @returns {String} * @memberof Window_Base */ convertEscapeCharacters(text: string): string; /** * Returns the actor name given an index; * the index starts from 1. * @param {number} actorIndex * @returns {String} * @memberof Window_Base */ actorName(actorIndex: number): string; /** * Returns a party member name given an index; * the index starts from 1. * @param {number} partyMemberIndex * @returns {String} * @memberof Window_Base */ partyMemberName(partyMemberIndex: number): string; /** * Process each character in the text when drawTextEx * is used to draw text. * @param {MV.TextState} textState * @memberof Window_Base */ processCharacter(textState: rm.types.TextState): void; /** * Processes the normal characters in the text * when drawTextEx is used to draw text. * Normal characters are letters and numbers. * @param {MV.TextState} textState * @memberof Window_Base */ processNormalCharacter(textState: rm.types.TextState): void; /** * Processes new line when drawTextEx is used to draw text. * * @param {MV.TextState} textState * @memberof Window_Base */ processNewLine(textState: rm.types.TextState): void; /** * Processes new page when drawTexttEx is used to draw text. * * @param {MV.TextState} textState * @memberof Window_Base */ processNewPage(textState: rm.types.TextState): void; obtainEscapeCode(textState: rm.types.TextState): string; /** * Obtains the escape parameters from text codes in the text state * when drawTextEx is used to draw text. * @param {MV.TextState} textState * @returns {(number | String)} * @memberof Window_Base */ obtainEscapeParam(textState: string | rm.types.TextState): number | string; /** * Processes escape characters when drawTextEx is used * for drawing text. * @param {String} code * @param {MV.TextState} textState * @memberof Window_Base */ processEscapeCharacter(code: string, textState: rm.types.TextState): void; /** * Processes drawing an icon when drawTextEx is used for * drawing text. * @param {number} iconIndex * @param {MV.TextState} textState * @memberof Window_Base */ processDrawIcon(iconIndex: number, textState: rm.types.TextState): void; /** * Makes the font bigger by a value of 12. * * @memberof Window_Base */ makeFontBigger(): void; /** * Makes the font smaller by a value of 12. * * @memberof Window_Base */ makeFontSmaller(): void; /** * Calculates the text height of the textState (when using drawTextEx); * if all is set to true, all lines of text are calculated, otherwise * only a single line is processed. * @param {rm.TextState} textState * @param {Bool} all * @returns Int * @memberof Window_Base */ calcTextHeight(textState: rm.types.TextState, all: boolean): number; /** * Draws an icon given the specified iconIndex at the specified * x and y coordinates. The Width and Height of the icon is based on the * _iconWidth and _iconHeight properties. * @param {number} iconIndex * @param {number} x * @param {number} y * @memberof Window_Base */ drawIcon(iconIndex: number, x: number, y: number): void; drawFace(faceName: string, faceIndex: number, x: number, y: number, width: number, height: number): void; /** * Draws a character (map sprites) at the specified x and y coordinate. * CharacterName refers to character spritesheet, and characterIndex refers * to the characterIndex on the spritesheet. * @param {String} characterName * @param {number} characterIndex * @param {number} x * @param {number} y * @memberof Window_Base */ drawCharacter(characterName: string, characterIndex: number, x: number, y: number): void; /** * Draws a gauge at the specified x and y coordinates within the given width. * Color1 and Color2 represent the gradient as css color Strings of the gauge. * * @param {number} x * @param {number} y * @param {number} width * @param {number} rate * @param {String} color1 * @param {String} color2 * @memberof Window_Base */ drawGauge(x: number, y: number, width: number, rate: number, color1: string, color2: string): void; /** * Returns the hp color as a css String. * * @param {Game_Actor} actor * @returns {String} * @memberof Window_Base */ hpColor(actor: Game_Actor): string; /** * Returns the mp color as a css color String. * * @param {Game_Actor} actor * @returns {String} * @memberof Window_Base */ mpColor(actor: Game_Actor): string; /** * Returns the tp color as a css color String. * * @param {Game_Actor} actor * @returns {String} * @memberof Window_Base */ tpColor(actor: Game_Actor): string; drawActorCharacter(actor: Game_Actor, x: number, y: number): void; /** * Draws the actor face at the specified x and y coordinates within * the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @param {number} height * @memberof Window_Base */ drawActorFace(actor: Game_Actor, x: number, y: number, width: number, height: number): void; /** * Draws the actor name at the specified x and y coordinates within * the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorName(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the actor class at the specified x and y coordinates * within the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorClass(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the actor nickname at the specified x and y coordinates * within the given width. * @param {Game_Actor} actor * @param {Int} x * @param {Int} y * @param {Int} width * @memberof Window_Base */ drawActorNickname(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the actor level at the specified x and y coordinates. * * @param {Game_Actor} actor * @param {Int} x * @param {Int} y * @memberof Window_Base */ drawActorLevel(actor: Game_Actor, x: number, y: number): void; /** * Draws the actor icons at the specified x and y coordinates * within the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorIcons(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the current and max number at the specified x and y coordinate * within the given width. Color1 represents the current number and color2 * represents the max number when the text is drawn. * @param {number} current * @param {number} max * @param {number} x * @param {number} y * @param {number} width * @param {String} color1 * @param {String} color2 * @memberof Window_Base */ drawCurrentAndMax(current: number, max: number, x: number, y: number, width: number, color1: string, color2: string): void; /** * Draws the actor hp at the specified x and y coordinates within * the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorHp(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the actor mp at the specified x and y coordinates within * the given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorMp(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the actor tp at the specified x and y coordinates within the * given width. * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorTp(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws a simple status for the game actor passed into the method at the * specified x and y coordinates within the given width. * * @param {Game_Actor} actor * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawActorSimpleStatus(actor: Game_Actor, x: number, y: number, width: number): void; /** * Draws the item name at the specified x and y coordinates within * the given width. * @param {RPG.BaseItem} item * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawItemName(item: rm.types.BaseItem, x: number, y: number, width: number): void; /** * Draws the currency value given at the specified x and y coordinates within * the width given. Useful if you want to write your own custom currency value. * @param {number} value * @param {String} unit * @param {number} x * @param {number} y * @param {number} width * @memberof Window_Base */ drawCurrencyValue(value: number, unit: string, x: number, y: number, width: number): void; /** * Changes the text color based on the powerUpColor, powerDownColor * and normal color. powerUpColor is any number greater than 0, powerDownColor * is any color less than 0, otherwise normal color is returned. * @param {number} change * @memberof Window_Base */ paramchangeTextColor(change: number): rm.types.Color; /** * Sets the background type of the window. * 0 is 255 window opacity (standard). * 1 is the window with background dimmer. * Any other number changes the opacity * to 0. * @param {number} type * @memberof Window_Base */ setBackgroundType(type: number): void; /** * Shows the background dimmer sprite. * * @memberof Window_Base */ showBackgroundDimmer(): void; /** * Hides the background dimmer sprite. * * @memberof Window_Base */ hideBackgroundDimmer(): void; /** * Updates the background dimmer sprite opacity based on the openness * of the window. * @memberof Window_Base */ updateBackgroundDimmer(): void; /** * Refreshes the bitmap attached to the dimmer sprite * based on the window dimensions. * @memberof Window_Base */ refreshDimmerBitmap(): void; /** * Color 1 of the dimmer sprite bitmap. * for the gradient. * @returns {String} * @memberof Window_Base */ dimColor1(): string; /** * Color 2 of the dimmer sprite bitmap * for the gradient. * @returns {String} * @memberof Window_Base */ dimColor2(): string; /** * Returns the x coordinate of the mouse to * a local window x coordinate. * @param {number} x * @returns {number} * @memberof Window_Base */ canvasToLocalX(x: number): number; /** * Returns the y coordinate of the mouse * to a local window y coordinate. * @param {number} y * @returns {number} * @memberof Window_Base */ canvasToLocalY(y: number): number; /** * Reverses the face images of the * game party members. * @memberof Window_Base */ reserveFaceImages(): void; static _iconWidth: number; static _iconHeight: number; static _faceWidth: number; static _faceHeight: number; } declare namespace rm.types { export type ConfigData = { alwaysDash: boolean; bgmVolume: number; bgsVolume: number; commandRemember: boolean; meVolume: number; seVolume: number; } } /** * Manages the configuration of RPGMakerMZ Config Data. */ declare class ConfigManager { protected constructor(); static load(): void; static save(): void; static makeData(): rm.types.ConfigData; static applyData(config: rm.types.ConfigData): void; static readFlag(config: rm.types.ConfigData, name: string): boolean; static readVolume(config: rm.types.ConfigData, name: string): number; } /** * Manages the game data: saving, loading, meta data, * and map information. */ declare class DataManager { protected constructor(); static _globalId: string; static _lastAccessId: number; static _errorUrl: any; static _databaseFiles: JSON[]; static loadDatabase(): void; static loadDataFile(name: string, src: string): void; static isDatabaseLoaded(): boolean; static loadMapData(mapId: number): void; static makeEmptyMap(): void; static isMapLoaded(): boolean; static onLoad(object: any): void; /** * Extracts Meta Data. A Json Like Object * @param data */ static extractMetaData(data: any): void; static checkError(): void; static isBattleTest(): boolean; static isEventTest(): boolean; /** * Returns a Bool value given an item. * Item being a database object representing a skill. * @static * @param {object} item * @returns {Bool} * @memberof DataManager */ static isSkill(item: rm.types.BaseItem): boolean; /** * Returns a Bool value given an item. * Item must be a database item to be true. * @static * @param {object} item * @returns {Bool} * @memberof DataManager */ static isItem(item: rm.types.BaseItem): boolean; /** * Returns a Bool value given an item. * Item must be a database weapon to be true. * @static * @param {object} item * @returns {Bool} * @memberof DataManager */ static isWeapon(item: rm.types.BaseItem): boolean; /** * Returns a Bool value given an item. * Item must be a database armor to be true. * @static * @param {object} item * @returns {Bool} * @memberof DataManager */ static isArmor(item: rm.types.BaseItem): boolean; static createGameObjects(): void; static setupNewGame(): void; static setupBattleTest(): void; static setupEventTest(): void; static loadGlobalInfo(): void; /** * JSON like object * @param info */ static saveGlobalInfo(info: any): void; /** * Returns a Bool value given a savefileId. * If the savefileId exists; the value will be true. * @static * @param {number} savefileId * @returns {Bool} * @memberof DataManager */ static isThisGameFile(savefileId: number): boolean; static isAnySavefileExists(): boolean; static latestSavefileId(): number; static loadAllSavefileImages(): void; /** * JSON Like Object for save file images */ static loadSavefileImages(info: any): void; /** * Returns the maximum number of save files * allocated in the game. * @static * @returns {number} * @memberof DataManager */ static maxSavefiles(): number; /** * Saves the RPGMakerMV game given a savefileId. * Returns true if successful. * @static * @param {number} savefileId * @returns {Bool} * @memberof DataManager */ static saveGame(savefileId: number): boolean; static loadGame(savefileId: number): boolean; /** * Returns the last accessed save fileId upon * saving or loading the game. * @static * @returns {number} * @memberof DataManager */ static lastAccessedSavefileId(): number; static saveGameWithoutRescue(savefileId: number): boolean; static loadGameWithoutRescue(savefileId: number): boolean; static selectSavefileForNewGame(): void; /** * Creates a new save file on the global * save file information containing important * data such as play time, characters, timestamp. * @static * @memberof DataManager */ static makeSavefileInfo(): void; /** * Creates the save file contents when saving your game. * Good for aliasing when you want to add more data * to the game's save contents. * @static * @returns {object} * @memberof DataManager */ static makeSaveContents(): any; /** * Extracts the save file contents into the game's * variables. An excellent method to alias when you * wish to extend the game's save contents for a plugin. * @static * @param {object} contents * @memberof DataManager */ static extractSaveContents(contents: any): void; } /** * Static class that manages images. Loading the images * and create bitmap objects. */ declare class ImageManager { protected constructor(); static cache: CacheMap; static loadFace(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/parallaxes/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadParallax(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/pictures/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadPicture(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/animations/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadAnimation(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/battlebacks1/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadBattleback1(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/battlebacks2/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadBattleback2(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/enemies/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadEnemy(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/characters/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadCharacter(filename: string, hue?: number): Bitmap; static loadSvActor(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/sv_enemies/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadSvEnemy(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from 'img/system/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadSystem(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/tilesets/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadTileset(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/titles1/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadTitle1(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from the 'img/titles2/' folder * and returns it. * @param {string} filename * @param {number} [hue] * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadTitle2(filename: string, hue?: number): Bitmap; /** * Loads a Bitmap object from any folder and returns it. * * @param {string} folder * @param {string} filename * @param {number} hue * @param {boolean} smooth * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadBitmap(folder: string, filename: string, hue: number, smooth: boolean): Bitmap; /** * Loads an empty Bitmap object and returns it. * * @param {string} path * @param {number} hue * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadEmptyBitmap(path: string, hue: number): Bitmap; /** * Loads a Bitmap object given a path * and returns it. * @param {string} path * @param {number} hue * @returns {Bitmap} * @memberof ImageManagerStatic */ static loadNormalBitmap(path: string, hue: number): Bitmap; /** * Clears the image cache in RPGMakerMV. * * @memberof ImageManagerStatic */ static clear(): void; /** * Returns true if the image cache * is ready. * @returns {boolean} * @memberof ImageManagerStatic */ static isReady(): boolean; /** * Returns true if the given filename * is an object character. Must contain * a '!' in the file name to be an * object character. * @param {string} filename * @returns {boolean} * @memberof ImageManagerStatic */ static isObjectCharacter(filename: string): boolean; /** * Returns true if the given filename is * a large character. Must contain a '$' * in the file name to be a large character. * @param {string} filename * @returns {boolean} * @memberof ImageManagerStatic */ static isBigCharacter(filename: string): boolean; static isZeroParallax(filename: string): boolean; } declare namespace rm.types { /** * Plugin Settings for RPGMakerMV/MZ */ export type PluginSettings = { /** * Plugin Description */ description: string; /** * Plugin Name */ name: string; /** * Plugin Parameters in a map/dictionary like syntax. * Example: * ```js * parameters["TextSpeed"] * ``` */ parameters: { [key: string]: any }; /** * Plugin Status On/Off */ status: string; } } /** * Static class that manages plugins */ declare class PluginManager { protected constructor(); static _path: string; static _scripts: string[]; static _errorUrls: string[]; static setup(plugins: rm.types.PluginSettings[]): void; static checkErrors(): void; /** * Returns all of the plugin parameters for an RPGMakerMZ * plugin in a JSON Like String Format. * Should typedef this for ease of parsing. * @param name * @return Any */ static parameters(name: string): any; /** * Uses internally by the Plugin Manager to load * the plugin scripts. * @param name */ static loadScript(name: string): void; static onError(e: Event): void; /** * Regsters a new plugin command in MZ using a lambda expression * The Variable of the lambda should be transformed into the appropriate * typed def struct for your use case for your command. * Example Syntax For Commented Parameters * *```js * //Should be in comment * @command PluginCommandFunctionName * @text My Plugin Command * @desc Plugin Command Description Text * @arg Actors * @text Which Actors? * @type actor[] * @desc Select which Actor ID(s) to affect. * @default ["1"] * @arg State * @text State * @type state * @desc Which State to apply? * @default 1 * PluginManager.registerCommand("TestPlugin", "PluginCommandFunctionName", args => { * // Get Arguments * const actorIds = JSON.parse(args.Actors); * const stateId = args.State; * // Use the arguments * for (const actorId of actorIds) { * const actor = $gameParty.members().find(member => member.actorId() === Number(actorId)); * if (actor) { * actor.addState(stateId); * } * } * }); * ``` * @param pluginName * @param commandName * @param lambda */ static registerCommand(pluginName: string, commandName: string, lambda: (arg0: any) => void): void; } /** * Manages the scenes of the game. */ declare class SceneManager { protected constructor(); static _scene: Scene_Base; static _nextScene: Scene_Base; static _stack: any[]; static _screenWidth: number; static _screenHeight: number; static _backgroundBitmap: Bitmap; static _boxWidth: number; static _boxHeight: number; static _deltaTime: number; static _currentTime: number; static _accumulator: number; /** * Convenience variable for getting the current scene. */ static _scene: any; static preferableRendererType(): string; static shouldUseCanvasRenderer(): boolean; static initialize(): void; static initGraphics(): void; static initAudio(): void; static initInput(): void; static initNwjs(): void; static update(): void; static terminate(): void; static tickStart(): void; static tickEnd(): void; static changeScene(): void; static updateScene(): void; static renderScene(): void; static onSceneCreate(): void; static onSceneStart(): void; static onSceneLoading(): void; static onError(e: Event): void; static onKeyDown(event: KeyboardEvent): void; static catchException(e: Event): void; static isSceneChanging(): boolean; static isCurrentSceneBusy(): boolean; static isCurrentSceneStarted(): boolean; static isNextScene(sceneClass: any): boolean; static isPreviousScene(sceneClass: any): boolean; /** * Goes to the scene passed in. * @param sceneClass */ static goto(sceneClass: any): void; /** * Pushes the scene passed in to the scene stack. * Immediately goes to the scene passed in. * @param sceneClass */ static push(sceneClass: any): void; /** * Pops the current scene from the stack. */ static pop(): void; /** * Exits the current scene. */ static exit(): void; static clearStack(): void; /** * Stops the current scene. */ static stop(): void; static prepareNextScene(): void; static snap(): Bitmap; static snapForBackground(): void; static backgroundBitmap(): Bitmap; static updateManagers(ticks: number, delta: number): void; } /** * Static class that plays sound effects defined in the database. */ declare class SoundManager { protected constructor(); static preloadImportantSounds(): void; static loadSystemSound(databaseNumber: number): void; static playSystemSound(databaseNumber: number): void; static playCursor(): void; static playOk(): void; static playCancel(): void; static playBuzzer(): void; static playEquip(): void; static playSave(): void; static playLoad(): void; static playBattleStart(): void; static playEscape(): void; static playEnemyAttack(): void; static playEnemyDamage(): void; static playEnemyCollapse(): void; static playBossCollapse1(): void; static playBossCollapse2(): void; static playActorDamage(): void; static playActorCollapse(): void; static playRecovery(): void; static playMiss(): void; static playEvasion(): void; static playMagicEvasion(): void; static playReflection(): void; static playShop(): void; static playUseItem(): void; static playUseSkill(): void; } /** * The static class that manages storage of save game data. */ declare class StorageManager { protected constructor(); static save(savefileId: number, json: string): void; static load(savefileId: number): string; static exists(savefileId: number): boolean; static remove(savefileId: number): void; static backup(savefileId: number): void; static backupExists(savefileId: number): boolean; static cleanBackup(savefileId: number): boolean; static restoreBackup(savefileId: number): void; static isLocalMode(): boolean; static saveToLocalFile(savefileId: number, json: string): void; static loadFromLocalFile(savefileId: number): string; static loadFromLocalBackupFile(savefileId: number): string; static localFileBackupExists(savefileId: number): boolean; static localFileExists(savefileId: number): boolean; static removeLocalFile(savefileId: number): void; static saveToWebStorage(savefileId: number, json: string): void; static loadFromWebStorage(savefileId: number): string; static loadFromWebStorageBackup(savefileId: number): string; static webStorageBackupExists(savefileId: number): boolean; static webStorageExists(savefileId: number): boolean; static removeWebStorage(savefileId: number): void; static localFileDirectoryPath(): string; static localFilePath(savefileId: number): string; static webStorageKey(savefileId: number): string; } /** * The static class that handles terms and messages. * This is linked to the terms and information * contained within the editor. */ declare class TextManager { protected constructor(); static currencyUnit: string; static level: string; static levelA: string; static hp: string; static hpA: string; static mp: string; static mpA: string; static tp: string; static tpA: string; static exp: string; static expA: string; static fight: string; static escape: string; static attack: string; static guard: string; static item: string; static skill: string; static equip: string; static status: string; static formation: string; static save: string; static gameEnd: string; static options: string; static weapon: string; static armor: string; static keyItem: string; static equip2: string; static optimize: string; static clear: string; static newGame: string; static continue_: string; static toTitle: string; static cancel: string; static buy: string; static sell: string; static alwaysDash: string; static commandRemember: string; static bgmVolume: string; static bgsVolume: string; static meVolume: string; static seVolume: string; static possession: string; static expTotal: string; static expNext: string; static saveMessage: string; static loadMessage: string; static file: string; static partyName: string; static emerge: string; static preemptive: string; static surprise: string; static escapeStart: string; static escapeFailure: string; static victory: string; static defeat: string; static obtainExp: string; static obtainGold: string; static obtainItem: string; static levelUp: string; static obtainSkill: string; static useItem: string; static criticalToEnemy: string; static criticalToActor: string; static actorDamage: string; static actorRecovery: string; static actorGain: string; static actorLoss: string; static actorDrain: string; static actorNoDamage: string; static actorNoHit: string; static enemyDamage: string; static enemyRecovery: string; static enemyGain: string; static enemyLoss: string; static enemyDrain: string; static enemyNoDamage: string; static enemyNoHit: string; static evasion: string; static magicEvasion: string; static magicReflection: string; static counterAttack: string; static substitute: string; static buffAdd: string; static debuffAdd: string; static buffRemove: string; static actionFailure: string; static basic(basicId: number): string; static param(paramId: number): string; static command(commandId: number): string; static message(messageId: string): string; static getter(method: string, param: number): string; } declare namespace rm.types { /** * The data class for enemy [Actions]. */ export type EnemyAction = { /** * The first parameter of the condition. */ conditionParam1: number; /** * The second parameter of the condition. */ conditionParam2: number; /** * The type of condition. * * 0: Always * 1: Turn No. * 2: HP * 3: MP * 4: State * 5: Party Level * 6: Switch */ conditionType: number; /** * The action's priority rating (1..10). */ rating: number; /** * The ID of skills to be employed as actions. */ skillId: number; } } declare namespace rm.types { /** * The data class for damage. */ export type Damage = { /** * Critical hit (true/false). */ critical: boolean; /** * The element ID. */ elementId: number; /** * The formula. */ formula: string; /** * The type of damage. * * 0: None * 1: HP damage * 2: MP damage * 3: HP recovery * 4: MP recovery * 5: HP drain * 6: MP drain */ type: number; /** * The degree of variability. */ variance: number; } } declare namespace rm.types { /** * The data class for use effects. */ export type Effect = { /** * The use effect code. */ code: number; /** * The ID of data (state, parameter, and so on) according to the type of use effect. */ dataId: number; /** * Value 1 set according to the type of use effect. */ value1: number; /** * Value 2 set according to the type of use effect. */ value2: number; } } declare namespace rm.types { export type UsableItem = { /** * The animation ID. */ animationId: number; /** * Damage (RPG.Damage). */ damage: rm.types.Damage; /** * The description text. */ description: string; /** * A list of use effects. An RPG.Effect array. */ effects: rm.types.Effect[]; /** * The type of hit. * * 0: Certain hit * 1: Physical attack * 2: Magical attack */ hitType: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; meta: Object; /** * The item name. */ name: string; note: string; /** * When the item/skill may be used. * * 0: Always * 1: Only in battle * 2: Only from the menu * 3: Never */ occasion: number; /** * The number of repeats. */ repeats: number; /** * The scope of effects. * * 0: None * 1: One Enemy * 2: All Enemies * 3: One Random Enemy * 4: Two Random Enemies * 5: Three Random Enemies * 6: Four Random Enemies * 7: One Ally * 8: All Allies * 9: One Ally (Dead) * 10: All Allies (Dead) * 11: The User */ scope: number; /** * The speed correction. */ speed: number; /** * The success rate. */ successRate: number; /** * The number of TP gained. */ tpGain: number; } } /** * Game_Action * The game object class representing a battle action. * @class Game_Action */ declare class Game_Action { constructor(subject: Game_Battler, forcing: boolean); _subjectActorId: number; _subjectEnemyIndex: number; _targetIndex: number; _forcing: boolean; _item: Game_Item; clear(): void; setSubject(subject: Game_Battler): void; subject(): Game_Battler; friendsUnit(): Game_Unit; opponentsUnit(): Game_Unit; setEnemyAction(action: rm.types.EnemyAction): void; setAttack(): void; setGuard(): void; setSkill(skillId: number): void; setItem(itemId: number): void; setItemObject(object: rm.types.UsableItem): void; setTarget(targetIndex: number): void; item(): rm.types.UsableItem; isSkill(): boolean; isItem(): boolean; numRepeats(): number; checkItemScope(list: number[]): boolean; isForOpponent(): boolean; isForFriend(): boolean; isForDeadFriend(): boolean; isForUser(): boolean; isForOne(): boolean; isForRandom(): boolean; isForAll(): boolean; needsSelection(): number; numTargets(): number; checkDamageType(list: number[]): boolean; isHpEffect(): boolean; isMpEffect(): boolean; isDamage(): boolean; isRecover(): boolean; isDrain(): boolean; isHpRecover(): boolean; isMpRecover(): boolean; isCertainHit(): boolean; isPhysical(): boolean; isMagical(): boolean; isAttack(): boolean; isGuard(): boolean; isMagicSkill(): boolean; decideRandomTarget(): void; setConfusion(): void; prepare(): void; isValid(): boolean; speed(): number; makeTargets(): Game_Battler[]; repeatTargets(targets: Game_Battler[]): Game_Battler[]; confusionTarget(): Game_Battler; targetsForOpponents(): Game_Battler[]; targetsForFriends(): Game_Battler[]; evaluate(): number; itemTargetCandidates(): Game_Battler[]; evaluateWithTarget(target: Game_Battler): number; testApply(target: Game_Battler): boolean; hasItemAnyValidEffects(target: Game_Battler): boolean; testItemEffect(target: Game_Battler, effect: rm.types.Effect): boolean; itemCnt(target: Game_Battler): number; itemMrf(target: Game_Battler): number; itemHit(target: Game_Battler): number; itemEva(target: Game_Battler): number; itemCri(target: Game_Battler): number; apply(target: Game_Battler): void; makeDamageValue(target: Game_Battler, critical: boolean): number; evalDamageFormula(target: Game_Battler): number; calcElementRate(target: Game_Battler): number; elementsMaxRate(target: Game_Battler, elements: number[]): number; applyCritical(damage: number): number; applyVariance(damage: number, variance: number): number; applyGuard(damage: number, target: Game_Battler): number; executeDamage(target: Game_Battler, value: number): void; executeHpDamage(target: Game_Battler, value: number): void; executeMpDamage(target: Game_Battler, value: number): void; gainDrainedHp(value: number): void; gainDrainedMp(value: number): void; applyItemEffect(target: Game_Battler, effect: rm.types.Effect): void; itemEffectRecoverHp(target: Game_Battler, effect: rm.types.Effect): void; itemEffectRecoverMp(target: Game_Battler, effect: rm.types.Effect): void; itemEffectGainTp(target: Game_Battler, effect: rm.types.Effect): void; itemEffectAddState(target: Game_Battler, effect: rm.types.Effect): void; itemEffectAddAttackState(target: Game_Battler, effect: rm.types.Effect): void; itemEffectAddNormalState(target: Game_Battler, effect: rm.types.Effect): void; itemEffectRemoveState(target: Game_Battler, effect: rm.types.Effect): void; itemEffectAddBuff(target: Game_Battler, effect: rm.types.Effect): void; itemEffectAddDebuff(target: Game_Battler, effect: rm.types.Effect): void; itemEffectRemoveBuff(target: Game_Battler, effect: rm.types.Effect): void; itemEffectRemoveDebuff(target: Game_Battler, effect: rm.types.Effect): void; itemEffectSpecial(target: Game_Battler, effect: rm.types.Effect): void; itemEffectGrow(target: Game_Battler, effect: rm.types.Effect): void; itemEffectLearnSkill(target: Game_Battler, effect: rm.types.Effect): void; itemEffectCommonEvent(target: Game_Battler, effect: rm.types.Effect): void; makeSuccess(target: Game_Battler): void; applyItemUserEffect(target: Game_Battler): void; lukEffectRate(target: Game_Battler): number; applyGlobal(): void; static EFFECT_RECOVER_HP: number; static EFFECT_RECOVER_MP: number; static EFFECT_GAIN_TP: number; static EFFECT_ADD_STATE: number; static EFFECT_REMOVE_STATE: number; static EFFECT_ADD_BUFF: number; static EFFECT_ADD_DEBUFF: number; static EFFECT_REMOVE_BUFF: number; static EFFECT_REMOVE_DEBUFF: number; static EFFECT_SPECIAL: number; static EFFECT_GROW: number; static EFFECT_LEARN_SKILL: number; static EFFECT_COMMON_EVENT: number; static SPECIAL_EFFECT_ESCAPE: number; static HITTYPE_CERTAIN: number; static HITTYPE_PHYSICAL: number; static HITTYPE_MAGICAL: number; } declare namespace haxe.display { } declare namespace haxe.display { } declare namespace rm.types { export type Trait = { /** * The trait code. */ code: number; /** * The ID of the data (such as elements or states) according to the type of the trait. */ dataId: number; /** * The map tree expansion flag, which is used internally. */ expanded: boolean; /** * The x-axis scroll position, which is used internally. */ scrollX: number; /** * The y-axis scroll position, which is used internally. */ scrollY: number; /** * The value set according to the type of the trait. */ value: number; } } declare namespace rm.types { /** * The data class for state. */ export type State = { /** * The timing of automatic state removal. * * 0: None * 1: At end of action * 2: At end of turn */ autoRemovalTiming: number; /** * Chance of state being removed by damage (%). */ chanceByDamage: number; description: string; doc: string; /** * The icon number. */ iconIndex: number; /** * The ID. */ id: number; internal: boolean; links: string[]; /** * The maximum turns of the duration. */ maxTurns: number; /** * The message when an actor fell in the state. */ message1: string; /** * The message when an enemy fell in the state. */ message2: string; /** * The message when the state remains. */ message3: string; /** * The message when the state is removed. */ message4: number; /** * The minimum turns of the duration. */ minTurns: number; /** * The side-view motion. */ motion: number; /** * The name. */ name: string; /** * The side-view overlay. */ overlay: number; parameters: string[]; platforms: haxe.display.Platform[]; /** * The state priority (0..100). */ priority: number; releaseByDamage: boolean; /** * Removes state at end of battle (true/false). */ removeAtBattleEnd: boolean; /** * Removes state by damage (true/false). */ removeByDamage: boolean; /** * Removes state by action restriction (true/false). */ removeByRestriction: boolean; /** * Removes state by walking (true/false). */ removeByWalking: boolean; /** * Action restrictions. * * 0: None * 1: Attack enemy * 2: Attack enemy or ally * 3: Attack ally * 4: Cannot act */ restriction: number; /** * Number of steps until state is removed. */ stepToRemove: number; targets: haxe.display.MetadataTarget[]; /** * The array of Trait data. */ traits: rm.types.Trait[]; } } /** * ----------------------------------------------------------------------------- * Game_ActionResult * * The game object declare class for a result of a battle action. For convinience, all * member variables in this declare class are public. * @class Game_ActionResult */ declare class Game_ActionResult { constructor(); used: boolean; missed: boolean; evaded: boolean; physical: boolean; drain: boolean; critical: boolean; success: boolean; hpAffected: boolean; hpDamage: number; mpDamage: number; tpDamage: number; addedStates: number[]; removedStates: number[]; addedBuffs: number[]; addedDebuffs: number[]; removedBuffs: number[]; initialize(): void; /** * Clears the game action result. * * @memberof Game_ActionResult */ clear(): void; /** * Returns the added states from the action result. * * @returns {Array} * @memberof Game_ActionResult */ addedStateObjects(): rm.types.State[]; /** * Returns the removes states from the result. * * @returns {Array} * @memberof Game_ActionResult */ removedStateObjects(): rm.types.State[]; isStatusAffected(): boolean; /** * Returns true if the action result is a hit. * * @returns {Bool} * @memberof Game_ActionResult */ isHit(): boolean; isStateAdded(stateId: number): boolean; pushAddedState(stateId: number): void; isStateRemoved(stateId: number): boolean; pushRemovedState(stateId: number): void; /** * Returns true if the a buff is added to the specified param * from the action result. * @param {number} paramId * @returns {Bool} * @memberof Game_ActionResult */ isBuffAdded(paramId: number): boolean; pushAddedBuff(paramId: number): void; isDebuffAdded(paramId: number): boolean; pushAddedDebuff(paramId: number): void; isBuffRemoved(paramId: number): boolean; pushRemovedBuff(paramId: number): void; } declare namespace rm.types { /** * The data class for skills. */ export type Skill = { /** * The animation ID. */ animationId: number; /** * Damage (RPG.Damage). */ damage: rm.types.Damage; /** * The description text. */ description: string; /** * A list of use effects. An RPG.Effect array. */ effects: rm.types.Effect[]; /** * The type of hit. * * 0: Certain hit * 1: Physical attack * 2: Magical attack */ hitType: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; /** * The use message. */ message1: string; /** * The use message. */ message2: string; meta: Object; /** * Number of MP consumed. */ mpCost: number; /** * The item name. */ name: string; note: string; /** * When the item/skill may be used. * * 0: Always * 1: Only in battle * 2: Only from the menu * 3: Never */ occasion: number; /** * The number of repeats. */ repeats: number; /** * Weapon type required. */ requiredWtypeId1: number; /** * Weapon type required. */ requiredWtypeId2: number; /** * The scope of effects. * * 0: None * 1: One Enemy * 2: All Enemies * 3: One Random Enemy * 4: Two Random Enemies * 5: Three Random Enemies * 6: Four Random Enemies * 7: One Ally * 8: All Allies * 9: One Ally (Dead) * 10: All Allies (Dead) * 11: The User */ scope: number; /** * The speed correction. */ speed: number; /** * Skill type ID. */ stypeId: number; /** * The success rate. */ successRate: number; /** * Number of TP consumed */ tpCost: number; /** * The number of TP gained. */ tpGain: number; } } declare namespace rm.types { /** * The data class for items. */ export type Item = { /** * The animation ID. */ animationId: number; /** * The truth value indicating whether the item disappears when used. */ consumable: boolean; /** * Damage (RPG.Damage). */ damage: rm.types.Damage; /** * The description text. */ description: string; /** * A list of use effects. An RPG.Effect array. */ effects: rm.types.Effect[]; /** * The type of hit. * * 0: Certain hit * 1: Physical attack * 2: Magical attack */ hitType: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; /** * The item type ID. * * 1: Regular item * 2: Key item */ itypeId: number; meta: Object; /** * The item name. */ name: string; note: string; /** * When the item/skill may be used. * * 0: Always * 1: Only in battle * 2: Only from the menu * 3: Never */ occasion: number; /** * The item's price. */ price: number; /** * The number of repeats. */ repeats: number; /** * The scope of effects. * * 0: None * 1: One Enemy * 2: All Enemies * 3: One Random Enemy * 4: Two Random Enemies * 5: Three Random Enemies * 6: Four Random Enemies * 7: One Ally * 8: All Allies * 9: One Ally (Dead) * 10: All Allies (Dead) * 11: The User */ scope: number; /** * The speed correction. */ speed: number; /** * The success rate. */ successRate: number; /** * The number of TP gained. */ tpGain: number; } } declare namespace rm.types { /** * A superclass of weapons and armor. */ export type EquipItem = { /** * The description text. */ description: string; /** * The type of weapon or armor. * * 0: Weapon * 1: Shield * 2: Head * 3: Body * 4: Accessory */ etypeId: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; meta: Object; /** * The item name. */ name: string; note: string; /** * The amount of parameter change. An array of integers using the following IDs as subscripts: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck */ params: number[]; /** * The price of the weapon or armor. */ price: number; /** * The array of Trait data. */ traits: rm.types.Trait[]; } } /** * ----------------------------------------------------------------------------- * Game_BattlerBase * * The superdeclare class of Game_Battler. It mainly contains parameters calculation. * @class Game_BattlerBase */ declare class Game_BattlerBase { constructor(); initialize(): void; _hp: number; _mp: number; _tp: number; _hidden: boolean; _paramPlus: number[]; _states: number[]; /** * [stateId: Int]:Int * } * Access using number/integer */ _stateTurns: { [key: string]: any }; _buffs: number[]; _buffTurns: number[]; /** * [read-only] Hit Points */ readonly hp: number; /** * [read-only] Magic Points */ readonly mp: number; /** * [read-only] Tactical Points */ readonly tp: number; /** * [read-only] Maximum Hit Points - param 0 */ readonly mhp: number; /** * [read-only] Maximum Magic Points - param 1 */ readonly mmp: number; /** * [read-only] ATtacK power - param 2 */ readonly atk: number; /** * [read-only] DEFense power - param 3 */ readonly def: number; /** * [read-only] Magic Attack power - param 4 */ readonly mat: number; /** * [read-only] Magic Defense power - param 5 */ readonly mdf: number; /** * [read-only] Agility - param 6 */ readonly agi: number; /** * [read-only] LucK - param 7 */ readonly luk: number; /** * [read-only] HIT rate -xparam 0 */ readonly hit: number; /** * [read-only] EVAsion rate */ readonly eva: number; /** * [read-only] CRItical rate */ readonly cri: number; /** * [read-only] Critical EVasion rate */ readonly cev: number; /** * [read-only] Magic EVasion rate */ readonly mev: number; /** * [read-only] Magic ReFlection rate */ readonly mrf: number; /** * [read-only] CouNTer attack rate */ readonly cnt: number; /** * [read-only] Hp ReGeneration rate */ readonly hrg: number; /** * [read-only] Mp ReGeneration rate */ readonly mrg: number; /** * [read-only] Tp ReGeneration rate */ readonly trg: number; /** * [read-only] TarGet Rate */ readonly tgr: number; /** * [read-only] Ggweqrtg*xzuaRD effect rate */ readonly grd: number; /** * [read-only] RECovery effect rate */ readonly rec: number; /** * [read-only] PHArmacology */ readonly pha: number; /** * [read-only] Mp Cost Rate */ readonly mcr: number; /** * [read-only] Tp Charge Rate */ readonly tcr: number; /** * [read-only] Physical Damage Rate */ readonly pdr: number; /** * [read-only] Magical Damage Rate */ readonly mdr: number; /** * [read-only] Floor Damage Rate */ readonly fdr: number; /** * [read-only] EXperience Rate */ readonly exr: number; initMembers(): void; /** * Clears any modifications to * the base parameters. */ clearParamPlus(): void; /** * Clears states applied to the actors. */ clearStates(): void; /** * Erases the current state from the game battler given the * stateId in the editor database. * @param {number} stateId * @memberof Game_BattlerBase */ eraseState(stateId: number): void; /** * Returns true if the battler is affected by the specified state given * the state id. * @param {number} stateId * @returns {Bool} * @memberof Game_BattlerBase */ isStateAffected(stateId: number): boolean; isDeathStateAffected(): boolean; /** * Returns the death state id. * * @returns {number} * @memberof Game_BattlerBase */ deathStateId(): number; /** * Resets the state count of the specified state, given the state id. * * @param {number} stateId * @memberof Game_BattlerBase */ resetStateCounts(stateId: number): void; /** * Returns true if the state, given the state id is expired. * * @param {number} stateId * @returns {Bool} * @memberof Game_BattlerBase */ isStateExpired(stateId: number): boolean; updateStateTurns(): void; /** * Clears buffs from the battler. * * @memberof Game_BattlerBase */ clearBuffs(): void; eraseBuff(paramId: number): void; /** * Returns the length of the buff. * * @returns {number} * @memberof Game_BattlerBase */ buffLength(): number; /** * Buffs the current parameter id. * * @param {number} paramId * @returns {number} * @memberof Game_BattlerBase */ buff(paramId: number): number; isBuffAffected(paramId: number): boolean; isDebuffAffected(paramId: number): boolean; isBuffOrDebuffAffected(paramId: number): boolean; isMaxBuffAffected(paramId: number): boolean; isMaxDebuffAffected(paramId: number): boolean; increaseBuff(paramId: number): void; decreaseBuff(paramId: number): void; overwriteBuffTurns(paramId: number, turns: number): void; isBuffExpired(paramId: number): boolean; /** * Updates the buff turns on battler. * * @memberof Game_BattlerBase */ updateBuffTurns(): void; /** * Kills the battler. * * @memberof Game_BattlerBase */ die(): void; /** * Revives the battler. * * @memberof Game_BattlerBase */ revive(): void; /** * Returns the states applied to the battler. * * @returns {Array} * @memberof Game_BattlerBase */ states(): rm.types.State[]; /** * Returns the array of state icons attached to the battler; * this is determined by the active states on the battler. * @returns {Array} * @memberof Game_BattlerBase */ stateIcons(): number[]; /** * Returns the array of buff icons attached to the battler; * this is determined by the active buffs on the battler. * @returns {Array} * @memberof Game_BattlerBase */ buffIcons(): number[]; buffIconIndex(buffLevel: number, paramId: number): number; /** * Returns all of the icons attached to the battler. * * @returns {Array} * @memberof Game_BattlerBase */ allIcons(): number[]; /** * Returns the trait object to the user * @return Array */ traitObjects(): any[]; /** * Returns all the traits of the battler. * * @returns {Array} * @memberof Game_BattlerBase */ allTraits(): rm.types.Trait[]; traits(code: number): rm.types.Trait[]; traitsWithId(code: number, traitId: number): rm.types.Trait[]; traitsPi(code: number, traitId: number): number; traitsSum(code: number, traitId: number): number; traitsSumAll(code: number): number; traitsSet(code: number): number[]; /** * Returns the base parameters of the battler; this is determined by their * current level and the paramId given. * @param {number} paramId * @returns {number} * @memberof Game_BattlerBase */ paramBase(paramId: number): number; paramPlus(paramId: number): number; paramMin(paramId: number): number; paramMax(paramId: number): number; paramRate(paramId: number): number; paramBuffRate(paramId: number): number; /** * Returns a standard parameter, given a paramId; * standard parameters include: HP, MP, Atk, M.Atk, Def, M.Def, Luck, Agility. * @param {number} paramId * @returns {number} * @memberof Game_BattlerBase */ param(paramId: number): number; /** * Returns the Extra parameter, given a x parameter id. * These include * Hit rate * Evasion rate * Critical rate * Magic evasion rate * Magic reflection rate * Counter attack rate * Hp regeneration rate * Mp regeneration rate * Tp regeneration rate * @param xparamId * @return Int */ xparam(xparamId: number): number; sparam(sparamId: number): number; elementRate(elementId: number): number; debuffRate(paramId: number): number; stateRate(stateId: number): number; stateResistSet(): number[]; isStateResist(stateId: number): boolean; /** * Returns the attack elements of the battler * as a list of numbers. * @returns {Array} * @memberof Game_BattlerBase */ attackElements(): number[]; /** * Returns the attack states of the battler as a * list of numbers. * @returns {Array} * @memberof Game_BattlerBase */ attackStates(): number[]; attackStatesRate(stateId: number): void; /** * Returns the attack speed of the battler. * * @returns {number} * @memberof Game_BattlerBase */ attackSpeed(): number; /** * Returns the number of attacks available to the battler. * * @returns {number} * @memberof Game_BattlerBase */ attackTimesAdd(): number; /** * Returns an array of integers * representing skill type ids. * @return Array */ addedSkillTypes(): number[]; isSkillTypeSealed(skilltypeId: number): boolean; addedSkills(): number[]; isSkillSealed(skillId: number): boolean; isEquipWtypeOk(weaponTypeId: number): boolean; isEquipAtypeOk(armorTypeId: number): boolean; isEquipTypeLocked(equipmentTypeId: number): boolean; isEquipTypeSealed(equipmentTypeId: number): boolean; /** * Returns the battler slot type of a trait. * * @returns {number} * @memberof Game_BattlerBase */ slotType(): number; /** * Returns true if the battler dual wields. * * @returns {Bool} * @memberof Game_BattlerBase */ isDualWield(): boolean; actionPlusSet(): number[]; /** * Takes a special flag * @param flagId * @return Bool */ specialFlag(flagId: number): boolean; /** * Returns the collapse type of the battler. * This is represented as an Int. * @returns {Int} * @memberof Game_BattlerBase */ collapseType(): number; partyAbility(abilityId: number): boolean; /** * Returns true if the battler is set to battle automatically. * * @returns {Bool} * @memberof Game_BattlerBase */ isAutoBattle(): boolean; /** * Returns true if the battler is guarding. * * @returns {Bool} * @memberof Game_BattlerBase */ isGuard(): boolean; isSubstitute(): boolean; /** * Returns true if tp is preserved between battles. * * @returns {Bool} * @memberof Game_BattlerBase */ isPreserveTp(): boolean; addParam(paramId: number, value: number): void; /** * Sets the battler hp. * * @param {number} hp * @memberof Game_BattlerBase */ setHp(hp: number): void; /** * Sets the battler mp. * * @param {number} mp * @memberof Game_BattlerBase */ setMp(mp: number): void; /** * Sets the battler tp. * * @param {number} tp * @memberof Game_BattlerBase */ setTp(tp: number): void; /** * Returns the maximum tp of the battler. * * @returns {number} * @memberof Game_BattlerBase */ maxTp(): number; /** * Refreshes the battler. * * @memberof Game_BattlerBase */ refresh(): void; /** * Recovers the battler from all states and restores the * battler to maximum hp and mp. * @memberof Game_BattlerBase */ recoverAll(): void; /** * Returns the percentage of the battler's hp left as a float. * * @returns {number} * @memberof Game_BattlerBase */ hpRate(): number; /** * Returns the percentage of the battler's mp left as a float. * * @returns {number} * @memberof Game_BattlerBase */ mpRate(): number; /** * Returns the percentage of the battler's tp left as a float. * * @returns {number} * @memberof Game_BattlerBase */ tpRate(): number; /** * Hides the game battler. * * @memberof Game_BattlerBase */ hide(): void; /** * Shows the game battler. * * @memberof Game_BattlerBase */ appear(): void; /** * Returns true if the game battler is hidden. * * @returns {Bool} * @memberof Game_BattlerBase */ isHidden(): boolean; /** * Returns true if the game battler is not hidden. * * @returns {Bool} * @memberof Game_BattlerBase */ isAppeared(): boolean; /** * Returns true if the battler is dead. * * @returns {Bool} * @memberof Game_BattlerBase */ isDead(): boolean; /** * Returns true if the battler is alive. * * @returns {Bool} * @memberof Game_BattlerBase */ isAlive(): boolean; /** * Returns true if the battler is dying. * * @returns {Bool} * @memberof Game_BattlerBase */ isDying(): boolean; /** * Returns true if the game battler is restricted. * * @returns {Bool} * @memberof Game_BattlerBase */ isRestricted(): boolean; /** * Returns true if the battler can input actions. * * @returns {Bool} * @memberof Game_BattlerBase */ canInput(): boolean; canMove(): boolean; /** * Returns true if the battler is confused. * * @returns {Bool} * @memberof Game_BattlerBase */ isConfused(): boolean; /** * Returns the confusion level of the battler. * * @returns {number} * @memberof Game_BattlerBase */ confusionLevel(): number; /** * Returns true if the battler is an actor. * * @returns {Bool} * @memberof Game_BattlerBase */ isActor(): boolean; /** * Returns true if the battler is an enemy. * * @returns {Bool} * @memberof Game_BattlerBase */ isEnemy(): boolean; /** * Sorts the states attached to the battler. * * @memberof Game_BattlerBase */ sortStates(): void; /** * Returns the number of the restriction. * * @returns {number} * @memberof Game_BattlerBase */ restriction(): number; /** * Adds a new state given a state id to the battler. * * @param {number} stateId * @memberof Game_BattlerBase */ addNewState(stateId: number): void; /** * Handler for when the battler is restricted. * * @memberof Game_BattlerBase */ onRestrict(): void; mostImportantStateText(): string; stateMotionIndex(): number; stateOverlayIndex(): number; /** * Returns true if the skill is a weapon type * oriented skill. * @param {RPG.Skill} skill * @returns {Bool} * @memberof Game_BattlerBase */ isSkillWtypeOk(skill: rm.types.Skill): boolean; /** * Returns the mp cost of the skill. * * @param {RPG.Skill} skill * @returns {number} * @memberof Game_BattlerBase */ skillMpCost(skill: rm.types.Skill): number; /** * Returns the tp cost of the skill. * * @param {RPG.Skill} skill * @returns {number} * @memberof Game_BattlerBase */ skillTpCost(skill: rm.types.Skill): number; /** * Returns true if the battler can pay the cost * of the specified skill. * @param {RPG.Skill} skill * @returns {Bool} * @memberof Game_BattlerBase */ canPaySkillCost(skill: rm.types.Skill): boolean; /** * Pays the cost of the skill when activating the skill. * * @param {RPG.Skill} skill * @memberof Game_BattlerBase */ paySkillCost(skill: rm.types.Skill): void; /** * Returns true if the item occasion is okay. * * @param {RPG.UsableItem} item * @returns {Bool} * @memberof Game_BattlerBase */ isOccasionOk(item: rm.types.UsableItem): boolean; meetsUsableItemConditions(item: rm.types.UsableItem): boolean; /** * Returns true if the battler meets the skill conditions. * * @param {RPG.Skill} skill * @returns {Bool} * @memberof Game_BattlerBase */ meetsSkillConditions(skill: rm.types.Skill): boolean; /** * Returns true if the battler meets the item conditions. * * @param {RPG.Item} item * @returns {Bool} * @memberof Game_BattlerBase */ meetsItemConditions(item: rm.types.Item): boolean; /** * Returns true if the battler can use the item. * * @param {RPG.UsableItem} item * @returns {Bool} * @memberof Game_BattlerBase */ canUse(item: rm.types.UsableItem): boolean; /** * Returns true if the battler can equip the item. * * @param {RPG.EquipItem} item * @returns {Bool} * @memberof Game_BattlerBase */ canEquip(item: rm.types.EquipItem): boolean; /** * Returns true if the battler can equip a weapon. * * @param {RPG.EquipItem} item * @returns {Bool} * @memberof Game_BattlerBase */ canEquipWeapon(item: rm.types.EquipItem): boolean; /** * Returns true if the battler can equip armor. * * @param {RPG.EquipItem} item * @returns {Bool} * @memberof Game_BattlerBase */ canEquipArmor(item: rm.types.EquipItem): boolean; /** * Returns the attack skill id in the database. * * @returns {number} * @memberof Game_BattlerBase */ attackSkillid(): number; /** * Returns the guard skill id in the database. * * @returns {number} * @memberof Game_BattlerBase */ guardSkillId(): number; /** * Returns true if the battler can attack. * * @returns {Bool} * @memberof Game_BattlerBase */ canAttack(): boolean; /** * Returns true if the battler can guard. * * @returns {Bool} * @memberof Game_BattlerBase */ canGuard(): boolean; /** * Trait element rate; default to 11. */ static TRAIT_ELEMENT_RATE: number; /** * Debuff Rate; default to 12. */ static TRAIT_DEBUFF_RATE: number; /** * Trait state rate; default to 13. */ static TRAIT_STATE_RATE: number; /** * Trait state resist; default to 14. */ static TRAIT_STATE_RESIST: number; /** * Trait param; default to 21. */ static TRAIT_PARAM: number; /** * Trait x param; default to 22. */ static TRAIT_XPARAM: number; /** * Trait s param; default to 23. */ static TRAIT_SPARAM: number; /** * Trait attack element; default to 31. */ static TRAIT_ATTACK_ELEMENT: number; /** * Trait attack state; default to 32. */ static TRAIT_ATTACK_STATE: number; /** * Trait attack speed; default to 33. */ static TRAIT_ATTACK_SPEED: number; /** * Trait attack times; default to 34. */ static TRAIT_ATTACK_TIMES: number; /** * Trait Stype(Skill type ) add; default to 41. */ static TRAIT_STYPE_ADD: number; /** * Trait Stype(Skill type) seal; default to 42. */ static TRAIT_STYPE_SEAL: number; /** * Trait Skill add; default to 43. */ static TRAIT_SKILL_ADD: number; /** * Trait skill seal; default to 44. */ static TRAIT_SKILL_SEAL: number; /** * Trait WType(equip weapon type); default to 51. */ static TRAIT_EQUIP_WTYPE: number; /** * Trait AType(Equip armor type); default to 52. */ static TRAIT_EQUIP_ATYPE: number; /** * Trait equipment lock; default to 53. */ static TRAIT_EQUIP_LOCK: number; /** * Trait equipment seal; default to 54. */ static TRAIT_EQUIP_SEAL: number; /** * Trait slot type;default to 55. */ static TRAIT_SLOT_TYPE: number; /** * Trait action plus; default to 61. */ static TRAIT_ACTION_PLUS: number; /** * Trait special flag; default to 62. */ static TRAIT_SPECIAL_FLAG: number; /** * Trait collapse type; default to 63. */ static TRAIT_COLLAPSE_TYPE: number; /** * Trait party ability; default to 64. */ static TRAIT_PARTY_ABILITY: number; /** * Flag ID auto battle; default to 0; */ static FLAG_ID_AUTO_BATTLE: number; /** * Flag ID guard; default to 1. */ static FLAG_ID_GUARD: number; /** * Flag Id substitude; default to 2. */ static FLAG_ID_SUBSTITUTE: number; /** * Flag id preserve type; default to 3. */ static FLAG_ID_PRESERVE_TP: number; /** * Icon buff start, default to 32. */ static ICON_BUFF_START: number; /** * Icon debuff start; default to 48. */ static ICON_DEBUFF_START: number; } declare namespace rm.types { export type BattlerAnimation = { animationId: number; delay: number; mirror: boolean; } } declare namespace rm.types { export const enum MotionType { WALK = "walk", WAIT = "wait", CHANT = "chant", GUARD = "guard", DAMAGE = "damage", EVADE = "evade", THRUST = "thrust", MISSLE = "missle", SKILL = "SKILL", SPELL = "spell", ITEM = "item", ESCAPE = "escape", VICTORY = "victory", DYING = "dying", ABNORMAL = "abnormal", SLEEP = "sleep", DEAD = "dead", } } declare namespace rm.types { export const enum WeaponImageId { base = -1, } } declare namespace rm.types { export const enum AnimationId { base = -1, } } declare namespace rm.types { export const enum ActionState { base = "", } } declare class Game_Battler extends Game_BattlerBase { protected constructor(); _actions: Game_Action[]; _speed: number; _result: Game_ActionResult; _actionState: string; _lastTargetIndex: number; _animations: rm.types.BattlerAnimation[]; _damagePopup: boolean; _effectType: string; _motionType: rm.types.MotionType; _weaponImageId: number; _motionRefresh: boolean; _selected: boolean; /** * Returns the name of the battler. * * @returns {String} * @memberof Game_Battler */ name(): string; /** * Returns the battler name of the battler; * the battler name is associated with the file used as the battler graphic. * @returns {String} * @memberof Game_Battler */ battlerName(): string; /** * Returns the index of the battler. * * @returns {number} * @memberof Game_Battler */ index(): number; /** * Returns the unit of the battler; this is either the * game party or game troop. * @returns {Game_Unit} * @memberof Game_Battler */ friendsUnit(): Game_Unit; /** * Returns the opponents unit; this is either * game party or game troop. * @returns {Game_Unit} * @memberof Game_Battler */ opponentsUnit(): Game_Unit; /** * Clears animations from the battler. * * @memberof Game_Battler */ clearAnimations(): void; /** * Clear damage pop up from the battler. * * @memberof Game_Battler */ clearDamagePopup(): void; /** * Clear weapon animation from the battler. * * @memberof Game_Battler */ clearWeaponAnimation(): void; /** * Clears effect from the battler. * * @memberof Game_Battler */ clearEffect(): void; /** * Clears motion from the battler. * * @memberof Game_Battler */ clearMotion(): void; requestEffect(effectType: string): void; /** * Request the specified motion on the game battler. * * @param {String} motionType * @memberof Game_Battler */ requestMotion(motionType: string): void; requestMotionRefresh(): void; select(): void; deselect(): void; isAnimationRequested(): boolean; isDamagePopupRequested(): boolean; isEffectRequested(): boolean; /** * Returns true if a motion is requested. * * @returns {Bool} * @memberof Game_Battler */ isMotionRequested(): boolean; /** * Returns true if a weapon animation is requested. * * @returns {Bool} * @memberof Game_Battler */ isWeaponAnimationRequested(): boolean; isMotionRefreshRequested(): boolean; isSelected(): boolean; /** * Returns the effect type of the battler. * * @returns {String} * @memberof Game_Battler */ effectType(): string; /** * Returns the motion type of the battler. * * @returns {String} * @memberof Game_Battler */ motionType(): string; /** * Returns the weapon image id. * * @returns {number} * @memberof Game_Battler */ weaponImageId(): rm.types.WeaponImageId; /** * Shifts the battler animation. * * @returns {BattlerAnimation} * @memberof Game_Battler */ shiftAnimation(): rm.types.BattlerAnimation; /** * Starts the specified animation, given the animation id on the * battler. * @param {number} animationId * @param {Bool} mirror * @param {number} delay * @memberof Game_Battler */ startAnimation(animationId: rm.types.AnimationId, mirror: boolean, delay: number): void; /** * Starts a damage pop up on the battler. * * @memberof Game_Battler */ startDamagePopup(): void; /** * Starts the weapon animation on te battler given a weapon id. * * @param {number} weaponImageId * @memberof Game_Battler */ startWeaponAnimation(weaponImageId: rm.types.WeaponImageId): void; action(index: number): Game_Action; /** * Sets the action at the specified index for the battler. * * @param {number} index * @param {Game_Action} action * @memberof Game_Battler */ setAction(index: number, action: Game_Action): void; /** * Returns the number of battler actions. * * @returns {number} * @memberof Game_Battler */ numActions(): number; /** * Clears the battler actions. * * @memberof Game_Battler */ clearActions(): void; /** * Returns the battler action result. * * @returns {Game_ActionResult} * @memberof Game_Battler */ result(): Game_ActionResult; /** * Clears the battler action result. * * @memberof Game_Battler */ clearResult(): void; /** * Refreshes the battler. * * @memberof Game_Battler */ refresh(): void; /** * Adds a state to the battler given the specified * state id. * @param {number} stateId * @memberof Game_Battler */ addState(stateId: number): void; /** * Returns true if the specified state given the state id * is addable. * @param {number} stateId * @returns {Bool} * @memberof Game_Battler */ isStateAddable(stateId: number): boolean; /** * Returns true if the specified state given the state id * restricts. * * @param {number} stateId * @returns {Bool} * @memberof Game_Battler */ isStateRestrict(stateId: number): boolean; /** * Handler for when theb attler is restricted. * * @memberof Game_Battler */ onRestrict(): void; /** * Removes the specified state given the state id. * * @param {number} stateId * @memberof Game_Battler */ removeState(stateId: number): void; /** * Has the battler escape from battle; plays a sound on escaping. * * @memberof Game_Battler */ escape(): void; /** * Adds a buff to the battler for the specified number of turns * on the selected parameter. * @param {number} paramId * @param {number} turns * @memberof Game_Battler */ addBuff(paramId: number, turns: number): void; /** * Adds a debuff to the battler for the specified number of turns * on the selected parameter. * @param {number} paramId * @param {number} turns * @memberof Game_Battler */ addDebuff(paramId: number, turns: number): void; removeBuff(paramId: number): void; removeBattleStates(): void; /** * Removes all buffs from the battler. * * @memberof Game_Battler */ removeAllBuffs(): void; removeStatesAuto(timing: number): void; removeBuffsAuto(): void; removeStatesByDamage(): void; /** * Creates the number of times for * an action. * @returns {number} * @memberof Game_Battler */ makeActionTimes(): number; /** * Creates the actions for the battler. * * @memberof Game_Battler */ makeActions(): void; /** * Returns the speed of the battler. * * @returns {number} * @memberof Game_Battler */ speed(): number; /** * Calculates the speed of the battler. * * @memberof Game_Battler */ makeSpeed(): void; /** * Returns the current action of the battler. * * @returns {Game_Action} * @memberof Game_Battler */ currentAction(): Game_Action; /** * Removes the current battler action. * * @memberof Game_Battler */ removeCurrentAction(): void; /** * Sets the last target based on the target passed in. * @param target */ setLastTarget(target: Game_Battler): void; forceAction(skillId: number, targetIndex: number): void; /** * Has theb attler use the given item. * * @param {RPG.UsableItem} item * @memberof Game_Battler */ useItem(item: rm.types.UsableItem): void; /** * Has the battler consume the given item. * * @param {RPG.UsableItem} item * @memberof Game_Battler */ consumeItem(item: rm.types.UsableItem): void; /** * Adds the specified amount of hp to the battler. * * @param {number} value * @memberof Game_Battler */ gainHp(value: number): void; /** * Adds the specified amount of mp to the battler. * * @param {number} value * @memberof Game_Battler */ gainMp(value: number): void; /** * Adds the specified amount of tp to the battler. * * @param {number} value * @memberof Game_Battler */ gainTp(value: number): void; /** * Adds a specified amount of tp to the battler silently. * * @param {number} value * @memberof Game_Battler */ gainSilentTp(value: number): void; /** * Initializes the battler's tp; tp is random. * * @memberof Game_Battler */ initTp(): void; /** * Clears the battler's tp. * * @memberof Game_Battler */ clearTp(): void; chargeTpByDamage(damageRate: number): void; /** * Has the battler regenerate hp based on their hp regen. * * @memberof Game_Battler */ regenerateHp(): void; maxSlipDamage(): number; /** * Has the battler regenerate mp based on their mp regen. * * @memberof Game_Battler */ regenerateMp(): void; /** * Has the battler regenerate tp based on their tp regen. * * @memberof Game_Battler */ regenerateTp(): void; /** * Has the battler regenerate all resources based on * their respective regeneration stats. * @memberof Game_Battler */ regenerateAll(): void; /** * Handler for when battle has started. * * @memberof Game_Battler */ onBattleStart(): void; /** * Handler for when all actions end */ onAllActionsEnd(): void; /** * Handler for when turn ends */ onTurnEnd(): void; /** * Handler for when battle ends */ onBattleEnd(): void; /** * Handler for when damage is done * @param value */ onDamage(value: number): void; /** * Sets the action state * @param actionState */ setActionState(actionState: rm.types.ActionState): void; isUndecided(): boolean; /** * Returns true if the battler is inputting commands in battle. * * @returns {Bool} * @memberof Game_Battler */ isInputting(): boolean; /** * Returns true if the battler is waiting in battle. * * @returns {Bool} * @memberof Game_Battler */ isWaiting(): boolean; /** * Returns true if the battler is performing an action in battle. * * @returns {Bool} * @memberof Game_Battler */ isActing(): boolean; /** * Returns true if the battler is chanting in combat. * * @returns {Bool} * @memberof Game_Battler */ isChanting(): boolean; /** * Returns true if the battler is waiting to guard. * * @returns {Bool} * @memberof Game_Battler */ isGuardWaiting(): boolean; /** * Perform action start motion, given the specified game action. * * @param {Game_Action} action * @memberof Game_Battler */ performActionStart(action: Game_Action): void; /** * Perform given action motion. * * @param {Game_Action} action * @memberof Game_Battler */ performAction(action: Game_Action): void; /** * Perform action end motion. * * @memberof Game_Battler */ performActionEnd(): void; /** * Perform damage motion. * * @memberof Game_Battler */ performDamage(): void; /** * Perform miss motion. * * @memberof Game_Battler */ performMiss(): void; /** * Perform recovery motion. * * @memberof Game_Battler */ performRecovery(): void; /** * Perform evasion motion. * * @memberof Game_Battler */ performEvasion(): void; /** * Perform magic evasion motion. * * @memberof Game_Battler */ performMagicEvasion(): void; /** * Perform counter motion. * * @memberof Game_Battler */ performCounter(): void; /** * Performs the reflect motion. * * @memberof Game_Battler */ performReflection(): void; /** * Perform substitute motion with the specified game battler. * * @param {Game_Battler} target * @memberof Game_Battler */ performSubstitute(target: Game_Battler): void; /** * Performs the collapse motion. * * @memberof Game_Battler */ performCollapse(): void; } declare namespace rm.types { /** * The data class for actors. */ export type Actor = { /** * The file name of the actor's battler graphic. */ battlerName: string; /** * The index (0..7) of the actor's walking graphic. */ characterIndex: number; /** * The file name of the actor's walking graphic. */ characterName: string; /** * The actor's class ID. */ classId: number; doc: string; /** * The actor's initial equipment. An array of weapon IDs or armor IDs with the following subscripts: */ equips: number[]; /** * The index (0..7) of the actor's face graphic. */ faceIndex: number; /** * The file name of the actor's face graphic. */ faceName: string; /** * The ID. */ id: string; /** * The actor's initial level. */ initialLevel: number; internal: boolean; links: string[]; /** * The actor's max level */ maxLevel: number; /** * The name. */ name: string; /** * The actor's nickname. */ nickname: string; parameters: string[]; platforms: haxe.display.Platform[]; /** * The profile. */ profile: string; targets: haxe.display.MetadataTarget[]; /** * The array of Trait data. */ traits: rm.types.Trait[]; } } declare namespace rm.types { /** * The data class for weapons. */ export type Weapon = { /** * The animation ID when using the weapon. */ animationId: number; /** * The description text. */ description: string; /** * The type of weapon or armor. * * 0: Weapon * 1: Shield * 2: Head * 3: Body * 4: Accessory */ etypeId: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; meta: Object; /** * The item name. */ name: string; note: string; /** * The amount of parameter change. An array of integers using the following IDs as subscripts: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck */ params: number[]; /** * The price of the weapon or armor. */ price: number; /** * The array of Trait data. */ traits: rm.types.Trait[]; /** * The weapon type ID. */ wtypeId: number; } } declare namespace rm.types { /** * The data class for armor. */ export type Armor = { /** * The armor type ID. */ atypeId: number; /** * The description text. */ description: string; /** * The type of weapon or armor. * * 0: Weapon * 1: Shield * 2: Head * 3: Body * 4: Accessory */ etypeId: number; /** * The icon number. */ iconIndex: number; /** * The item ID. */ id: number; meta: Object; /** * The item name. */ name: string; note: string; /** * The amount of parameter change. An array of integers using the following IDs as subscripts: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck */ params: number[]; /** * The price of the weapon or armor. */ price: number; /** * The array of Trait data. */ traits: rm.types.Trait[]; } } declare namespace rm.types { /** * The data class for a class's [Skills to Learn]. */ export type ClassLearning = { doc: string; internal: boolean; /** * The data class for a class's [Skills to Learn]. */ level: number; links: string[]; name: string; parameters: string[]; platforms: haxe.display.Platform[]; /** * The ID of the skill to learn. */ skillId: number; targets: haxe.display.MetadataTarget[]; } } declare namespace rm.types { /** * The data class for class. */ export type RPGClass = { doc: string; /** * An array of values that decides the experience curve. The subscripts are as follows: * * 0: Base value * 1: Extra value * 2: Acceleration A * 3: Acceleration B */ expParams: number[]; /** * The ID. */ id: number; internal: boolean; /** * The skills to learn. An array of RPG.Class.Learning. */ learnings: rm.types.ClassLearning[]; links: string[]; /** * The name. */ name: string; parameters: string[]; /** * The parameter development curve. A 2-dimensional array containing ordinary parameters according to level (Table). * * The format is params[param_id, level], and param_id is assigned as follows: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck */ params: number[][]; platforms: haxe.display.Platform[]; targets: haxe.display.MetadataTarget[]; /** * The array of Trait data. */ traits: rm.types.Trait[]; } } declare class Game_Actor extends Game_Battler { constructor(actorId: number); _actorId: number; _name: string; _nickname: string; _profile: string; _classId: number; _level: number; _characterName: string; _characterIndex: number; _faceName: string; _faceIndex: number; _battlerName: string; _exp: Object; /** * Skill Ids */ _skills: number[]; _equips: Game_Item[]; _actionInputIndex: number; _lastMenuSkill: Game_Item; _lastBattleSkill: Game_Item; _lastCommandSymbol: string; _stateSteps: Object; /** * [read-only] */ level: number; setup(actorId: number): void; /** * Returns the id of the actor. * * @returns {Int} * @memberof Game_Actor */ actorId(): number; /** * Returns the database information of the actor. * * @returns {Actor} * @memberof Game_Actor */ actor(): rm.types.Actor; /** * Returns the actor's name. * @return String */ name(): string; /** * Sets the actor name. * * @param {String} name * @memberof Game_Actor */ setName(name: string): void; /** * Returns the nickname of the actor. * * @returns {String} * @memberof Game_Actor */ nickname(): string; /** * Sets the nickname of the actor. * * @param {String} nickname * @memberof Game_Actor */ setNickname(nickname: string): void; /** * Returns the actor profile. * * @returns {String} * @memberof Game_Actor */ profile(): string; /** * Sets the actor profile. * * @param {String} profile * @memberof Game_Actor */ setProfile(profile: string): void; /** * Returns the face name of the actor; this is * the image of faces for the actor. * @returns {String} * @memberof Game_Actor */ faceName(): string; /** * Returns the face index of the actor. * * @returns {Int} * @memberof Game_Actor */ faceIndex(): number; /** * Clears all states from the actor. * * @memberof Game_Actor */ clearStates(): void; /** * Erase the specified state from the actor. * * @param {Int} stateId * @memberof Game_Actor */ eraseState(stateId: number): void; /** * Reset state count of the specified state. * * @param {Int} stateId * @memberof Game_Actor */ resetStateCounts(stateId: number): void; /** * Initialize images of the actor. * * @memberof Game_Actor */ initImages(): void; /** * Returns the exp required to level. * * @param {Int} level * @returns {Int} * @memberof Game_Actor */ expForLevel(level: number): number; /** * Initialize exp of the actor. * * @memberof Game_Actor */ initExp(): void; /** * Returns the current experience points of the actor. * * @returns {Int} * @memberof Game_Actor */ currentExp(): number; /** * Returns the current level's experience for the actor. * * @returns {Int} * @memberof Game_Actor */ currentLevelExp(): number; /** * Returns the experience points for the next level of the actor. * * @returns {Int} * @memberof Game_Actor */ nextLevelExp(): number; /** * Returns the next required experience points for the actor to level up. * * @returns {Int} * @memberof Game_Actor */ nextRequiredExp(): number; /** * Returns the maximum level of the actor. * * @memberof Game_Actor */ maxLevel(): void; /** * Returns true if the actor is max level. * * @returns {Bool} * @memberof Game_Actor */ isMaxLevel(): boolean; /** * Initialize actor skills. * * @memberof Game_Actor */ initSkills(): void; /** * Initialize actor equipment in the given slots. * * @param {Array} equips * @memberof Game_Actor */ initEquips(equips: number[]): void; /** * Returns the equip slots of the actor. * * @returns {Array} * @memberof Game_Actor */ equipSlots(): number[]; /** * Returns the equipment of the actor. * * @returns {Array} * @memberof Game_Actor */ equips(): rm.types.EquipItem[]; /** * Returns the weapon of the actor. * * @returns {Array} * @memberof Game_Actor */ weapons(): rm.types.Weapon[]; /** * Returns the armor of the actor. * * @returns {Array} * @memberof Game_Actor */ armors(): rm.types.Armor[]; /** * Returns true if the actor has a weapon. * * @param {Weapon} weapon * @returns {Bool} * @memberof Game_Actor */ hasWeapon(weapon: rm.types.Weapon): boolean; /** * Returns true if the actor has armor. * * @param {Armor} armor * @returns {Bool} * @memberof Game_Actor */ hasArmor(armor: rm.types.Armor): boolean; /** * Returns true if the equip change is okay in the given slot. * * @param {Int} slotId * @returns {Bool} * @memberof Game_Actor */ isEquipChangeOk(slotId: number): boolean; /** * Changes the actor equipment in the given slot with the * given equip item. Places the original item into the party * inventory. * @param {Int} slotId * @param {EquipItem} item * @memberof Game_Actor */ changeEquip(slotId: number, item: rm.types.EquipItem): void; /** * Forces the actor to change equipment in the given slot * with the given equip item without placing the item back into * the party inventory. * @param {Int} slotId * @param {EquipItem} item * @memberof Game_Actor */ forceChangeEquip(slotId: number, item: rm.types.EquipItem): void; /** * Trades the new item with the old item in the party inventory. * * @param {EquipItem} newItem * @param {EquipItem} oldItem * @returns {Bool} * @memberof Game_Actor */ tradeItemWithParty(newItem: rm.types.EquipItem, oldItem: rm.types.EquipItem): boolean; /** * Changes the actor equip with an item based on the equip id. * * @param {Int} etypeId * @param {Int} itemId * @memberof Game_Actor */ changeEquipById(etypeId: number, itemId: number): void; /** * Returns true if the actor is equipped with the specific item. * * @param {EquipItem} item * @returns {Bool} * @memberof Game_Actor */ isEquipped(item: rm.types.EquipItem): boolean; /** * Discards the given equip item from the actor; item * is not return to the party inventory. * @param {EquipItem} item * @memberof Game_Actor */ discardEquip(item: rm.types.EquipItem): void; /** * Returns items the actor can't normally equip to the party inventory. * * @param {Bool} forcing * @memberof Game_Actor */ releaseUnequippableItems(forcing: boolean): void; /** * Clears the actor's equipment; items are returned to the inventory. * * @memberof Game_Actor */ clearEquipments(): void; /** * Optimize the actor's equipment. * * @memberof Game_Actor */ optimizeEquipments(): void; /** * Equips the best item in the given slot. * * @param {Int} slotId * @memberof Game_Actor */ bestEquipItem(slotId: number): void; /** * Calculates the equip item performance and returns the sum/difference. * * @param {EquipItem} item * @returns {Int} * @memberof Game_Actor */ calcEquipItemPerformance(item: rm.types.EquipItem): number; isSkillWtypeOk(skill: rm.types.Skill): boolean; isWtypeEquipped(wtypeId: number): boolean; /** * Refreshes the actor. * * @memberof Game_Actor */ refresh(): void; friendsUnit(): Game_Party; opponentsUnit(): Game_Temp; /** * Returns true if the actor is a member in battle. * * @returns {Bool} * @memberof Game_Actor */ isBattleMember(): boolean; isFormationChangeOk(): boolean; /** * Returns the current class of the actor from the database. * * @returns {Class} * @memberof Game_Actor */ currentClass(): rm.types.RPGClass; /** * Returns true if the actor is the specified class from the database. * * @param {Class} gameClass * @returns {Bool} * @memberof Game_Actor */ isClass(gameClass: rm.types.RPGClass): boolean; /** * Returns the actor's skills; even if the skills are not usable. * * @returns {Array} * @memberof Game_Actor */ skills(): rm.types.Skill[]; /** * Returns the usable skills of the actor. * * @returns {Array} * @memberof Game_Actor */ usableSkills(): rm.types.Skill[]; /** * Returns the attack element ids. * * @returns {Array} * @memberof Game_Actor */ attackElements(): number[]; /** * Returns true if the actor has no weapon. * * @returns {Bool} * @memberof Game_Actor */ hasNoWeapons(): boolean; /** * Returns the element id of barehanded attacks. * By default this is 1. * * @returns {Int} * @memberof Game_Actor */ bareHandsElementId(): number; /** * Returns the base value of the parameter. * @param paramId * @return Int */ paramBase(paramId: number): number; /** * Returns the first attack animation id. * * @returns {Int} * @memberof Game_Actor */ attackAnimationId1(): number; /** * Returns the second attack animation id. * * @returns {Int} * @memberof Game_Actor */ attackAnimationId2(): number; /** * Returns the animation id for a barehanded attack. * * @returns {Int} * @memberof Game_Actor */ bareHandsAnimationId(): number; /** * Change the actor experience points; leveling up the actor * if it's above the required exp for the current level. * If show is set to true, actor level up with be displayed. * @param {Int} exp * @param {Bool} show * @memberof Game_Actor */ changeExp(exp: number, show: boolean): void; /** * Level up the actor. * * @memberof Game_Actor */ levelUp(): void; /** * Level down the actor. * * @memberof Game_Actor */ levelDown(): void; findNewSkills(lastSkills: rm.types.Skill[]): rm.types.Skill[]; /** * Displays the actor level up in a message window, with the learned skills. * * @param {Array} newSkills * @memberof Game_Actor */ displayLevelUp(newSkills: rm.types.Skill[]): void; /** * Gives the specified exp to the actor. * * @param {Int} exp * @memberof Game_Actor */ gainExp(exp: number): void; /** * Returns the final exp rate of the actor based on if the actor * is a reserved party member or an active battle member. * @returns {Int} * @memberof Game_Actor */ finalExpRate(): number; /** * Returns the exp rate of actors not in battle; this is set in the database. * * @returns {Int} * @memberof Game_Actor */ benchMembersExpRate(): number; /** * Returns true if the actor should display level up in a message window. * * @returns {Bool} * @memberof Game_Actor */ shouldDisplayLevelUp(): boolean; /** * Changes the actor level; if show is set to true, * the actor level will be displayed. * @param {Int} level * @param {Bool} show * @memberof Game_Actor */ changeLevel(level: number, show: boolean): void; /** * Actor learns the specified skill given the skill id. * * @param {Int} skillId * @memberof Game_Actor */ learnSkill(skillId: number): void; /** * Actor forgets the specified skill given the skill id from * the actor's usable skills. * @param {Int} skillId * @memberof Game_Actor */ forgetSkill(skillId: number): void; /** * Returns true if the actor has learned the specified * skill given the specified skill id. * @param {Int} skillId * @returns {Bool} * @memberof Game_Actor */ isLearnedSkill(skillId: number): boolean; /** * Changes the actor class; if keep is true, the actor * will retain their experience points. * @param {Int} classId * @param {Bool} keepExp * @memberof Game_Actor */ changeClass(classId: number, keepExp: boolean): void; setCharacterImage(characterName: string, characterIndex: number): void; /** * Sets the face image of the actor given the face image (from database) * and face index within the iamge. * * @param {String} faceName * @param {Int} faceIndex * @memberof Game_Actor */ setFaceImage(faceName: string, faceIndex: number): void; /** * Sets the battler image of the actor; this is the sprite displayed * in the side view mode. * @param {String} battlerName * @memberof Game_Actor */ setBattlerImage(battlerName: string): void; /** * Returns true if the actor sprite is visible. * * @returns {Bool} * @memberof Game_Actor */ isSpriteVisible(): boolean; /** * Starts the animation on the actor given the specified animation id; * if mirror is set to true, the animation will be mirrored. If a delay is enter, * the animation will be delayed. * @param {Int} animationId * @param {Bool} mirror * @param {Int} delay * @memberof Game_Actor */ startAnimation(animationId: number, mirror: boolean, delay: number): void; /** * Performs the attack motion for the actor. * * @memberof Game_Actor */ performAttack(): void; /** * Perform the victory motion for the actor. * * @memberof Game_Actor */ performVictory(): void; /** * Performs the escape motion for the actor. * * @memberof Game_Actor */ performEscape(): void; /** * Creates the action list for the actor. * * @returns {Array} * @memberof Game_Actor */ makeActionList(): Game_Action[]; /** * Creates the auto battle actions for the game actor. * * @memberof Game_Actor */ makeAutoBattleActions(): void; makeConfusionActions(): void; /** * Handler for when the player walks on the map scene. * * @memberof Game_Actor */ onPlayerWalk(): void; updateStateSteps(state: rm.types.State): void; /** * Shows the added states to the actor. * * @memberof Game_Actor */ showAddedStates(): void; /** * Shows the removed states from the actor. * * @memberof Game_Actor */ showRemovedStates(): void; stepsForTurn(): number; turnEndOnMap(): void; /** * Checks the effect of the floor on the actor. * * @memberof Game_Actor */ checkFloorEffect(): void; /** * Executes the floor dmaage on the actor. * * @memberof Game_Actor */ executeFloorDamage(): void; /** * Returns the basic floor damage. * * @returns {Int} * @memberof Game_Actor */ basicFloorDamage(): number; /** * Returns the max floor damage. * * @returns {Int} * @memberof Game_Actor */ maxFloorDamage(): number; /** * Perform damage to the actor on the map scene. * * @memberof Game_Actor */ performMapDamage(): void; /** * Clears all of the actor's animations. * * @memberof Game_Actor */ clearActions(): void; /** * Returns action the actor is inputting. * * @returns {Game_Action} * @memberof Game_Actor */ inputtingAction(): Game_Action; selectNextCommand(): boolean; selectPreviousCommand(): boolean; /** * Returns the last menu skill of the actor. * * @returns {Skill} * @memberof Game_Actor */ lastMenuSkill(): rm.types.Skill; setLastMenuSkill(skill: rm.types.Skill): void; /** * Returns the last battle skill of the actor. * * @returns {Skill} * @memberof Game_Actor */ lastBattleSkill(): rm.types.Skill; setLastBattleSkill(skill: rm.types.Skill): void; /** * Returns the last command symbol that the actor used. * * @returns {String} * @memberof Game_Actor */ lastCommandSymbol(): string; /** * Sets the last command symbol to the given symbol; this is the * selected command in the battle menu. * @param {String} symbol * @memberof Game_Actor */ setLastCommandSymbol(symbol: string): void; /** * Returns true if the item effect has a special effect from game action. * @param item * @return Bool */ testEscape(item: rm.types.BaseItem): boolean; } declare class Game_Actors { constructor(); /** * List of all Game_Actor in the database. */ _data: Game_Actor[]; initialize(): void; /** * Returns the actor with the specified id. * * @param {number} actorId * @returns {Game_Actor} * @memberof Game_Actors */ actor(actorId: number): Game_Actor; } declare namespace rm.types { export const enum MoveSpeed { X8SLOWER = 1, X4SLOWER = 2, X2SLOWER = 3, NORMAL = 4, X2FASTER = 5, X4FASTER = 6, } } declare namespace rm.types { export const enum MoveFrequency { LOWEST = 1, LOWER = 2, NORMAL = 3, HIGHER = 4, HIGHEST = 5, } } declare namespace rm.types { export const enum Direction { base = -1, } } declare namespace rm.types { } declare namespace rm.types { export const enum CharacterPriority { BELOW_CHARACTERS = 0, SAME_AS_CHARACTERS = 1, ABOVE_CHARACTERS = 2, } } declare namespace rm.types { export const enum BalloonId { EXCLAMATION = 0, QUESTION = 1, MUSIC_NOTE = 2, HEART = 3, ANGER = 4, SWEAT = 5, COBWEB = 6, SILENCE = 7, LIGHT_BULB = 8, ZZZ = 9, } } /** * The super class of Game Character. It handles basic * information such as coordinates, images, and more * shared by all characters. */ declare class Game_CharacterBase { constructor(); _x: number; _y: number; _realX: number; _realY: number; _moveSpeed: rm.types.MoveSpeed; _moveFrequency: rm.types.MoveFrequency; _opacity: number; _blendMode: number; _direction: rm.types.Direction; _pattern: rm.types.CharacterPattern; _priorityType: rm.types.CharacterPriority; _tileId: number; _characterName: string; _characterIndex: number; _isObjectCharacter: boolean; _walkAnime: boolean; _stepAnime: boolean; _directionFix: boolean; _through: boolean; _transparent: boolean; _bushDepth: number; _animationId: rm.types.AnimationId; _ballonId: rm.types.BalloonId; _animationPlaying: boolean; _balloonPlaying: boolean; _animationCount: number; _stopCount: number; _jumpCount: number; _jumpPeak: number; _movementSuccess: boolean; initialize(): void; /** * [read-only] */ x: number; /** * [read-only] */ y: number; initMembers(): void; pos(x: number, y: number): boolean; posNt(x: number, y: number): boolean; /** * Returns the move speed of the game character. * * @returns {Int} * @memberof Game_CharacterBase */ moveSpeed(): number; setMoveSpeed(moveSpeed: number): void; /** * Returns the move frequency of the character. * * @returns {Int} * @memberof Game_CharacterBase */ moveFrequency(): number; setMoveFrequency(moveFrequency: number): void; opacity(): number; setOpacity(opacity: number): void; /** * Returns the blend mode of the character; * these are represented by Ints. * @returns {Int} * @memberof Game_CharacterBase */ blendMode(): number; /** * Sets the blend mode of the character; * these are represented by Ints. * @param {Int} blendMode * @memberof Game_CharacterBase */ setBlendMode(blendMode: number): void; /** * Returns true if the character is * normal priority; this means you can collide with them. * @returns {Bool} * @memberof Game_CharacterBase */ isNormalPriority(): boolean; setPriorityType(priorityType: number): void; /** * Returns true if the character is moving. * * @returns {Bool} * @memberof Game_CharacterBase */ isMoving(): boolean; /** * Returns true if the character is jumping. * * @returns {Bool} * @memberof Game_CharacterBase */ isJumping(): boolean; /** * Returns the jump height of base character. * * @returns {Int} * @memberof Game_CharacterBase */ jumpHeight(): number; /** * Returns true if the character is stopping. * * @returns {Bool} * @memberof Game_CharacterBase */ isStopping(): boolean; checkStop(threshold: number): boolean; /** * Resets the step count of the character. * * @memberof Game_CharacterBase */ resetStopCount(): void; realMoveSpeed(): number; distancePerFrame(): number; /** * Returns true if the character is dashing. * * @returns {Bool} * @memberof Game_CharacterBase */ isDashing(): boolean; isDebugThrough(): boolean; /** * Straightens the character. * * @memberof Game_CharacterBase */ straighten(): void; reverseDir(d: number): number; canPass(x: number, y: number, d: number): boolean; canPassDiagonally(x: number, y: number, horz: number, vert: number): boolean; isMapPassable(x: number, y: number, d: number): boolean; isCollidedWithCharacters(x: number, y: number): boolean; isCollidedWithEvents(x: number, y: number): boolean; isCollidedWithVehicles(x: number, y: number): boolean; setPosition(x: number, y: number): void; copyPosition(character: Game_Player): void; locate(x: number, y: number): void; direction(): number; /** * Sets the direction of the character based on numpad * directions. * @param {Int} d * @memberof Game_CharacterBase */ setDirection(d: number): void; /** * Returns true if the character is a tile; these * are events without character sprites. * @returns {Bool} * @memberof Game_CharacterBase */ isTile(): boolean; /** * Returns true if the character is an object character; * these are events with character sprites. * @returns {Bool} * @memberof Game_CharacterBase */ isObjectCharacter(): boolean; shiftY(): number; scrolledX(): number; scrolledY(): number; /** * Returns the character's scrreen x position. * * @returns {Int} * @memberof Game_CharacterBase */ screenX(): number; /** * Returns the character's screen y position. * * @returns {Int} * @memberof Game_CharacterBase */ screenY(): number; /** * Returns the character's screen z position. * * @returns {Int} * @memberof Game_CharacterBase */ screenZ(): number; isNearTheScreen(): boolean; update(): void; updateStop(): void; updateJump(): void; updateMove(): void; updateAnimation(): void; animationWait(): number; /** * Updates the character's animation count. * * @memberof Game_CharacterBase */ updateAnimationCount(): void; updatePattern(): void; maxPattern(): number; /** * Returns the pattern of the character; these are the walking * patterns. * @returns {Int} * @memberof Game_CharacterBase */ pattern(): number; /** * Sets the pattern of the character, given * a pattern Int. * @param {Int} pattern * @memberof Game_CharacterBase */ setPattern(pattern: number): void; isOriginalPattern(): boolean; /** * Resets the pattern of the character. * * @memberof Game_CharacterBase */ resetPattern(): void; refreshBushDepth(): void; isOnLadder(): boolean; isOnBush(): boolean; /** * Returns the terrain tag of the character. * * @returns {Int} * @memberof Game_CharacterBase */ terrainTag(): number; /** * Returns the region id of the character. * * @returns {Int} * @memberof Game_CharacterBase */ regionId(): number; /** * Increases the character steps. * * @memberof Game_CharacterBase */ increaseSteps(): void; /** * Returns the tile id of character. * * @returns {Int} * @memberof Game_CharacterBase */ tileId(): number; characterName(): string; characterIndex(): number; setImage(characterName: string, characterIndex: number): void; setTileImage(tileId: number): void; checkEventTriggerTouchFront(d: number): void; checkEventTriggerTouch(x: number, y: number): boolean; isMovementSucceeded(x: number, y: number): boolean; setMovementSuccess(success: boolean): void; moveStraight(d: number): void; moveDiagonally(horz: number, vert: number): void; jump(xPlus: number, yPlus: number): void; hasWalkAnime(): boolean; setWalkAnime(walkAnime: boolean): void; /** * Returns true if the character has step animation. * * @returns {Bool} * @memberof Game_CharacterBase */ hasStepAnime(): boolean; setStepAnime(stepAnime: boolean): void; /** * Returns true if the character is set to a fixed direction. * * @returns {Bool} * @memberof Game_CharacterBase */ isDirectionFixed(): boolean; /** * Sets the character to be fixed in a specified direction * given a Bool value. * @param {Bool} directionFix * @memberof Game_CharacterBase */ setDirectionFix(directionFix: boolean): void; /** * Returns true if the character is set to pass through. * * @returns {Bool} * @memberof Game_CharacterBase */ isThrough(): boolean; setThrough(through: boolean): void; isTransparent(): boolean; /** * Returns the bush depth around the character. * * @returns {Int} * @memberof Game_CharacterBase */ bushDepth(): number; setTransparent(transparent: boolean): void; /** * Requests an animation given the animation id. * * @param {Int} animationId * @memberof Game_CharacterBase */ requestAnimation(animationId: number): void; /** * Requests the balloon animation given the balloon id. * * @param {Int} balloonId * @memberof Game_CharacterBase */ requestBalloon(balloonId: number): void; /** * Returns the animation id. * * @returns {Int} * @memberof Game_CharacterBase */ animationId(): number; /** * Returns the id of the balloon animation. * * @returns {Int} * @memberof Game_CharacterBase */ balloonId(): number; /** * Starts the requested animation. * * @memberof Game_CharacterBase */ startAnimation(): void; /** * Stars a balloon animation. * * @memberof Game_CharacterBase */ startBalloon(): void; isAnimationPlaying(): boolean; /** * Returns true if a balloon animation is playing. * * @returns {Bool} * @memberof Game_CharacterBase */ isBalloonPlaying(): boolean; endAnimation(): void; /** * Ends the balloon animation on the character. * * @memberof Game_CharacterBase */ endBalloon(): void; } declare namespace rm.types { /** * The data class for the Move command. */ export type MoveCommand = { /** * Move command code. */ code: number; /** * An array containing the Move command's arguments. The contents vary for each command. */ parameters: any[]; } } declare namespace rm.types { /** * The data class for the Move route. */ export type MoveRoute = { /** * Program contents. An RPG.MoveCommand array. */ list: rm.types.MoveCommand[]; /** * The truth value of the [Repeat Action] option. */ repeat: boolean; /** * The truth value of the [Skip If Cannot Move] option. */ skippable: boolean; /** * The truth value of the [Wait for Completion] option. */ wait: boolean; } } /** * Super class of Game_Player, Game_Follower, Game_Vehicle, * and Game_Event. */ declare class Game_Character extends Game_CharacterBase { protected constructor(); _moveRouteForcing: boolean; _moveRoute: rm.types.MoveRoute; _moveRouteIndex: number; _originalMoveRoute: rm.types.MoveRoute; _originalMoveRouteIndex: number; _waitCount: number; initMembers(): void; /** * Memorizes the movement route. * * @memberof Game_Character */ memorizeMoveRoute(): void; /** * Restores the original movement route. * * @memberof Game_Character */ restoreMoveRoute(): void; /** * Returns true if the move route is being forced. * * @returns {Bool} * @memberof Game_Character */ isMoveRouteForcing(): boolean; /** * Sets the move route of the game character. * * @param {RPG.MoveRoute} moveRoute * @memberof Game_Character */ setMoveRoute(moveRoute: rm.types.MoveRoute): void; /** * Forces the move route of the game character. * * @param {RPG.MoveRoute} moveRoute * @memberof Game_Character */ forceMoveRoute(moveRoute: rm.types.MoveRoute): void; updateStop(): void; /** * Updates the game character's move routine. * * @memberof Game_Character */ updateRoutineMove(): void; /** * Processes the given move commands. * * @param {RPG.MoveCommand} command * @memberof Game_Character */ processMoveCommand(command: rm.types.MoveCommand): void; deltaXFrom(x: number): number; deltaYFrom(y: number): number; /** * Move's the game character at random. * * @memberof Game_Character */ moveRandom(): void; /** * Moves the game character toward the other game character. * * @param {Game_Character} character * @memberof Game_Character */ moveTowardCharacter(character: Game_Character): void; /** * Moves the game character away from the other game character. * * @param {Game_Character} character * @memberof Game_Character */ moveAwayFromCharacter(character: Game_Character): void; /** * Turns the game character toward the other game character. * * @param {Game_Character} character * @memberof Game_Character */ turnTowardCharacter(character: Game_Character): void; /** * Turns the game character away from the other game character. * * @param {Game_Character} character * @memberof Game_Character */ turnAwayFromCharacter(character: Game_Character): void; /** * Turns the game character toward the player. * * @memberof Game_Character */ turnTowardPlayer(): void; /** * Turns the game character away from the player. * * @memberof Game_Character */ turnAwayFromPlayer(): void; /** * Moves the game character toward the player. * * @memberof Game_Character */ moveTowardPlayer(): void; /** * Moves the game character away from the player. * * @memberof Game_Character */ moveAwayFromPlayer(): void; /** * Moves the game character forward. * * @memberof Game_Character */ moveForward(): void; /** * Moves the game character backward. * * @memberof Game_Character */ moveBackward(): void; /** * Handles the end of the move route. * * @memberof Game_Character */ processRouteEnd(): void; advanceMoveRouteIndex(): void; /** * Turns the game character right by 90 degrees. * * @memberof Game_Character */ turnRight90(): void; /** * Turns the game character left by 90 degrees. * * @memberof Game_Character */ turnLeft90(): void; turn180(): void; /** * Turns the game character or left by 90 degrees. * * @memberof Game_Character */ turnRightOrLeft90(): void; /** * Turns the game character at random. * * @memberof Game_Character */ turnRandom(): void; swap(character: Game_Character): void; findDirectionTo(goalX: number, goalY: number): number; /** * Returns the search limit for path finding. * * @returns {Int} * @memberof Game_Character */ searchLimit(): number; static ROUTE_END: number; static ROUTE_MOVE_DOWN: number; static ROUTE_MOVE_LEFT: number; static ROUTE_MOVE_RIGHT: number; static ROUTE_MOVE_UP: number; static ROUTE_MOVE_LOWER_L: number; static ROUTE_MOVE_LOWER_R: number; static ROUTE_MOVE_UPPER_L: number; static ROUTE_MOVE_UPPER_R: number; static ROUTE_MOVE_RANDOM: number; static ROUTE_MOVE_TOWARD: number; static ROUTE_MOVE_AWAY: number; static ROUTE_MOVE_FORWARD: number; static ROUTE_MOVE_BACKWARD: number; static ROUTE_JUMP: number; static ROUTE_WAIT: number; static ROUTE_TURN_DOWN: number; static ROUTE_TURN_LEFT: number; static ROUTE_TURN_RIGHT: number; static ROUTE_TURN_UP: number; static ROUTE_TURN_90D_R: number; static ROUTE_TURN_90D_L: number; static ROUTE_TURN_180D: number; static ROUTE_TURN_90D_R_L: number; static ROUTE_TURN_RANDOM: number; static ROUTE_TURN_TOWARD: number; static ROUTE_TURN_AWAY: number; static ROUTE_SWITCH_ON: number; static ROUTE_SWITCH_OFF: number; static ROUTE_CHANGE_SPEED: number; static ROUTE_CHANGE_FREQ: number; static ROUTE_WALK_ANIME_ON: number; static ROUTE_WALK_ANIME_OFF: number; static ROUTE_STEP_ANIME_ON: number; static ROUTE_STEP_ANIME_OFF: number; static ROUTE_DIR_FIX_ON: number; static ROUTE_DIR_FIX_OFF: number; static ROUTE_THROUGH_ON: number; static ROUTE_THROUGH_OFF: number; static ROUTE_TRANSPARENT_ON: number; static ROUTE_TRANSPARENT_OFF: number; static ROUTE_CHANGE_IMAGE: number; static ROUTE_CHANGE_OPACITY: number; static ROUTE_CHANGE_BLEND_MODE: number; static ROUTE_PLAY_SE: number; static ROUTE_SCRIPT: number; } declare namespace rm.types { /** * The data class for the Event command. */ export type EventCommand = { /** * The event code. */ code: number; /** * The indent depth. Usually 0. The [Conditional Branch] command, among others, adds 1 with every step deeper. */ indent: number; /** * An array containing the Event command's arguments. The contents vary for each command. */ parameters: any[]; } } declare namespace rm.types { /** * The data class for common events. */ export type CommonEvent = { /** * The event ID. */ id: number; /** * A list of event commands. An RPG.EventCommand array. */ list: rm.types.EventCommand[]; /** * The event name. */ name: string; /** * The condition switch ID. */ switchId: number; /** * The event trigger (0: none, 1: autorun; 2: parallel). */ trigger: number; } } declare class Game_CommonEvent { constructor(commonEventId: number); _commonEventId: number; _interpreter: Game_Interpreter; initialize(commonEventId: number): void; /** * Returns the common event information from the database. * * @returns {CommonEvent} * @memberof Game_CommonEvent */ event(): rm.types.CommonEvent; /** * Returns the common event's list of event commands. * * @returns {Array} * @memberof Game_CommonEvent */ list(): rm.types.EventCommand[]; /** * Refreshes the common event. * * @memberof Game_CommonEvent */ refresh(): void; /** * Returns true if the common event is active. * * @returns {boolean} * @memberof Game_CommonEvent */ isActive(): boolean; /** * Updates the common event. * * @memberof Game_CommonEvent */ update(): void; } declare namespace rm.types { export type EnemyDropItem = { /** * The ID of the data depending on the type of dropped item (item, weapon, or armor). */ dataId: number; /** * N of the probability that the item will be dropped, 1/N. */ denominator: number; /** * The type of dropped item. * * 0: None * 1: Item * 2: Weapon * 3: Armor */ kind: number; } } declare namespace rm.types { export type Enemy = { /** * The enemy's action pattern. An array of RPG.Enemy.Action. */ actions: rm.types.EnemyAction[]; /** * The adjustment value for the battler graphic's hue (0..360). */ battlerHue: number; /** * The file name of the enemy's battler graphic. */ battlerName: string; doc: string; /** * The items the enemy drops. An RPG.Enemy.DropItem array. */ dropItems: rm.types.EnemyDropItem[]; /** * The enemy's experience. */ exp: number; /** * The enemy's gold. */ gold: number; /** * The ID of the enemy in the database. * * @type {number} * @memberof Enemy */ id: number; internal: boolean; links: string[]; /** * The name of the enemy in the database. * * @type {string} * @memberof Enemy */ name: string; parameters: string[]; /** * Parameters. An array of integers using the following IDs as subscripts: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck */ params: number[]; platforms: haxe.display.Platform[]; targets: haxe.display.MetadataTarget[]; } } /** * ----------------------------------------------------------------------------- * Game_Enemy * * The game object declare class for an enemy. * @class Game_Enemy */ declare class Game_Enemy extends Game_Battler { constructor(enemyId: number, x: number, y: number); _enemyId: number; _letter: string; _plural: boolean; _screenX: number; _screenY: number; initialize(enemyId: number, x: number, y: number): void; initMembers(): void; setup(enemyId: number, x: number, y: number): void; /** * Returns the other troops in the enemy team. * * @returns {Game_Troop} * @memberof Game_Enemy */ friendsUnit(): Game_Temp; /** * Returns the game party. * * @returns {Game_Party} * @memberof Game_Enemy */ opponentsUnit(): Game_Party; isBattleMember(): boolean; /** * Returns the enemy id. * * @returns {number} * @memberof Game_Enemy */ enemyId(): number; /** * Returns the enemy information from the database. * * @returns {RPG.Enemy} * @memberof Game_Enemy */ enemy(): rm.types.Enemy; /** * Returns the enemy's exp amount. * * @memberof Game_Enemy */ exp(): void; /** * Returns enemy's given gold. * * @memberof Game_Enemy */ gold(): void; /** * Creates the drop items for the enemy specified by the database. * * @returns {Array} * @memberof Game_Enemy */ makeDropItems(): rm.types.BaseItem[]; /** * Returns the item drop rate of the enemy. * * @returns {number} * @memberof Game_Enemy */ dropItemRate(): number; itemObject(kind: number, dataId: number): void; /** * Returns true if the enemy sprite is visible. * * @returns {boolean} * @memberof Game_Enemy */ isSpriteVisible(): boolean; /** * Returns enemy screen X coordinate. * * @returns {number} * @memberof Game_Enemy */ screenX(): number; /** * Returns enemy screen Y position. * * @returns {number} * @memberof Game_Enemy */ screenY(): number; /** * Returns the hue of the enemy. * * @returns {number} * @memberof Game_Enemy */ battlerHue(): number; /** * Returns the enemy original name. * * @returns {string} * @memberof Game_Enemy */ originalName(): string; isLetterEmpty(): boolean; setLetter(letter: string): void; setPlural(plural: boolean): void; /** * Transform the enemy into another enemy based on id. * * @param {number} enemyId * @memberof Game_Enemy */ transform(enemyId: number): void; meetsCondition(action: rm.types.EnemyAction): boolean; meetsTurnCondition(param1: number, param2: number): boolean; meetsHpCondition(param1: number, param2: number): boolean; meetsMpCondition(param1: number, param2: number): boolean; meetsStateCondition(param: number): boolean; meetsPartyLevelCondition(param: number): boolean; meetsSwitchCondition(param: number): boolean; /** * Returns true if the enemy action is valid. * * @param {RPG.Enemy.Action} action * @returns {boolean} * @memberof Game_Enemy */ isActionValid(action: rm.types.EnemyAction): boolean; selectAction(actionList: rm.types.EnemyAction[], ratingZero: number): rm.types.EnemyAction; selectAllActions(actionList: rm.types.EnemyAction[]): void; } declare namespace rm.types { export const enum MoveType { FIXED = 0, RANDOM = 1, APPROACH = 2, CUSTOM = 3, } } declare namespace rm.types { export const enum EventTrigger { base = -1, } } declare namespace rm.types { /** * The data class for the event page conditions. */ export type EventPageConditions = { /** * The ID of that actor if the [Actor] condition is valid. */ actorId: string; /** * The truth value indicating whether the [Actor] condition is valid. */ actorValid: boolean; /** * The ID of that item if the [Item] condition is valid. */ itemId: string; /** * The truth value indicating whether the [Item] condition is valid. */ itemValid: boolean; /** * The letter of that self switch ("A".."D") if the [Self Switch] condition is valid. */ selfSwitchCh: string; /** * The truth value indicating whether the [Self Switch] condition is valid. */ selfSwitchValid: boolean; /** * The ID of that switch if the first [Switch] condition is valid. */ switch1Id: number; /** * The truth value indicating whether the first [Switch] condition is valid. */ switch1Valid: boolean; /** * The ID of that switch if the second [Switch] condition is valid. */ switch2Id: number; /** * The truth value indicating whether the second [Switch] condition is valid. */ switch2Valid: boolean; /** * The ID of that variable if the [Variable] condition is valid. */ variableId: number; /** * The truth value indicating whether the [Variable] condition is valid. */ variableValid: boolean; /** * The standard value of that variable (x and greater) if the [Variable] condition is valid. */ variableValue: number; } } declare namespace rm.types { /** * The data class for the Event page [Graphics]. */ export type EventPageImage = { /** * The index of the character's graphic file (0..7). */ characterIndex: number; /** * The file name of the character's graphic. */ characterName: string; /** * The direction in which the character is facing (2: down, 4: left, 6: right, 8: up). */ direction: number; /** * The character's pattern (0..2). */ pattern: number; /** * The tile ID. If the specified graphic is not a tile, this value is 0. */ tileId: number; } } declare namespace rm.types { /** * The data class for the event page. */ export type EventPage = { /** * The event condition (RPG.EventPage.Condition). */ conditions: rm.types.EventPageConditions; /** * The truth value of the [Direction Fix] option. */ directionFix: boolean; /** * The event graphic (RPG.EventPage.Image) . */ image: rm.types.EventPageImage; /** * A list of event commands. An RPG.EventCommand array. */ list: rm.types.EventCommand[]; /** * The movement frequency (1: lowest, 2: lower, 3: normal, 4: higher, 5: highest). */ moveFrequency: number; /** * The movement route (RPG.MoveRoute). Referenced only when the movement type is set to custom. */ moveRoute: rm.types.MoveRoute[]; /** * The movement speed (1: x8 slower, 2: x4 slower, 3: x2 slower, 4: normal, 5: x2 faster, 6: x4 faster). */ moveSpeed: number; /** * The type of movement (0: fixed, 1: random, 2: approach, 3: custom). */ moveType: number; /** * The priority type (0: below characters, 1: same as characters, 2: above characters). */ priorityType: number; /** * The truth value of the [Stepping Animation] option. */ stepAnime: boolean; /** * The truth value of the [Through] option. */ through: boolean; /** * The event trigger (0: action button, 1: player touch, 2: event touch, 3: autorun, 4: parallel). */ trigger: number; /** * The truth value of the [Walking Animation] option. */ walkAnime: boolean; } } declare namespace rm.types { /** * The data class for map events. */ export type Event = { /** * The event ID. */ id: number; meta: Object; /** * The event name. */ name: string; note: string; /** * The event pages. RPG.EventPage array. */ pages: rm.types.EventPage[]; /** * The event's x-coordinate on the map. */ x: number; /** * The event's y-coordinate on the map. */ y: number; } } /** * THe game object class for an event. It contains functionality * for event page switching and running parallel process events. */ declare class Game_Event extends Game_Character { constructor(mapId: number, eventId: number); _mapId: number; _eventId: number; _moveType: rm.types.MoveType; _trigger: rm.types.EventTrigger; _starting: boolean; _erased: boolean; _pageIndex: number; _originalPattern: rm.types.CharacterPattern; _originalDirection: rm.types.Direction; _prelockDirection: rm.types.Direction; _locked: boolean; initialize(mapId: number, eventId: number): void; initMembers(): void; /** * Returns the event id of the game event. * * @returns {Int} * @memberof Game_Event */ eventId(): number; /** * Returns the event database information. * * @returns {RPG.Event} * @memberof Game_Event */ event(): rm.types.Event; /** * Returns the event page created in the database. * * @returns {RPG.EventPage} * @memberof Game_Event */ page(): rm.types.EventPage; /** * Returns the list of event commands on the current page of the game event. * * @returns {Array} * @memberof Game_Event */ list(): rm.types.EventCommand[]; isCollidedWithCharacters(x: number, y: number): boolean; isCollidedWithEvents(x: number, y: number): boolean; /** * Returns true if the event has collided with the player character * at the specified x and y coordinates. * @param {Int} x * @param {Int} y * @returns {Bool} * @memberof Game_Event */ isCollidedWithPlayerCharacters(x: number, y: number): boolean; /** * Locks the game event. * * @memberof Game_Event */ lock(): void; /** * Unlocks the game eveent. * * @memberof Game_Event */ unlock(): void; updateStop(): void; /** * Updates the self movement of the game event. * * @memberof Game_Event */ updateSelfMovement(): void; stopCountThreshold(): number; moveTypeRandom(): void; moveTypeTowardPlayer(): void; /** * Returns true if the game event is near the player. * * @returns {Bool} * @memberof Game_Event */ isNearThePlayer(): boolean; moveTypeCustom(): void; /** * Returns true if the event is staring. * * @returns {Bool} * @memberof Game_Event */ isStarting(): boolean; /** * Clears the starting flag. * * @memberof Game_Event */ clearStartingFlag(): void; isTriggerIn(triggers: number[]): boolean; /** * Starts the game event. * * @memberof Game_Event */ start(): void; /** * Erases the event. * * @memberof Game_Event */ erase(): void; /** * Refreshes the game event. * * @memberof Game_Event */ refresh(): void; /** * Finds the proper page index of the game event for * event command processing. * @returns {Int} * @memberof Game_Event */ findProperPageIndex(): number; meetsConditions(page: rm.types.EventPage): boolean; /** * Sets up the event page. * * @memberof Game_Event */ setupPage(): void; /** * Clears the page settings of the game event. * * @memberof Game_Event */ clearPageSettings(): void; /** * Sets up the event page settings. * * @memberof Game_Event */ setupPageSettings(): void; isOriginalPattern(): boolean; /** * Resets the pattern of the game event. * * @memberof Game_Event */ resetPattern(): void; checkEventTriggerAuto(): void; update(): void; updateParallel(): void; locate(x: number, y: number): void; /** * Forces the game event to move along the specified route. * * @param {RPG.MoveRoute} moveRoute * @memberof Game_Event */ forceMoveRoute(moveRoute: rm.types.MoveRoute): void; } /** * ----------------------------------------------------------------------------- * Game_Follower * * The game object declare class for a follower. A follower is an allied character, * other than the front character, displayed in the party. * @class Game_Follower */ declare class Game_Follower extends Game_Character { constructor(memberIndex: number); _memberIndex: number; refresh(): void; /** * Returns the current actor. * * @returns {Game_Actor} * @memberof Game_Follower */ actor(): Game_Actor; /** * Returns true if the follower is visible. * * @returns {Bool} * @memberof Game_Follower */ isVisible(): boolean; /** * Updates the game follower. * * @memberof Game_Follower */ update(): void; /** * Has the follower chase a game actor. * * @param {Game_Character} character * @memberof Game_Follower */ chaseCharacter(character: Game_Character): void; } /** * ----------------------------------------------------------------------------- * Game_Followers * * The wrapper declare class for a follower array. * @class Game_Followers */ declare class Game_Followers { constructor(); _visible: boolean; _gathering: boolean; _data: Game_Follower[]; initialize(): void; /** * Returns true if the followers are visible. * * @returns {Bool} * @memberof Game_Followers */ isVisible(): boolean; /** * Shows the followers. * * @memberof Game_Followers */ show(): void; /** * Hides the followers. * * @memberof Game_Followers */ hide(): void; /** * Returns the followers at the specified index. * * @param {number} index * @returns {Game_Follower} * @memberof Game_Followers */ follower(index: number): Game_Follower; forEach(callback: () => void, thisObject: any): void; reverseEach(callback: () => void, thisObject: any): void; /** * Refreshes the game followers. * * @memberof Game_Followers */ refresh(): void; /** * Updates the game followers. * * @memberof Game_Followers */ update(): void; /** * Updates the movement of game followers. * * @memberof Game_Followers */ updateMove(): void; jumpAll(): void; synchronize(x: number, y: number, d: number): void; /** * Gathers the followers. * * @memberof Game_Followers */ gather(): void; /** * Returns true if the followers are gathering. * * @returns {Bool} * @memberof Game_Followers */ areGathering(): boolean; /** * Returns the visible followers. * * @returns {Array} * @memberof Game_Followers */ visibleFollowers(): Game_Follower[]; /** * Returns true if the followers are moving. * * @returns {Bool} * @memberof Game_Followers */ areMoving(): boolean; /** * Returns true if the followers are gathered. * * @returns {Bool} * @memberof Game_Followers */ areGathered(): boolean; /** * Returns true if the specified follower is collided at the specified x and y *coordinate. * * @param {number} x * @param {number} y * @returns {Bool} * @memberof Game_Followers */ isSomeoneCollided(x: number, y: number): boolean; } /** * ----------------------------------------------------------------------------- * Game_Interpreter * * The interpreter for running event commands. * @class Game_Interpreter */ declare class Game_Interpreter { constructor(depth: number); _depth: number; _branch: Object; _params: any[]; _indent: number; _frameCount: number; _freezeChecker: number; _mapId: number; _eventId: number; _list: rm.types.EventCommand[]; _index: number; _waitCount: number; _waitMode: string; _comments: string; _character: Game_Event; _childInterpreter: Game_Interpreter; checkOverflow(): void; /** * Clears the interpreter. * * @memberof Game_Interpreter */ clear(): void; /** * Sets up the interpreter with the list of event commands, and the given * event Id. * * @param {Array} list * @param {Int} eventId * @memberof Game_Interpreter */ setup(list: rm.types.EventCommand[], eventId: number): void; /** * Returns the currrent eventId. * * @returns {Int} * @memberof Game_Interpreter */ eventId(): number; /** * Returns true if the event is on the current map. * * @returns {Bool} * @memberof Game_Interpreter */ isOnCurrentMap(): boolean; /** * Returns true after setting up the reserved common event. * * @returns {Bool} * @memberof Game_Interpreter */ setupReservedCommonEvent(): boolean; /** * Returns true if the interpreter is running. * * @returns {Bool} * @memberof Game_Interpreter */ isRunning(): boolean; update(): void; /** * Updates the child game interpreter. * * @returns {Bool} * @memberof Game_Interpreter */ updateChild(): boolean; /** * Updates the wait of the game interpreter. * * @returns {Bool} * @memberof Game_Interpreter */ updateWait(): boolean; updateWaitCount(): boolean; updateWaitMode(): boolean; /** * Sets the wait mode of the interpreter. * * @param {String} waitMode * @memberof Game_Interpreter */ setWaitMode(waitMode: string): void; /** * sets a specified wait duration for the interpreter. * * @param {Int} duration * @memberof Game_Interpreter */ wait(duration: number): void; fadeSpeed(): number; /** * Executes the event command; * returns true or false based on execution. * @returns {Bool} * @memberof Game_Interpreter */ executeCommand(): boolean; /** * Checks if the interpreter has frozen. * * @returns {Bool} * @memberof Game_Interpreter */ checkFreeze(): boolean; /** * Terminates the game interpreter. * * @memberof Game_Interpreter */ terminate(): void; /** * Skips a conditional branch on the interpreter. * * @memberof Game_Interpreter */ skipBranch(): void; /** * Returns the current event command. * * @returns {RPG.EventCommand} * @memberof Game_Interpreter */ currentCommand(): rm.types.EventCommand; /** * Returns the next event code. * * @returns {Int} * @memberof Game_Interpreter */ nextEventCode(): number; iterateActorId(param: number, callback: (actor: Game_Actor) => void): void; iterateActorEx(param1: number, param2: number, callback: (actor: Game_Actor) => void): void; iterateActorIndex(param: number, callback: (actor: Game_Actor) => void): void; iterateEnemyIndex(param: number, callback: (enemt: Game_Enemy) => void): void; iterateBattler(param1: number, param2: number, callback: (battler: Game_Battler) => void): void; character(param: number): Game_Character; operateValue(operation: number, operandType: number, operand: number): number; changeHp(target: number, value: number, allowDeath: boolean): void; /** * Show Text */ command101(): boolean; /** * Show Choices */ command102(): boolean; setupChoices(params: any[]): void; /** * When [**] */ command402(): boolean; /** * When Cancel */ command403(): boolean; /** * Input Number */ command103(): boolean; /** * * @param params */ setupNumInput(params: number[]): void; /** * Select Item */ command104(): boolean; setupItemChoice(params: number[]): void; /** * Show Scrolling Text */ command105(): boolean; /** * Comment */ command108(): boolean; /** * Conditional Branch */ command111(): boolean; /** * Else */ command411(): boolean; /** * Loop */ command112(): boolean; /** * Repeat Above */ command413(): boolean; /** * Break Loop */ command113(): boolean; /** * Exit Event Processing */ command115(): boolean; /** * Common Event */ command117(): boolean; setupChild(list: rm.types.EventCommand[], eventId: number): void; /** * Label */ command118(): boolean; /** * Jump to Label */ command119(): boolean; jumpTo(index: number): void; /** * Control Switches */ command121(): boolean; /** * Control Variables */ command122(): boolean; gameDataOperand(type: number, param1: number, param2: number): number; operateVariable(variableId: number, operationType: number, value: number): void; /** * Control Self Switch */ command123(): boolean; /** * Control Timer */ command124(): boolean; /** * Change Gold */ command125(): boolean; /** * Change Items */ command126(): boolean; /** * Change Weapons */ command127(): boolean; /** * Change Armors */ command128(): boolean; /** * Change Party Member */ command129(): boolean; /** * Change Battle BGM */ command132(): boolean; /** * Change Victory ME */ command133(): boolean; /** * Change Save Access */ command134(): boolean; /** * Change Menu Access */ command135(): boolean; /** * Change Encounter Disable */ command136(): boolean; /** * Change Formation Access */ command137(): boolean; /** * Change Window Color */ command138(): boolean; /** * Change Defeat ME */ command139(): boolean; /** * Change Vehicle BGM */ command140(): boolean; /** * Transfer Player */ command201(): boolean; /** * Set Vehicle Location */ command202(): boolean; /** * Set Event Location */ command203(): boolean; /** * Scroll Map */ command204(): boolean; /** * Set Movement Route */ command205(): boolean; /** * Getting On and Off Vehicles */ command206(): boolean; /** * Change Transparency */ command211(): boolean; /** * Show Animation */ command212(): boolean; /** * Show Balloon Icon */ command213(): boolean; /** * Erase Event */ command214(): boolean; /** * Change Player Followers */ command216(): boolean; /** * Gather Followers */ command217(): boolean; /** * Fadeout Screen */ command221(): boolean; /** * Fadein Screen */ command222(): boolean; /** * Tint Screen */ command223(): boolean; /** * Flash Screen */ command224(): boolean; /** * Shake Screen */ command225(): boolean; /** * Wait */ command230(): boolean; /** * Show Picture */ command231(): boolean; /** * Move Picture */ command232(): boolean; /** * Rotate Picture */ command233(): boolean; /** * Tint Picture */ command234(): boolean; /** * Erase Picture */ command235(): boolean; /** * Set Weather Effect */ command236(): boolean; /** * Play BGM */ command241(): boolean; /** * Fadeout BGM */ command242(): boolean; /** * Save BGM */ command243(): boolean; /** * Resume BGM */ command244(): boolean; /** * Play BGS */ command245(): boolean; /** * Fadeout BGS */ command246(): boolean; /** * Play ME */ command249(): boolean; /** * Play SE */ command250(): boolean; /** * Stop SE */ command251(): boolean; /** * Play Movie */ command261(): boolean; videoFileExt(): string; /** * Change Map Name Display */ command281(): boolean; /** * Change Tileset */ command282(): boolean; /** * Change Battle Back */ command283(): boolean; /** * Change Parallax */ command284(): boolean; /** * Get Location Info */ command285(): boolean; /** * Battle Processing */ command301(): boolean; /** * If Win */ command601(): boolean; /** * If Escape */ command602(): boolean; /** * If Lose */ command603(): boolean; /** * Shop Processing */ command302(): boolean; /** * Name Input Processing */ command303(): boolean; /** * Change HP */ command311(): boolean; /** * Change MP */ command312(): boolean; /** * Change TP */ command326(): boolean; /** * Change State */ command313(): boolean; /** * Recover All */ command314(): boolean; /** * Change EXP */ command315(): boolean; /** * Change Level */ command316(): boolean; /** * Change Parameter */ command317(): boolean; /** * Change Skill */ command318(): boolean; /** * Change Equipment */ command319(): boolean; /** * Change Name */ command320(): boolean; /** * Change Class */ command321(): boolean; /** * Change Actor Images */ command322(): boolean; /** * Change Vehicle Image */ command323(): boolean; /** * Change Nickname */ command324(): boolean; /** * Change Profile */ command325(): boolean; /** * Change Enemy HP */ command331(): boolean; /** * Change Enemy MP */ command332(): boolean; /** * Change Enemy TP */ command342(): boolean; /** * Change Enemy State */ command333(): boolean; /** * Enemy Recover All */ command334(): boolean; /** * Enemy Appear */ command335(): boolean; /** * Enemy Transform */ command336(): boolean; /** * Show Battle Animation */ command337(): boolean; /** * Force Action */ command339(): boolean; /** * Abort Battle */ command340(): boolean; /** * Open Menu Screen */ command351(): boolean; /** * Open Save Screen */ command352(): boolean; /** * Game Over */ command353(): boolean; /** * Return to Title Screen */ command354(): boolean; /** * Script */ command355(): boolean; /** * Plugin Command */ command356(): boolean; pluginCommand(command: string, args: string[]): void; } /** * Game_Item * The game object class for handling skills, items, weapons. armor. * This is required, because the save data should not include the database object itself. * @class Game_Item */ declare class Game_Item { constructor(item: rm.types.BaseItem); _dataClass: string; _itemId: number; initialize(): void; /** * Returns true the item is a skill. * * @returns {boolean} * @memberof Game_Item */ isSkill(): boolean; /** * Returns true if the item is an item. * * @returns {boolean} * @memberof Game_Item */ isItem(): boolean; /** * Returns true if the item is a usable item, similar to a potion. * * @returns {boolean} * @memberof Game_Item */ isUsableItem(): boolean; /** * Returns true if the item is a weapon. * * @returns {boolean} * @memberof Game_Item */ isWeapon(): boolean; /** * Returns true if the item is an armor. * * @returns {boolean} * @memberof Game_Item */ isArmor(): boolean; /** * Returns true if the item is equippable (weapon or armor). * * @returns {boolean} * @memberof Game_Item */ isEquipItem(): boolean; /** * Returns true if the item is 'null'. * * @returns {boolean} * @memberof Game_Item */ isNull(): boolean; /** * Returns the current itemId. * * @returns {number} * @memberof Game_Item */ itemId(): number; object(): rm.types.BaseItem; /** * Sets the current item of the current Game_Item object. * * @param {RPG.BaseItem} item * @memberof Game_Item */ setObject(item: rm.types.BaseItem): void; setEquip(isWeapon: boolean, itemId: number): void; } declare namespace rm.types { /** * The data class for tile sets. */ export type Tileset = { doc: string; /** * The flags table. A 1-dimensional array containing a variety of flags (Table). * * Uses tile IDs as subscripts. The correspondence of each bit is as shown below: * * 0x0001: Impassable downward * 0x0002: Impassable leftward * 0x0004: Impassable rightward * 0x0008: Impassable upward * 0x0010: Display on normal character * 0x0020: Ladder * 0x0040: Bush * 0x0080: Counter * 0x0100: Damage floor * 0x0200: Impassable by boat * 0x0400: Impassable by ship * 0x0800: Airship cannot land * 0xF000: Terrain tag * This manual does not discuss bit operations, but they are similar to those in C. * We recommend an Internet search using keywords such as "hexadecimal bit operations" when necessary. */ flags: number[]; /** * The ID of the tile set. */ id: number; internal: boolean; links: string[]; /** * The mode of the tile set (0: Field type, 1: Area type, 2: VX compatible type). */ mode: number; /** * The name of the tile set. */ name: string; parameters: string[]; platforms: haxe.display.Platform[]; targets: haxe.display.MetadataTarget[]; /** * The file name of the graphic used as the number index (0-8) tile set. * * The correspondence between numbers and sets is illustrated in the table below. * * 0 TileA1 * 1 TileA2 * 2 TileA3 * 3 TileA4 * 4 TileA5 * 5 TileB * 6 TileC * 7 TileD * 8 TileE */ tilesetNames: string[]; } } declare namespace rm.types { export type MapEncounter = { /** * An array containing Region IDs. */ regionSet: number[]; /** * The enemy Troop ID. */ troopId: number; /** * Weight/chance among enemies on the map that you'll * meet this enemy. */ weight: number; } } /** * The game object for the map. It contains scrolling and passage functions * along with the game interpreter. */ declare class Game_Map { constructor(); _interpreter: Game_Interpreter; _mapId: number; _tilesetId: number; _events: Game_Event[]; _commonEvents: Game_CommonEvent[]; _vehicles: Game_Vehicle[]; _displayX: number; _displayY: number; _nameDisplay: boolean; _scrollDirection: number; _scrollRest: number; _scrollSpeed: number; _parallaxName: string; _parallaxZero: boolean; _parallaxLoopX: boolean; _parallaxLoopY: boolean; _parallaxSx: number; _parallaxSy: number; _parallaxX: number; _parallaxY: number; _battleback1Name: string; _battleback2Name: string; _needsRefresh: boolean; initialize(): void; setup(mapId: number): void; /** * Returns true if an event is running. * * @returns {Bool} * @memberof Game_Map */ isEventRunning(): boolean; /** * Returns tile width. * * @returns {Int} * @memberof Game_Map */ tileWidth(): number; /** * Returns tile height. * * @returns {Int} * @memberof Game_Map */ tileHeight(): number; /** * Returns map id. * * @returns {Int} * @memberof Game_Map */ mapId(): number; /** * Returns the tileset id. * * @returns {Int} * @memberof Game_Map */ tilesetId(): number; /** * Returns the display x coordinate. * * @returns {Int} * @memberof Game_Map */ displayX(): number; /** * Returns the display y coordinate. * * @returns {Int} * @memberof Game_Map */ displayY(): number; parallaxName(): string; /** * Returns the name of battle back 1. * * @returns {String} * @memberof Game_Map */ battleback1Name(): string; /** * Returns the name of battle back 2. * * @returns {String} * @memberof Game_Map */ battleback2Name(): string; requestRefresh(mapId: number): void; /** * Returns true if the name display is enabled. * * @returns {Bool} * @memberof Game_Map */ isNameDisplayEnabled(): boolean; /** * Disables name display. * * @memberof Game_Map */ disableNameDisplay(): void; /** * Enable name display. * * @memberof Game_Map */ enableNameDisplay(): void; /** * Creates the vehicles for the game map. * * @memberof Game_Map */ createVehicles(): void; /** * Refreshes the vehicles on the game map. * * @memberof Game_Map */ refereshVehicles(): void; vehicles(): Game_Vehicle[]; /** * Returns the game vehicle specified by type. * * @param {String} type * @returns {Game_Vehicle} * @memberof Game_Map */ vehicle(type: string): Game_Vehicle; /** * Returns the game boat. * * @returns {Game_Vehicle} * @memberof Game_Map */ boat(): Game_Vehicle; /** * Returns the game ship. * * @returns {Game_Vehicle} * @memberof Game_Map */ ship(): Game_Vehicle; /** * Returns the game airship. * * @returns {Game_Vehicle} * @memberof Game_Map */ airship(): Game_Vehicle; setupEvents(): void; /** * Returns all events on the game map. * * @returns {Array} * @memberof Game_Map */ events(): Game_Event[]; /** * Returns an event, given the event id. * * @param {Int} eventId * @returns {Game_Event} * @memberof Game_Map */ event(eventId: number): Game_Event; /** * Erases the event given the event id. * * @param {Int} eventId * @memberof Game_Map */ eraseEvent(eventId: number): void; /** * Returns all the parallel running common events. * * @returns {Array} * @memberof Game_Map */ parallelCommonEvents(): rm.types.CommonEvent[]; setupScroll(): void; setupParallax(): void; setupBattleback(): void; setDisplayPos(x: number, y: number): void; parallaxOx(): number; parallaxOy(): number; /** * Returns the tilset of the game map. * * @returns {RPG.Tileset} * @memberof Game_Map */ tileset(): rm.types.Tileset; /** * Returns the tileset flags of the game map. * * @returns {Array} * @memberof Game_Map */ tilesetFlags(): number[]; /** * Returns the display name of the game map. * * @returns {String} * @memberof Game_Map */ displayName(): string; /** * Returns the map width. * * @returns {Int} * @memberof Game_Map */ width(): number; /** * Returns the map height. * * @returns {Int} * @memberof Game_Map */ height(): number; /** * Returns the map data. * * @returns {Array} * @memberof Game_Map */ data(): number[]; /** * Returns true if the map loops horizontally. * * @returns {Bool} * @memberof Game_Map */ isLoopHorizontal(): boolean; /** * Returns true if the map loops vertically. * * @returns {Bool} * @memberof Game_Map */ isLoopVertical(): boolean; /** * Returns true if dash is disabled on the map. * * @returns {Bool} * @memberof Game_Map */ isDashDisabled(): boolean; /** * Returns the list of possible encounters on the current map. * * @returns {Array} * @memberof Game_Map */ encounterList(): rm.types.MapEncounter[]; /** * Returns the Int of encounter steps on the map. * * @returns {Int} * @memberof Game_Map */ encounterStep(): number; /** * Returns true if the map is an over world map. * * @returns {Bool} * @memberof Game_Map */ isOverworld(): boolean; /** * Returns the screen tile x coordinate. * * @returns {Int} * @memberof Game_Map */ screenTileX(): number; /** * Returns the screen tile y coordinate. * * @returns {Int} * @memberof Game_Map */ screenTileY(): number; adjustX(x: number): number; adjustY(y: number): number; roundX(x: number): number; roundY(y: number): number; xWithDirection(x: number, d: number): number; yWithDirection(y: number, d: number): number; roundXWithDirection(x: number, d: number): number; roundYWithDirection(y: number, d: number): number; deltaX(x1: number, x2: number): number; deltaY(y1: number, y2: number): number; distance(x1: number, y1: number, x2: number, y2: number): number; /** * Converts the x coordinate from canvas to map coordinate x. * * @param {Int} x * @returns {Int} * @memberof Game_Map */ canvasToMapX(x: number): number; /** * Converts the y coordinate from canvas to map y coordinate. * * @param {Int} y * @returns {Int} * @memberof Game_Map */ canvasToMapY(y: number): number; /** * Auto plays the game map. * * @memberof Game_Map */ autoplay(): void; refreshIfNeeded(): void; refresh(): void; refreshTileEvents(): void; /** * Returns the game events at the specified * x and y position. * @param {Int} x * @param {Int} y * @returns {Array} * @memberof Game_Map */ eventsXy(x: number, y: number): Game_Event[]; eventsXyNt(x: number, y: number): Game_Event[]; tileEventsXy(x: number, y: number): Game_Event[]; eventIdXy(x: number, y: number): number; scrollDown(distance: number): void; scrollLeft(distance: number): void; scrollRight(distance: number): void; scrollUp(distance: number): void; /** * Returns true if the x and y coordinates are valid. * * @param {Int} x * @param {Int} y * @returns {Bool} * @memberof Game_Map */ isValid(x: number, y: number): boolean; checkPassage(x: number, y: number, bit: number): boolean; /** * Returns the tile id at the specified x, y, and z coordinates. * * @param {Int} x * @param {Int} y * @param {Int} z * @returns {Int} * @memberof Game_Map */ tileId(x: number, y: number, z: number): number; layeredTiles(x: number, y: number): number[]; allTiles(x: number, y: number): number[]; autotileType(x: number, y: number, z: number): number; isPassable(x: number, y: number, d: number): boolean; isBoatPassable(x: number, y: number): boolean; isShipPassable(x: number, y: number): boolean; isAirshipLandOk(x: number, y: number): boolean; checkLayeredTilesFlags(x: number, y: number, bit: number): boolean; /** * Returns true if the specified element at the given x and y coordinates * is a ladder. * @param {Int} x * @param {Int} y * @returns {Bool} * @memberof Game_Map */ isLadder(x: number, y: number): boolean; isBush(x: number, y: number): boolean; isCounter(x: number, y: number): boolean; isDamageFloor(x: number, y: number): boolean; terrainTag(x: number, y: number): number; regionId(x: number, y: number): number; startScroll(direction: number, distance: number, speed: number): void; isScrolling(): boolean; /** * Updates the game map, given that the scene is active. * * @param {Bool} sceneActive * @memberof Game_Map */ update(sceneActive: boolean): void; updateScroll(): void; scrollDistance(): number; doScroll(direction: number, distance: number): void; /** * Updates all events on the map. * * @memberof Game_Map */ updateEvents(): void; /** * Updates all game vehicles on the map. * * @memberof Game_Map */ updateVehicles(): void; /** * Updates the map parallaxes. * * @memberof Game_Map */ updateParallax(): void; /** * Changes them ap tileset, given the tileset id. * * @param {Int} tilesetId * @memberof Game_Map */ changeTileset(tilesetId: number): void; changeBattleback(battleback1Name: string, battleback2Name: string): void; changeParallax(name: string, loopX: boolean, loopY: boolean, sx: number, sy: number): void; /** * Updates the map's game interpreter. * * @memberof Game_Map */ updateInterpreter(): void; /** * Unlocks an event on the map given the event id. * * @param {Int} eventId * @memberof Game_Map */ unlockEvent(eventId: number): void; setupStartingEvent(): boolean; setupTestEvent(): boolean; setupStartingMapEvent(): boolean; /** * Sets up an auto run common event. * * @returns {Bool} * @memberof Game_Map */ setupAutorunCommonEvent(): boolean; /** * Returns true if any event is starting on the map. * * @returns {Bool} * @memberof Game_Map */ isAnyEventStarting(): boolean; } declare namespace rm.types { export const enum MessageBackgroundType { base = -1, } } declare namespace rm.types { export const enum MessagePositionType { base = -1, } } declare namespace rm.types { export const enum ChoiceDefaultType { base = -1, } } declare namespace rm.types { export const enum ChoiceCancelType { base = -1, } } declare namespace rm.types { export const enum ChocieBackgroundType { base = -1, } } declare namespace rm.types { export const enum ChoicePositionType { base = -1, } } declare class Game_Message { constructor(); _texts: string[]; _choices: string[]; _faceName: string; _faceIndex: number; _background: rm.types.MessageBackgroundType; _positionType: rm.types.MessagePositionType; _choiceDefaultType: rm.types.ChoiceDefaultType; _choiceCancelType: rm.types.ChoiceCancelType; _choiceBackground: rm.types.ChocieBackgroundType; _choicePositionType: rm.types.ChoicePositionType; _numInputVariableId: number; _numInputMaxDigits: number; _itemChoiceVariableId: number; _itemChoiceItypeId: number; _scrollMode: boolean; _scrollSpeed: number; _scrollNoFast: boolean; _choiceCallback: (n: number) => void; initialize(): void; clear(): void; choices(): string[]; /** * Returns the name of the face image used for the message. * * @returns {String} * @memberof Game_Message */ faceName(): string; /** * Returns the face index within the face image to display the * correct face. * @returns {number} * @memberof Game_Message */ faceIndex(): number; /** * Returns the background associated with the message; * this is the background * @returns {number} * @memberof Game_Message */ background(): number; /** * Returns the current position type of the message window. * * @returns {number} * @memberof Game_Message */ positionType(): number; choiceDefaultType(): number; choiceCancelType(): number; /** * Returns the background type of the choice window. * * @returns {number} * @memberof Game_Message */ choiceBackground(): number; /** * Returns the position of the choice window. * * @returns {number} * @memberof Game_Message */ choicePositionType(): number; /** * Returns the number input variable id. * * @returns {number} * @memberof Game_Message */ numInputVariableId(): number; /** * Returns the number input maximum digits. * * @returns {number} * @memberof Game_Message */ numInputMaxDigits(): number; /** * Returns the item choice variable id. * * @returns {number} * @memberof Game_Message */ itemChoiceVariableId(): number; /** * Returns the item choice item type id. * * @returns {number} * @memberof Game_Message */ itemChoiceItypeId(): number; /** * Returns true if the scroll mode is set to true. * * @returns {boolean} * @memberof Game_Message */ scrollMode(): boolean; /** * Returns the scroll speed. * * @returns {number} * @memberof Game_Message */ scrollSpeed(): number; /** * Returns true if the scroll is set to not being fast. * * @returns {boolean} * @memberof Game_Message */ scrollNoFast(): boolean; /** * Adds text to the game message object. * * @param {String} text * @memberof Game_Message */ add(text: string): void; setFaceImage(faceName: string, faceIndex: number): void; /** * Sets the background of the message window; * options are 0 (fully opaque), 1 (transparent), 2 (invisible background). * The default is 0. * @param {number} background * @memberof Game_Message */ setBackground(background: number): void; /** * Sets the position of the message window; * default is 2. * @param {number} positionType * @memberof Game_Message */ setPositionType(positionType: number): void; /** * Sets the choices within the choice window; * sets the default and cancel choices for the window. * @param {Array} choices * @param {number} defaultType * @param {number} cancelType * @memberof Game_Message */ setChoices(choices: string[], defaultType: number, cancelType: number): void; setChoiceBackground(background: number): void; /** * Sets the position of the choice window associated with the * message window. * @param {number} positionType * @memberof Game_Message */ setChoicePositionType(positionType: number): void; /** * Sets the number input and associates it with a variable id; * the max number of digits can also be set. * @param {number} variableId * @param {number} maxDigits * @memberof Game_Message */ setNumberInput(variableId: number, maxDigits: number): void; /** * Sets the choice and associates it with a variable id; * sets the itemtype id associated with the choice. * @param {number} variableId * @param {number} itemType * @memberof Game_Message */ setItemChoice(variableId: number, itemType: number): void; /** * Sets the scroll speed of the message window; * disable fast movement if noFast is set to true. * @param {number} speed * @param {boolean} noFast * @memberof Game_Message */ setScroll(speed: number, noFast: boolean): void; /** * Sets a callback to be associated with a specific choice; * a callback is a JavaScript function that will be run when the * choice is selected. * @param {((n: number) => Void)} callback * @memberof Game_Message */ setChoiceCallback(callback: (n: number) => void): void; onChoice(n: number): void; /** * Returns true if the game message object has text. * * @returns {boolean} * @memberof Game_Message */ hasText(): boolean; /** * Returns true if the game message object has a set of choices. * * @returns {boolean} * @memberof Game_Message */ isChoice(): boolean; /** * Returns true if the game message object has a number input attached. * * @returns {boolean} * @memberof Game_Message */ isNumberInput(): boolean; /** * Returns true if the game message object has an item choice attached. * * @returns {boolean} * @memberof Game_Message */ isItemChoice(): boolean; /** * Returns true if the game message object has text, choices, number input, * or item choice. * @returns {boolean} * @memberof Game_Message */ isBusy(): boolean; /** * Creates a new page for the text within the message window. * * @memberof Game_Message */ newPage(): void; /** * Returns all of the text contained within the message. * * @returns {String} * @memberof Game_Message */ allText(): string; } /** * Superclass of Game_Party & Game_Troop * * @class Game_Unit */ declare class Game_Unit { constructor(); _inBattle: boolean; initialize(): void; /** * Returns true if unit is in battle. * * @returns {boolean} * @memberof Game_Unit */ inBattle(): boolean; /** * Returns the list of battlers. * * @returns {Array} * @memberof Game_Unit */ members(): Game_Battler[]; /** * Returns the list of alive battlers. * * @returns {Array} * @memberof Game_Unit */ aliveMembers(): Game_Battler[]; /** * Returns the list of dead battlers. * * @returns {Array} * @memberof Game_Unit */ deadMembers(): Game_Battler[]; /** * Returns the list of movable members. * * @returns {Array} * @memberof Game_Unit */ movableMembers(): Game_Battler[]; /** * Clears the unit's actions. * * @memberof Game_Unit */ clearActions(): void; /** * Returns the agility of the unit. * * @returns {Int} * @memberof Game_Unit */ agility(): number; tgrSum(): number; /** * Returns a random target from the game unit. * * @returns {Game_Battler} * @memberof Game_Unit */ randomTarget(): Game_Battler; /** * Returns a random dead target from the game unit. * * @returns {Game_Battler} * @memberof Game_Unit */ randomDeadTarget(): Game_Battler; smoothTarget(index: number): Game_Battler; smoothDeadTarget(index: number): Game_Battler; /** * Clears the action results. * * @memberof Game_Unit */ clearResults(): void; /** * Handler for when battle is started. * * @memberof Game_Unit */ onBattleStart(): void; /** * Handler for when battle has ended. * * @memberof Game_Unit */ onBattleEnd(): void; /** * Creates the action's of the game unit. * * @memberof Game_Unit */ makeActions(): void; /** * Selects a member of the unit given a battler. * * @param {Game_Battler} activeMember * @memberof Game_Unit */ select(activeMember: Game_Battler): void; /** * Returns true if all members of the unit are dead. * * @returns {Bool} * @memberof Game_Unit */ isAllDead(): boolean; substituteBattler(): Game_Battler; } /** * The game object for the party. Contains information * such as gold and items. */ declare class Game_Party extends Game_Unit { protected constructor(); _gold: number; _steps: number; _lastItem: Game_Item; _menuActorId: number; _targetActorId: number; _actors: Game_Actor[]; /** * Data structure. * [ItemId:Int] : Int */ _items: { [key: string]: any }; /** * Data structure. * [weaponId:Int] : Int */ _weapons: { [key: string]: any }; /** * Data structure. * [armorId:Int] : Int */ _armors: { [key: string]: any }; /** * Returns all party members. * * @returns {Array} * @memberof Game_Party */ members(): Game_Actor[]; /** * Returns the living party members. * * @returns {Array} * @memberof Game_Party */ aliveMembers(): Game_Actor[]; /** * Returns the dead party members. * * @returns {Array} * @memberof Game_Party */ deadMembers(): Game_Actor[]; /** * Returns the movable members in the party. * * @returns {Array} * @memberof Game_Party */ movableMembers(): Game_Actor[]; /** * Returns the battle members in the party. * * @returns {Array} * @memberof Game_Party */ battleMembers(): Game_Actor[]; /** * Initialize all party items. * * @memberof Game_Party */ initAllItems(): void; /** * Returns true if the game party exists. * * @returns {Bool} * @memberof Game_Party */ exists(): boolean; /** * Returns the size of the party. * * @returns {Int} * @memberof Game_Party */ size(): number; /** * Returns true if the game party is empty. * * @returns {Bool} * @memberof Game_Party */ isEmpty(): boolean; /** * Returns the maximum battle members in the party. * * @returns {Int} * @memberof Game_Party */ maxBattleMembers(): number; /** * Returns the leader of the party. * * @returns {Game_Actor} * @memberof Game_Party */ leader(): Game_Actor; /** * Revive the battle members of the party. * * @memberof Game_Party */ reviveBattleMembers(): void; items(): rm.types.Item[]; /** * Returns the weapons of the party. * * @returns {Array} * @memberof Game_Party */ weapons(): rm.types.Weapon[]; /** * Returns the party's armor. * * @returns {Array} * @memberof Game_Party */ armors(): rm.types.Armor[]; /** * Returns the party's equippable items. * * @returns {Array} * @memberof Game_Party */ equipItems(): rm.types.EquipItem[]; /** * Returns all items within the party's posession. * Items can be of equip item, or item type. * @returns {Array} * @memberof Game_Party */ allItems(): rm.types.BaseItem[]; itemContainer(item: rm.types.BaseItem): { ItemId: number }; /** * Sets up the starting party members. * * @memberof Game_Party */ setupStartingMembers(): void; name(): string; /** * Sets up a test battle with the party. * * @memberof Game_Party */ setupBattleTest(): void; /** * Sets up the battle test members. * * @memberof Game_Party */ setupBattleTestMembers(): void; /** * Sets up the battle test items. * * @memberof Game_Party */ setupBattleTestItems(): void; /** * Returns the highest level in the party. * * @returns {Int} * @memberof Game_Party */ highestLevel(): number; /** * Adds an actor to the party given the actor id. * * @param {Int} actorId * @memberof Game_Party */ addActor(actorId: number): void; /** * Removes an actor from the party given the actor id. * * @param {Int} actorId * @memberof Game_Party */ removeActor(actorId: number): void; /** * Returns party gold. * * @returns {Int} * @memberof Game_Party */ gold(): number; /** * Increases the party gold given a specified amount. * * @param {Int} amount * @memberof Game_Party */ gainGold(amount: number): void; /** * Decreases the party gold given a specified amount. * * @param {Int} amount * @memberof Game_Party */ loseGold(amount: number): void; /** * Returns maximum gold of the party. * * @returns {Int} * @memberof Game_Party */ maxGold(): number; /** * Returns the Int of steps the party has taken. * * @returns {Int} * @memberof Game_Party */ steps(): number; /** * Increases the Int of steps the party has taken. * * @memberof Game_Party */ increaseSteps(): void; /** * Returns the Int of items in the possession of the party of the * given item. * @param {RPG.BaseItem} item * @returns {Int} * @memberof Game_Party */ numItems(item: rm.types.BaseItem): number; /** * Returns the maximum Int of items of the given item. * * @param {RPG.BaseItem} item * @returns {Int} * @memberof Game_Party */ maxItems(item: rm.types.BaseItem): number; hasMaxItems(item: rm.types.BaseItem): boolean; /** * Returns true if the party has the given item; * if includeEquip is set to true, this will also check party equipment. * @param {RPG.BaseItem} item * @param {Bool} includeEquip * @returns {Bool} * @memberof Game_Party */ hasItem(item: rm.types.BaseItem, includeEquip: boolean): boolean; /** * Returns true if any party member has the specified equip item. * * @param {RPG.EquipItem} item * @returns {Bool} * @memberof Game_Party */ isAnyMemberEquipped(item: rm.types.EquipItem): boolean; gainItem(item: rm.types.BaseItem, amount: number, includeEquip: boolean): void; discardMembersEquip(item: rm.types.EquipItem, amount: number): void; loseItem(item: rm.types.BaseItem, amount: number, includeEquip: boolean): void; /** * Has the party consume the given item. * * @param {RPG.BaseItem} item * @memberof Game_Party */ consumeItem(item: rm.types.BaseItem): void; /** * Returns true if the party can use the item. * * @param {RPG.BaseItem} item * @returns {Bool} * @memberof Game_Party */ canUse(item: rm.types.BaseItem): boolean; canInput(): boolean; /** * Handler for when the player walks. * * @memberof Game_Party */ onPlayerWalk(): void; /** * Returns the actor that will be used in the current menu; * this is for menu scenes that target one actor. * @returns {Game_Actor} * @memberof Game_Party */ menuActor(): Game_Actor; setMenuActor(actor: Game_Actor): void; makeMenuActorNext(): void; makeMenuActorPrevious(): void; targetActor(): Game_Actor; setTargetActor(actor: Game_Actor): void; /** * Returns the last item selected by the game party. * * @returns {RPG.BaseItem} * @memberof Game_Party */ lastItem(): rm.types.BaseItem; setLastItem(item: rm.types.BaseItem): void; swapOrder(index1: number, index2: number): void; /** * Returns the characters that go on the save life. * * @returns {Array>} * @memberof Game_Party */ charactersForSavefile(): any[][]; /** * Returns the actor faces for the save file. * * @returns {Array>} * @memberof Game_Party */ facesForSavefile(): any[][]; partyAbility(abilityId: number): boolean; /** * Returns true if the encounter rate is set to half. * * @returns {Bool} * @memberof Game_Party */ hasEncounterHalf(): boolean; /** * Returns true if the encounter rate is set to none. * * @returns {Bool} * @memberof Game_Party */ hasEncounterNone(): boolean; hasCancelSurprise(): boolean; /** * Returns true if the party has an increased chance of preemptive strike. * * @returns {Bool} * @memberof Game_Party */ hasRaisePreemptive(): boolean; /** * Returns true if the party has double gold in effect. * * @returns {Bool} * @memberof Game_Party */ hasGoldDouble(): boolean; hasDropItemDouble(): boolean; ratePreemptive(troopAgi: number): number; rateSurprise(troopAgi: number): number; /** * Performs victory motion for the entire party. * * @memberof Game_Party */ performVictory(): void; /** * Performs escape motion for the entire party. * * @memberof Game_Party */ performEscape(): void; /** * Remove battle states from all actors in the party. * * @memberof Game_Party */ removeBattleStates(): void; /** * Refreshes the motion on all actors in the party. * * @memberof Game_Party */ requestMotionRefresh(): void; static ABILITY_ENCOUNTER_HALF: number; static ABILITY_ENCOUNTER_NONE: number; static ABILITY_CANCEL_SURPRISE: number; static ABILITY_RAISE_PREEMPTIVE: number; static ABILITY_GOLD_DOUBLE: number; static ABILITY_DROP_ITEM_DOUBLE: number; } /** * ----------- * The game object class for a picture. * */ declare class Game_Picture { constructor(); /** * _name property of the current picture. * * @protected * @type {string} * @memberof Game_Picture */ _name: string; _origin: number; _x: number; _y: number; _scaleX: number; _scaleY: number; _opacity: number; /** * Blend Mode, accepts an integer. */ _blendMode: number; _targetX: number; _targetY: number; _targetScaleX: number; _targetScaleY: number; _targetOpacity: number; _duration: number; /** * Tone of the picture, in RGB format. * 0 - 255, for all three tone elements. */ _tone: number[]; _toneTarget: number[]; _toneDuration: number; _angle: number; _rotationSpeed: number; initialize(): void; /** * Returns the name of the game picture. * * @returns {string} * @memberof Game_Picture */ name(): string; /** * Returns the origin of the game picture. * * @returns {number} * @memberof Game_Picture */ origin(): number; /** * Returns the picture x coordinate. * * @returns {number} * @memberof Game_Picture */ x(): number; /** * Returns the picture y coordinate. * * @returns {number} * @memberof Game_Picture */ y(): number; /** * Returns x scale of the game picture. * * @returns {number} * @memberof Game_Picture */ scaleX(): number; /** * Returns the y scale of the game picture. * * @returns {number} * @memberof Game_Picture */ scaleY(): number; /** * Returns the opacity of the game picture. * * @returns {number} * @memberof Game_Picture */ opacity(): number; /** * Returns the blend mode of the game picture. * * @returns {number} * @memberof Game_Picture */ blendMode(): number; /** * Returns the tone of the game picture. * * @returns {Array} * @memberof Game_Picture */ tone(): number[]; /** * Returns the angle of the game picture. * * @returns {number} * @memberof Game_Picture */ angle(): number; initBasic(): void; initTarget(): void; initTone(): void; initRotation(): void; show(name: string, origin: number, x: number, y: number, scaleX: number, scaleY: number, opacity: number, blendMode: number): void; move(origin: number, x: number, y: number, scaleX: number, scaleY: number, opacity: number, blendMode: number, duration: number): void; rotate(speed: number): void; tint(tone: number[], duration: number): void; /** * Erases the game picture. * * @memberof Game_Picture */ erase(): void; /** * Updates the game picture. * * @memberof Game_Picture */ update(): void; /** * Updates the movement of the game picture. * * @memberof Game_Picture */ updateMove(): void; /** * Updates the tone of the game picture. * * @memberof Game_Picture */ updateTone(): void; /** * Updates the rotation of the game picture. * * @memberof Game_Picture */ updateRotation(): void; } /** * The game object class for the player. It contains, * encounter information, x, y, vehicle type, and whether * the player is dashing. The Game Player State is this * object. */ declare class Game_Player extends Game_Character { protected constructor(); _vehicleType: string; _vehicleGettingOn: boolean; _vehicleGettingOff: boolean; _dashing: boolean; _needsMapReload: boolean; _transferring: boolean; _newX: number; _newY: number; _newDirection: rm.types.Direction; _fadeType: number; _followers: Game_Followers; _encounterCount: number; /** * Clears the transfer information for the player. * * @memberof Game_Player */ clearTransferInfo(): void; /** * Returns the player followers (party members). * * @returns {Game_Followers} * @memberof Game_Player */ followers(): Game_Followers; /** * Refreshes the game player. * * @memberof Game_Player */ refresh(): void; /** * Returns true if the player is stopping. * * @returns {Bool} * @memberof Game_Player */ isStopping(): boolean; /** * Reserves a transfer of the player to the specified map, at the given * x and y coordinates, facing the given direction (d). Using a specific fade. * @param {Int} mapId * @param {Int} x * @param {Int} y * @param {Int} [d] * @param {Int} [fadeType] * @memberof Game_Player */ reserveTransfer(mapId: number, x: number, y: number, d?: number, fadeType?: number): void; requestMapReload(): void; isTransferring(): boolean; /** * Returns the new map id. * * @returns {Int} * @memberof Game_Player */ newMapId(): number; fadeType(): number; /** * Performs a transfer of the player to a different area or map. * * @memberof Game_Player */ performTransfer(): void; isMapPassable(x: number, y: number, d: number): boolean; /** * Returns the current vehicles the player is riding in. * * @returns {Game_Vehicle} * @memberof Game_Player */ vehicle(): Game_Vehicle; /** * Returns true if the player is in a boat. * * @returns {Bool} * @memberof Game_Player */ isInBoat(): boolean; /** * Returns true if the player is in a ship. * * @returns {Bool} * @memberof Game_Player */ isInShip(): boolean; /** * Returns true if the player is in an airship. * * @returns {Bool} * @memberof Game_Player */ isInAirship(): boolean; /** * Returns true if the player is in a vehicle. * * @returns {Bool} * @memberof Game_Player */ isInVehicle(): boolean; /** * Returns true if the player is in their normal state. * * @returns {Bool} * @memberof Game_Player */ isNormal(): boolean; /** * Returns true if the player is dashing. * * @returns {Bool} * @memberof Game_Player */ isDashRing(): boolean; isDebugThrough(): boolean; isCollided(x: number, y: number): boolean; /** * Returns the player's center x coordinate. * * @returns {Int} * @memberof Game_Player */ centerX(): number; /** * Returns the player's center y coordinate. * * @returns {Int} * @memberof Game_Player */ centerY(): number; center(x: number, y: number): void; locate(x: number, y: number): void; increaseSteps(): void; /** * Creates the encounter count for the player. * * @memberof Game_Player */ makeEncounterCount(): void; /** * Creates the encounter troop id and returns it. * * @returns {Int} * @memberof Game_Player */ makeEncounterTroopId(): number; meetsEncounterConditions(encounter: rm.types.MapEncounter): boolean; /** * Executes an encounter. * * @returns {Bool} * @memberof Game_Player */ executeEncounter(): boolean; /** * Has the player start a map event at the given x and y coordinates. * Also passing the triggers and whether the event start is normal. * @param {Int} x * @param {Int} y * @param {Array} triggers * @param {Bool} normal * @memberof Game_Player */ startMapEvent(x: number, y: number, triggers: number[], normal: boolean): void; moveByInput(): void; /** * Returns true if the player can move. * * @returns {Bool} * @memberof Game_Player */ canMove(): boolean; /** * Gets the input direction of the player as a Int. * * @returns {Int} * @memberof Game_Player */ getInputDirection(): number; executeMove(direction: number): void; update(sceneActive?: boolean): void; /** * Updates the dashing of the player. * * @memberof Game_Player */ updateDashing(): void; /** * Returns true if the dash button is pressed. * * @returns {Bool} * @memberof Game_Player */ isDashButtonPressed(): boolean; updateScroll(lastScrolledX: number, lastScrolledY: number): void; /** * Updates the vehicle. * * @memberof Game_Player */ updateVehicle(): void; /** * Updates the player getting on the vehicle. * * @memberof Game_Player */ updateVehicleGetOn(): void; /** * Updates the player getting off the vehicle. * * @memberof Game_Player */ updateVehicleGetOff(): void; updateNonmoving(wasMoving: boolean): void; triggerAction(): boolean; triggerButtonAction(): boolean; /** * Returns true if the player triggered a touch action. * * @returns {Bool} * @memberof Game_Player */ triggerTouchAction(): boolean; triggerTouchActionD1(x1: number, y1: number): boolean; triggerTouchActionD2(x2: number, y2: number): boolean; triggerTouchActionD3(x2: number, y2: number): boolean; /** * Updates the player encounter count. * * @memberof Game_Player */ updateEncounterCount(): void; /** * Returns true if the player can encounter enemies. * * @returns {Bool} * @memberof Game_Player */ canEncounter(): boolean; /** * Returns the encounter progress value of the player. * * @returns {Int} * @memberof Game_Player */ encounterProgressValue(): number; checkEventTriggerHere(triggers: number[]): void; checkEventTriggerThere(triggers: number[]): void; /** * Returns true if the player can start local events. * * @returns {Bool} * @memberof Game_Player */ canStartLocalEvents(): boolean; /** * Returns true if the player is getting on/off a vehicle. * * @returns {Bool} * @memberof Game_Player */ getOnOffVehicle(): boolean; /** * Returns true if the player is getting on a vehicle. * * @returns {Bool} * @memberof Game_Player */ getOnVehicle(): boolean; /** * Returns true if the player is getting off a vehicle. * * @returns {Bool} * @memberof Game_Player */ getOffVehicle(): boolean; /** * Forces the player to move forward. * * @memberof Game_Player */ forceMoveForward(): void; /** * Returns true if the player is on a floor that does damage. * * @returns {Bool} * @memberof Game_Player */ isOnDamageFloor(): boolean; /** * Moves the player straight, given a direction. * * @param {Int} d * @memberof Game_Player */ moveStraight(d: number): void; /** * Moves the player diagonally, given a horizontal * and vertical direction. The numpad represents the directions. * @param {Int} horz * @param {Int} vert * @memberof Game_Player */ moveDiagonally(horz: number, vert: number): void; /** * Has the player jump in the given direction at the specified * x and y coordinate. This x and y will be added to the player's current * position. * @param {Int} xPlus * @param {Int} yPlus * @memberof Game_Player */ jump(xPlus: number, yPlus: number): void; /** * Shows the player followers. * * @memberof Game_Player */ showFollowers(): void; /** * Hides the player followers. * * @memberof Game_Player */ hideFollowers(): void; /** * Gather followers around the player. * * @memberof Game_Player */ gatherFollowers(): void; /** * Returns true if the followers are currently gathering. * * @returns {Bool} * @memberof Game_Player */ areFollowersGathering(): boolean; /** * Returns true if the followers are gathered. * * @returns {Bool} * @memberof Game_Player */ areFollowersGathered(): boolean; } /** * The game object class for screen effect data, such as * changes in color tone and flashes. * aliased as $gameScreen. * @class Game_Screen */ declare class Game_Screen { constructor(); initialize(): void; clear(): void; /** * Handler for when the battle starts in game; prepares * the screen for the battle scene. * @memberof Game_Screen */ onBattleStart(): void; /** * Returns the brightness of the game screen. * * @returns {number} * @memberof Game_Screen */ brightness(): number; tone(): number[]; flashColor(): number[]; shake(): number; /** * Returns the zoom x coordinate of the screen. * * @returns {number} * @memberof Game_Screen */ zoomX(): number; /** * Returns the zoom y coordiante of the screen. * * @returns {number} * @memberof Game_Screen */ zoomY(): number; /** * Returns the zoom scale of the screen. * * @returns {number} * @memberof Game_Screen */ zoomScale(): number; /** * Returns the current weather type. * * @returns {string} * @memberof Game_Screen */ weatherType(): string; /** * Returns the weather power. * * @returns {number} * @memberof Game_Screen */ weatherPower(): number; /** * Returns the specified picture given the picture id. * * @param {number} pictureId * @returns {Game_Picture} * @memberof Game_Screen */ picture(pictureId: number): Game_Picture; /** * Returns the real picture id, given the picture id. * * @param {number} pictureId * @returns {number} * @memberof Game_Screen */ realPictureId(pictureId: number): number; /** * Clears the screen fade. * * @memberof Game_Screen */ clearFade(): void; /** * Clears the screen tone. * * @memberof Game_Screen */ clearTone(): void; /** * Clears the screen flash. * * @memberof Game_Screen */ clearFlash(): void; /** * Clears the screen shake. * * @memberof Game_Screen */ clearShake(): void; /** * Clears the screen zoom. * * @memberof Game_Screen */ clearZoom(): void; /** * Clears the screen weather. * * @memberof Game_Screen */ clearWeather(): void; /** * Clears the pictures set on the game screen. * * @memberof Game_Screen */ clearPictures(): void; /** * Erases the battle pictures. * * @memberof Game_Screen */ eraseBattlePictures(): void; /** * Returns the maximum number of pictures set on the game screen. * * @returns {number} * @memberof Game_Screen */ maxPictures(): number; startFadeOut(duration: number): void; startFadeIn(duration: number): void; startTint(tone: number[], duration: number): void; startFlash(color: number[], duration: number): void; startShake(power: number, speed: number, duration: number): void; startZoom(x: number, y: number, scale: number, duration: number): void; setZoom(x: number, y: number, scale: number): void; changeWeather(type: string, power: number, duration: number): void; /** * Updates the game screen. * * @memberof Game_Screen */ update(): void; /** * Updates the screen fade out. * * @memberof Game_Screen */ updateFadeOut(): void; /** * Updates the screen fade in. * * @memberof Game_Screen */ updateFadeIn(): void; /** * Updates the screen tone. * * @memberof Game_Screen */ updateTone(): void; /** * Update the screen flash. * * @memberof Game_Screen */ updateFlash(): void; /** * Update the screen shake. * * @memberof Game_Screen */ updateShake(): void; /** * Update the screen zoom. * * @memberof Game_Screen */ updateZoom(): void; /** * Update the screen weather. * * @memberof Game_Screen */ updateWeather(): void; /** * Update the screen pictures. * * @memberof Game_Screen */ updatePictures(): void; startFlashForDamage(): void; showPicture(pictureId: number, name: string, origin: number, x: number, y: number, scaleX: number, scaleY: number, opacity: number, blendMode: number): void; movePicture(pictureId: number, origin: number, x: number, y: number, scaleX: number, scaleY: number, opacity: number, blendMode: number, duration: number): void; rotatePicture(pictureId: number, speed: number): void; tintPicture(pictureId: number, tone: number[], duration: number): void; /** * Erases a picture from the screen given the respected picture id. * * @param {number} pictureId * @memberof Game_Screen */ erasePicture(pictureId: number): void; } /** * The game object class for self switches. */ declare class Game_SelfSwitches { constructor(); /** * {key: Array} */ _data: { [key: string]: any }; initialize(): void; /** * Clears the array of data for the game's self switches. * * @memberof Game_SelfSwitches */ clear(): void; /** * Returns the value of the switch at the current key; * the value is a boolean (true or false). * @param {Array} key * @returns {boolean} * @memberof Game_SelfSwitches */ value(key: any[]): boolean; /** * Sets the value of the key of the respected self switch. * * @param {Array} key * @param {boolean} value * @memberof Game_SelfSwitches */ setValue(key: any[], value: boolean): void; onChange(): void; } /** * The game object class for game switches. * * @class Game_Switches */ declare class Game_Switches { constructor(); _data: boolean[]; initialize(): void; clear(): void; value(switchId: number): boolean; setValue(switchId: number, value: boolean): void; onChange(): void; } declare namespace rm.types { /** * The data class for audio file. */ export type AudioFile = { /** * The sound file name. */ name: string; /** * The pan. */ pan: number; /** * The sound's pitch (50..150). The default value is 100. */ pitch: number; /** * The sound's volume (0..100). The default values are 100 for BGM and ME and 80 for BGS and SE. */ volume: number; } } /** * Game_System * The game object class representing system data. * @class Game_System */ declare class Game_System { protected constructor(); initialize(): void; isJapanese(): boolean; isChinese(): boolean; isKorean(): boolean; isCJK(): boolean; isRussian(): boolean; isSideView(): boolean; isAutoSaveEnabled(): boolean; isSaveEnabled(): boolean; /** * Disables the ability to save the game. * * @memberof Game_System */ disableSave(): void; /** * Enables the ability to save the game. * * @memberof Game_System */ enableSave(): void; /** * Returns true if the menu is enabled. * * @returns {Bool} * @memberof Game_System */ isMenuEnabled(): boolean; /** * Disables the menu from being accessed. * * @memberof Game_System */ disableMenu(): void; /** * Enables the menu to be accessed. * * @memberof Game_System */ enableMenu(): void; isEncounterEnabled(): boolean; /** * Returns true if the player can encounter enemies. * * @memberof Game_System */ disableEncounter(): void; enableEncounter(): void; isFormationEnabled(): boolean; /** * Disables the use of the formation command in the menu. * * @memberof Game_System */ disableFormation(): void; /** * Enables the use of the formation command in the menu. * * @memberof Game_System */ enableFormation(): void; /** * Returns the number of battles the player has participated in. * * @returns {number} * @memberof Game_System */ battleCount(): number; /** * Returns the number of the wins the player has gained in battle. * * @returns {number} * @memberof Game_System */ winCount(): number; /** * Returns the number of battles the player has escaped from in battle. * * @returns {number} * @memberof Game_System */ escapeCount(): number; /** * Returns the number of saves the player has made in game. * * @returns {number} * @memberof Game_System */ saveCount(): number; /** * Returns the version id represented in the database. * * @returns {number} * @memberof Game_System */ versionId(): number; /** * Returns the current save file id * * @returns {number} * @memberof Game_System */ savefileId(): number; /** * Sets the save file id * * @returns {Void} * @memberof Game_System */ setSavefileId(savefileId: number): void; /** * Returns the tone of the window in the database. * * @returns {Array} * @memberof Game_System */ windowTone(): number[]; /** * Sets the window tone, given an array * of rgb. Example: [0, 255, 255]. * @param {Array} value * @memberof Game_System */ setWindowTone(value: number[]): void; /** * Returns the current battle background music. * * @returns {AudioFile} * @memberof Game_System */ battleBgm(): rm.types.AudioFile; /** * Sets the battle background music. * * @param {AudioFile} value * @memberof Game_System */ setBattleBgm(value: rm.types.AudioFile): void; /** * Returns the victory musical effect. * * @returns {AudioFile} * @memberof Game_System */ victoryMe(): rm.types.AudioFile; /** * Sets the victory musical effect. * * @param {AudioFile} value * @memberof Game_System */ setVictoryMe(value: rm.types.AudioFile): void; /** * Returns the defeat musical effect. * * @returns {AudioFile} * @memberof Game_System */ defeatMe(): rm.types.AudioFile; onBattleStart(): void; onBattleWin(): void; onBattleEscape(): void; onBeforeSave(): void; onAfterLoad(): void; /** * Returns the total play time. * * @returns {number} * @memberof Game_System */ playtime(): number; playtimeText(): string; /** * Saves background music to the game system object. * * @memberof Game_System */ saveBgm(): void; /** * Replays the saved background music. * * @memberof Game_System */ replayBgm(): void; /** * Saves the walking background music. * * @memberof Game_System */ saveWalkingBgm(): void; /** * Replays the saved walking background music. * * @memberof Game_System */ replayWalkingBgm(): void; /** * Saves the second walking bgm from the map data. * * @memberof Game_System */ saveWalkingBgm2(): void; /** * Returns the main font face * * @returns {String} * @memberof Game_System */ mainFontFace(): string; /** * Returns the font face for number * * @returns {String} * @memberof Game_System */ numberFontFace(): string; /** * Returns the main font size * * @returns {Int} * @memberof Game_System */ mainFontSize(): number; /** * Returns the window padding * * @returns {Int} * @memberof Game_System */ windowPadding(): number; } /** * The game object class for temporary data that is not * included in the save data. * @class Game_Temp */ declare class Game_Temp { constructor(); _isPlaytest: boolean; _commonEventId: number; _destinationX: number; _destinationY: number; initialize(): void; /** * Determines if the game is in Play Test mode. * * @returns {boolean} * @memberof Game_Temp */ isPlaytest(): boolean; /** * Reserves the given commonEventId to be processed later. * * @param {number} commonEventId * @memberof Game_Temp */ reserveCommonEvent(commonEventId: number): void; /** * Clears the current reserved common event. * * @memberof Game_Temp */ clearCommonEvent(): void; /** * Returns true if a common event has been reserved. * * @returns {boolean} * @memberof Game_Temp */ isCommonEventReserved(): boolean; /** * Returns common event data from the database. * * @returns {any} * @memberof Game_Temp */ reservedCommonEvent(): any; /** * Sets the destination of the player for movement. * * @param {number} x * @param {number} y * @memberof Game_Temp */ setDestination(x: number, y: number): void; /** * Clears the destination of movement for the player. * * @memberof Game_Temp */ clearDestination(): void; /** * Determines if the destination for the player to move to is valid. * * @returns {boolean} * @memberof Game_Temp */ isDestinationValid(): boolean; /** * Returns the x coordinate of the destination. * * @returns {number} * @memberof Game_Temp */ destinationX(): number; /** * Returns the y coordinate of the destination. * * @returns {number} * @memberof Game_Temp */ destinationY(): number; } /** * The game object class for the timer. * * @class Game_Timer */ declare class Game_Timer { constructor(); _frames: number; _working: boolean; initialize(): void; /** * Updates the game timer. * * @param {boolean} sceneActive * @memberof Game_Timer */ update(sceneActive: boolean): void; /** * Starts the timer with the specified number of frames as count. * * @param {number} count * @memberof Game_Timer */ start(count: number): void; /** * Stops the timer. * * @memberof Game_Timer */ stop(): void; /** * Returns true if the timer is working and counting down. * * @returns {boolean} * @memberof Game_Timer */ isWorking(): void; /** * Returns the number of seconds on the timer. * * @returns {number} * @memberof Game_Timer */ seconds(): number; /** * Handler for when the time expires on the timer. * * @memberof Game_Timer */ onExpire(): void; } declare namespace rm.types { export type TroopMember = { /** * The enemy ID. */ enemyId: number; /** * The truth value of the [Appear Halfway] option. */ hidden: boolean; /** * The troop member's x-coordinate. */ x: number; /** * The troop member's y-coordinate. */ y: number; } } declare namespace rm.types { /** * The data class of battle event [Conditions]. */ export type PageCondition = { /** * The HP percentage specified in the [Actor] condition. */ actorHp: number; /** * The actor ID specified in the [Actor] condition. */ actorId: number; /** * The truth value indicating whether the [Actor] condition is valid. */ actorValid: boolean; /** * The HP percentage specified in the [Enemy] condition. */ enemyHp: number; /** * The troop member index specified in the [Enemy] condition (0..7). */ enemyIndex: number; /** * The truth value indicating whether the [Enemy] condition is valid. */ enemyValid: boolean; /** * The switch ID specified in the [Switch] condition. */ switchId: number; /** * The truth value indicating whether the [Switch] condition is valid. */ switchValid: boolean; /** * The a and b values specified in the [Turn No.] condition. To be input in the form A + B * X. */ turnA: number; /** * The a and b values specified in the [Turn No.] condition. To be input in the form A + B * X. */ turnB: number; /** * The truth value indicating whether the [At End of Turn] condition is valid. */ turnEnding: boolean; /** * The truth value indicating whether the [Turn No.] condition is valid. */ turnValid: boolean; } } declare namespace rm.types { /** * The data class for battle events (pages). */ export type Page = { /** * Condition (RPG.Troop.Page.Condition). */ condition: rm.types.PageCondition; /** * Program contents. An RPG.EventCommand array. */ list: rm.types.EventCommand[]; /** * Span (0: battle, 1: turn, 2: moment). */ span: number; } } declare namespace rm.types { export type Troop = { /** * The troop ID. */ id: number; /** * The troop members. An RPG.Troop.Member array. */ members: rm.types.TroopMember[]; /** * The troop name. */ name: string; /** * The battle events. An RPG.Troop.Page array. */ pages: rm.types.Page[]; } } /** * ----------------------------------------------------------------------------- * Game_Troop * * The game object declare class for a troop and the battle-related data. * @class Game_Troop */ declare class Game_Temp extends Game_Unit { constructor(); _interpreter: Game_Interpreter; _troopId: number; /** * Returns all enemies in the battle. * * @returns {Array} * @memberof Game_Troop */ members(): Game_Enemy[]; /** * Returns all alive enemies. * * @returns {Array} * @memberof Game_Troop */ aliveMembers(): Game_Enemy[]; /** * Returns all dead enemies. * * @returns {Array} * @memberof Game_Troop */ deadMembers(): Game_Enemy[]; /** * Returns movable enemies. * * @returns {Array} * @memberof Game_Troop */ movableMembers(): Game_Enemy[]; /** * Returns true if event is running. * * @returns {boolean} * @memberof Game_Troop */ isEventRunning(): boolean; /** * Updates the game interpreter. * * @memberof Game_Troop */ updateInterpreter(): void; /** * Returns the turn count. * * @returns {number} * @memberof Game_Troop */ turnCount(): number; clear(): void; /** * Returns troop information from the database. * * @returns {RPG.Troop} * @memberof Game_Troop */ troop(): rm.types.Troop; setup(troopId: number): void; /** * Creates unique names for each enemy. * * @memberof Game_Troop */ makeUniqueNames(): void; /** * Returns the letter table for enemy troops. * * @returns {Array} * @memberof Game_Troop */ letterTable(): string[]; /** * Returns the name of enemies within the troop. * * @returns {Array} * @memberof Game_Troop */ enemyNames(): string[]; meetsConditions(page: rm.types.EventPage): boolean; setupBattleEvent(): void; /** * Increases the turn number. * * @memberof Game_Troop */ increaseTurn(): void; /** * Returns the total exp of all members of the enemy troop. * * @returns {number} * @memberof Game_Troop */ expTotal(): number; /** * Return the total gold of all enemies. * * @returns {number} * @memberof Game_Troop */ goldTotal(): number; /** * Returns the gold rate based on game party gold rate. * * @returns {number} * @memberof Game_Troop */ goldRate(): number; /** * Creates the drop items for all members of the enemy troop, and * returns the item information. * @returns {Array} * @memberof Game_Troop */ makeDropItems(): rm.types.BaseItem[]; static LETTER_TABLE_HALF: string[]; static LETTER_TABLE_FULL: string[]; } /** * The game object class for game variables. */ declare class Game_Variables { constructor(); _data: number[]; initialize(): void; clear(): void; value(variableId: number): number; setValue(variableId: number, value: number): void; onChange(): void; } declare namespace rm.types { /** * The data class for vehicles. */ export type SystemVehicle = { /** * The vehicle's BGM (RPG.AudioFile). */ bgm: rm.types.AudioFile; /** * The index of the vehicle's walking graphic (0..7). */ characterIndex: number; /** * The file name of the vehicle's walking graphic. */ characterName: string; /** * The map ID of the vehicle's initial position. */ startMapId: number; /** * The map's x-coordinate of the vehicle's initial position. */ startX: number; /** * The map's y-coordinate of the vehicle's initial position. */ startY: number; } } /** * The game object class for a vehicle. */ declare class Game_Vehicle extends Game_Character { constructor(type: string); _type: string; _mapId: number; _altitude: number; _driving: boolean; _bgm: rm.types.AudioFile; initMembers(): void; /** * Returns true if the vehicle is a boat. * * @returns {Bool} * @memberof Game_Vehicle */ isBoat(): boolean; /** * Returns true if the vehicle is a ship. * * @returns {Bool} * @memberof Game_Vehicle */ isShip(): boolean; /** * Returns true if the vehicle is an airship. * * @returns {Bool} * @memberof Game_Vehicle */ isAirship(): boolean; /** * Resets the direction of the vehicle. * * @memberof Game_Vehicle */ resetDirection(): void; initMoveSpeed(): void; /** * Returns the current vehicle. * * @returns {RPG.System.Vehicle} * @memberof Game_Vehicle */ vehicle(): rm.types.SystemVehicle; loadSystemSettings(): void; /** * Refreshes the game vehicle. * * @memberof Game_Vehicle */ refresh(): void; setLocation(mapId: number, x: number, y: number): void; pos(x: number, y: number): boolean; isMapPassable(x: number, y: number, d: rm.types.Direction): boolean; /** * Gets on the vehicle. * * @memberof Game_Vehicle */ getOn(): void; /** * Gets off the vehicle. * * @memberof Game_Vehicle */ getOff(): void; /** * Sets the bgm associated with the vehicle. * * @param {RPG.AudioFile} bgm * @memberof Game_Vehicle */ setBgm(bgm: rm.types.AudioFile): void; /** * Plays the bgm associated with the vehicle. * * @memberof Game_Vehicle */ playBgm(): void; /** * Syncs the vehicle with the player. * * @memberof Game_Vehicle */ syncWithPlayer(): void; /** * Returns the screen y position of the vehicle. * * @returns {number} * @memberof Game_Vehicle */ screenY(): number; /** * Returns the shadow x position of the vehicle's shadow. * * @returns {number} * @memberof Game_Vehicle */ shadowX(): number; /** * Returns the shadow y position of the vehicle's shadow. * * @returns {number} * @memberof Game_Vehicle */ shadowY(): number; /** * Returns the shadow opacity of the vehicle's shadow. * * @returns {number} * @memberof Game_Vehicle */ shadowOpacity(): number; /** * Returns true if the vehicle can move. * * @returns {Bool} * @memberof Game_Vehicle */ canMove(): boolean; /** * Updates the vehicle. * * @memberof Game_Vehicle */ update(): void; /** * Updates the airship. * * @memberof Game_Vehicle */ updateAirship(): void; /** * Updates airship altitude. * * @memberof Game_Vehicle */ updateAirshipAltitude(): void; /** * Returns the max altitude of the vehicle. * * @returns {number} * @memberof Game_Vehicle */ maxAltitude(): number; /** * Returns true if the vehicle is at it's lowest altitude. * * @returns {Bool} * @memberof Game_Vehicle */ isLowest(): boolean; /** * Returns true if the vehicle is at it's highest altitude. * * @returns {Bool} * @memberof Game_Vehicle */ isHighest(): boolean; /** * Returns true if take off is ok. * * @returns {Bool} * @memberof Game_Vehicle */ isTakeoffOk(): boolean; /** * Returns true if the vehicle is capable of landing at the specified * x, y coordinate, with the specified direction (d). * @param {number} x * @param {number} y * @param {number} d * @returns {Bool} * @memberof Game_Vehicle */ isLandOk(x: number, y: number, d: rm.types.Direction): boolean; } declare class Scene_Base extends Stage { constructor(); _windowLayer: WindowLayer; /** * Initializes the scene. * @return Void */ initialize(): void; /** * Creates the scene's important properties. */ create(): void; /** * Returns whether the scene is active or not. * @return Bool */ isActive(): boolean; /** * Returns if the scene is ready or not. * @return Bool */ isReady(): boolean; /** * Starts the scene. */ start(): void; /** * Updates the scene. */ update(): void; /** * Stops the scene. */ stop(): void; /** * Checks if the Scene is busy processing an event * or other conditions. * @return Bool */ isBusy(): boolean; /** * Terminates/ends the scene. */ terminate(): void; /** * Creates the window layer on the current scene * for displaying any and all windows. */ createWindowLayer(): void; /** * Adds a child window to the window layer for processing. * @param window */ addWindow(window: Window_Base): void; /** * Request a fadeIn screen process * @param duration [duration=30] The time the process will take to fadeIn the screen. * @param white [white=false] If true the fadeIn will process with a white color else it will be black. */ startFadeIn(duration: number, white: boolean): void; /** * Request a fadeOut screen process * @param duration [duration=30] The time the process will take to fadeOut the screen. * @param white [white=false] If true the fadeOut will process with a white color else it will be black. */ startFadeOut(duration: number, white: boolean): void; createFadeSprite(white: boolean): void; /** * Updates the scene's fade */ updateFade(): void; updateChildren(): void; /** * Pops the current scene and returns to the previous scene if available. */ popScene(): void; /** * Checks for game over. */ checkGameOver(): void; fadeOutAll(): void; /** * Returns the fade speed. * @return Int */ fadeSpeed(): number; /** * Returns the slow fade speed. * @return Int */ slowFadeSpeed(): number; } /** * Scene class of the battle screen. */ declare class Scene_Battle extends Scene_Base { protected constructor(); updateBattleProcess(): void; isAnyInputWindowActive(): boolean; changeInputWindow(): void; /** * Stops the battle scene. * * @memberof Scene_Battle */ stop(): void; /** * Returns true if the battle needs a slow fade out. * * @returns {boolean} * @memberof Scene_Battle */ needsSlowFadeOut(): boolean; /** * Updates the status window on the battle scene. * * @memberof Scene_Battle */ updateStatusWindow(): void; /** * Updates the position of the battle scene windows. * * @memberof Scene_Battle */ updateWindowPositions(): void; /** * Creates all the display objects including: * the spritesheet, window layer, windows, and more. * * @memberof Scene_Battle */ createDisplayObjects(): void; /** * Creates the spriteset within * the battle scene. This includes * sprites for actors, enemies, etc. * @memberof Scene_Battle */ createSpriteset(): void; /** * Creates all the windows within the * battle scene. * @memberof Scene_Battle */ createAllWindows(): void; /** * Creates the log window. * * @memberof Scene_Battle */ createLogWindow(): void; createStatusWindow(): void; createPartyCommandWindow(): void; /** * Creates the actor command window. * * @memberof Scene_Battle */ createActorCommandWindow(): void; /** * Creates the help window. * * @memberof Scene_Battle */ createHelpWindow(): void; /** * Creates the skill window. * * @memberof Scene_Battle */ createSkillWindow(): void; /** * Creates the item window. * * @memberof Scene_Battle */ createItemWindow(): void; /** * Creates the actor window. * * @memberof Scene_Battle */ createActorWindow(): void; /** * Creates the enemy window. * * @memberof Scene_Battle */ createEnemyWindow(): void; /** * Creates the message window on the battle scene. * * @memberof Scene_Battle */ createMessageWindow(): void; /** * Creates the scroll text window. * * @memberof Scene_Battle */ createScrollTextWindow(): void; refreshStatus(): void; startPartyCommandSelection(): void; /** * Handler for the fight command on battle start.. * * @memberof Scene_Battle */ commandFight(): void; /** * Handler for the escape command on battle start. * * @memberof Scene_Battle */ commandEscape(): void; startActorCommandSelection(): void; /** * Handler for the attack command. * * @memberof Scene_Battle */ commandAttack(): void; /** * * Handler for the skill command. * * @memberof Scene_Battle */ commandSkill(): void; /** * Handler for the guard command. * * @memberof Scene_Battle */ commandGuard(): void; /** * Handler for the item command. * * @memberof Scene_Battle */ commandItem(): void; /** * Selects the next command in the battle scene. * * @memberof Scene_Battle */ selectNextCommand(): void; /** * Selects the previous command in the battle scene. * * @memberof Scene_Battle */ selectPreviousCommand(): void; selectActorSelection(): void; onActorOk(): void; onActorCancel(): void; selectEnemySelection(): void; /** * Handler for when an enemy is selected. * * @memberof Scene_Battle */ onEnemyOk(): void; onEnemyCancel(): void; /** * Handler for when a skill is selected. * * @memberof Scene_Battle */ onSkillOk(): void; onSkillCancel(): void; onItemOk(): void; onItemCancel(): void; onSelectAction(): void; endCommandSelection(): void; } declare class Scene_Boot extends Scene_Base { protected constructor(); _databaseLoaded: boolean; /** * Loads the system images upon booting the game. */ loadSystemImages(): void; /** * Loads the system window image for showing all windows in game. */ loadSystemWindowImage(): void; /** * Returns true if the game font is loaded. * @return Bool */ isGameFontLoaded(): boolean; updateDocumentTitle(): void; /** * Checks the player location upon booting the game. */ checkPlayerLocation(): void; } /** * The super class of all menu-type scenes */ declare class Scene_MenuBase extends Scene_Base { protected constructor(); /** * Returns the current game actor. * * @returns {Game_Actor} * @memberof Scene_MenuBase */ actor(): Game_Actor; /** * Updates the current actor. * * @memberof Scene_MenuBase */ updateActor(): void; /** * Creates the background of the base menu scene. * * @memberof Scene_MenuBase */ createBackground(): void; /** * Sets the background opacity of the base menu scene background. * * @param {number} opacity * @memberof Scene_MenuBase */ setBackgroundOpacity(opacity: number): void; /** * Creates the help window. * * @memberof Scene_MenuBase */ createHelpWindow(): void; /** * Moves to the next actor in the party. * * @memberof Scene_MenuBase */ nextActor(): void; /** * Moves to the previous actor in the party. * * @memberof Scene_MenuBase */ previousActor(): void; onActorChange(): void; } /** * Scene class of the debug menu screen. */ declare class Scene_Debug extends Scene_MenuBase { protected constructor(); /** * Creates the range window. * * @memberof Scene_Debug */ createRangeWindow(): void; /** * Creates the edit window. * * @memberof Scene_Debug */ createEditWindow(): void; /** * Creates the debug help .window. * * @memberof Scene_Debug */ createDebugHelpWindow(): void; onRangeOk(): void; onEditCancel(): void; refreshHelpWindow(): void; /** * Returns the help text within the * debug scene. * @returns {String} * @memberof Scene_Debug */ helpText(): string; } /** * Scene class of the equipment screen. */ declare class Scene_Equip extends Scene_MenuBase { protected constructor(); /** * Creates the status window within the equip scene. * * @memberof Scene_Equip */ createStatusWindow(): void; /** * Creates the status window within the equip scene. * * @memberof Scene_Equip */ createCommandWindow(): void; /** * Creates the slot window within the equip scene. * * @memberof Scene_Equip */ createSlotWindow(): void; /** * Creates the item window within the equip scene. * * @memberof Scene_Equip */ createItemWindow(): void; /** * Refreshes the actor within the equip scene. * * @memberof Scene_Equip */ refreshActor(): void; /** * Handler for the equip command. * * @memberof Scene_Equip */ commandEquip(): void; /** * Handler for the optimize command. * * @memberof Scene_Equip */ commandOptimize(): void; commandClear(): void; onSlotOk(): void; onSlotCancel(): void; onItemOk(): void; onItemCancel(): void; onActorChange(): void; } /** * Super class of Scene_Save and Scene_Load */ declare class Scene_File extends Scene_MenuBase { protected constructor(); /** * Returns the index of the first * save file. * @returns {number} * @memberof Scene_File */ firstSavefileIndex(): number; /** * Returns the current savefileId. * * @memberof Scene_File */ savefileId(): number; createHelpWindow(): void; createListWindow(): void; /** * The current mode of the scene; * the modes are 'save' or 'load'. * @memberof Scene_File */ mode(): void; activateListWindow(): void; helpWindowText(): string; /** * Handler for when a * save file is selected within the file scene. * @memberof Scene_File */ onSavefileOk(): void; } /** * Scene class of the game end screen. */ declare class Scene_GameEnd extends Scene_MenuBase { protected constructor(); stop(): void; /** * Creates the background for * the game end scene. * @memberof Scene_GameEnd */ createBackground(): void; /** * Creates the command window * for the game end screen. * @memberof Scene_GameEnd */ createCommandWindow(): void; /** * Handler for when to title * is clicked within the game end screen. * @memberof Scene_GameEnd */ commandToTitle(): void; } /** * Scene class of the game over screen. */ declare class Scene_Gameover extends Scene_Base { protected constructor(); stop(): void; /** * Plays the game over music * within the game over scene. * @memberof Scene_Gameover */ playGameoverMusic(): void; /** * Creates the background of * the game over scene. * @memberof Scene_Gameover */ createBackground(): void; isTriggered(): boolean; /** * Returns to the title scene (Scene_Title). * @memberof Scene_Gameover */ gotoTitle(): void; } /** * Super class of all public function item(skill, items, etc) screen scenes. * Super class of Scene_Item & Scene_Skill. */ declare class Scene_ItemBase extends Scene_Base { protected constructor(); /** * Creates the actor window within the base item scene. * * @memberof Scene_ItemBase */ createActorWindow(): void; /** * Returns the item attached to the item window within the base item scene. * * @returns {*} * @memberof Scene_ItemBase */ item(): any; /** * Returns the current game actor. * * @returns {Game_Actor} * @memberof Scene_ItemBase */ user(): Game_Actor; /** * Returns true if the cursor is left. * * @returns {boolean} * @memberof Scene_ItemBase */ isCursorLeft(): boolean; /** * Shows the sub window. * * @param {Window_Base} window * @memberof Scene_ItemBase */ showSubWindow(window: Window_Base): void; /** * Hides the sub window. * * @param {Window_Base} window * @memberof Scene_ItemBase */ hideSubWindow(window: Window_Base): void; onActorOk(): void; onActorCancel(): void; determineItem(): void; /** * Uses the current item. * * @memberof Scene_ItemBase */ useItem(): void; /** * Activates the item window. * * @memberof Scene_ItemBase */ activateItemWindow(): void; itemTargetActors(): Game_Actor; /** * Returns true if the user (game actor) can use the item. * * @returns {boolean} * @memberof Scene_ItemBase */ canUse(): boolean; /** * Returns true if the item effects are valid on the public function target(the user). * * @returns {boolean} * @memberof Scene_ItemBase */ isItemEffectsValid(): boolean; applyItem(): void; /** * Checks the common event set on the item. * * @memberof Scene_ItemBase */ checkCommonEvent(): void; } /** * ----------------------------------------------------------------------------- * Scene_Item * * The scene class of the item screen. * @class Scene_Item * @extends {Scene_ItemBase} */ declare class Scene_Item extends Scene_ItemBase { protected constructor(); /** * Creates the category window on the * item scene. * @memberof Scene_Item */ createCategoryWindow(): void; /** * Creates the item window on the item * scene. * @memberof Scene_Item */ createItemWindow(): void; /** * Handler for when a cataegory is selected * on the item scene. * @memberof Scene_Item */ onCategoryOk(): void; /** * Handler for when an item is selected * on the item scene. * @memberof Scene_Item */ onItemOk(): void; /** * Handler for when an item selection * is canceled on the item scene. * @memberof Scene_Item */ onItemCancel(): void; /** * Plays a sound effect when the * item is confirmed. * @memberof Scene_Item */ playSeForItem(): void; } /** * The scene class of the load game screen. */ declare class Scene_Load extends Scene_File { protected constructor(); /** * Returns the mode of the * load scene. * @returns {string} * @memberof Scene_Load */ mode(): string; /** * Returns the help window text on the * game load scene. * @returns {string} * @memberof Scene_Load */ helpWindowText(): string; firstSavefileIndex(): number; onSavefileOk(): void; onLoadSuccess(): void; onLoadFailure(): void; reloadMapIfUpdated(): void; } /** * The scene class for the map screen. */ declare class Scene_Map extends Scene_Base { protected constructor(); menuCalling: boolean; /** * Handler for when the map scene is loaded. * * @memberof Scene_Map */ onMapLoaded(): void; /** * Speeds up the updateMain if * the map scene is in fast forward mode. * @memberof Scene_Map */ updateMainMultiply(): void; /** * Updates the main $game globals * if the map scene is active. * @memberof Scene_Map */ updateMain(): void; /** * Returns true if the player * is holding down the confirm button to * fast forward through text. * @returns {boolean} * @memberof Scene_Map */ isFastForward(): boolean; /** * Stops the map scene and prepares * for a new scene. * @memberof Scene_Map */ stop(): void; /** * Returns true if the map scene needs a slow fade in. * * @returns {boolean} * @memberof Scene_Map */ needsFadeIn(): boolean; /** * Returns true if the map scene needs a slow fade out. * * @returns {boolean} * @memberof Scene_Map */ needsSlowFadeOut(): boolean; updateWaitCount(): boolean; /** * Constantly checks if the player * is touching the map, then processes * a map touch for mouse based player character movement. * @memberof Scene_Map */ updateDestination(): void; /** * Returns true if the map scene is * active and the player can move. Used for * mouse movement on the map scene. * @returns {boolean} * @memberof Scene_Map */ isMapTouchOk(): boolean; /** * Processes the map touch and turns it * into coordinates for the player character to move to. * @memberof Scene_Map */ processMapTouch(): void; isSceneChangeOk(): boolean; /** * Updates the scene. * * @memberof Scene_Map */ updateScene(): void; /** * Creates all the display objects on the map scene; * this includes the sprites, window layer, windows, and more. * @memberof Scene_Map */ createDisplayObjects(): void; /** * Creates the spriteset on the map scene; * this shows all the characters and events on the map. * @memberof Scene_Map */ createSpriteset(): void; /** * Creates all the windows on the map scene * contains other window creation methods. * @memberof Scene_Map */ createAllWindows(): void; /** * Creates the map name window within * the map scene; display map name. * @memberof Scene_Map */ createMapNameWindow(): void; /** * Creates the message window for displaying * text on the map scene. Commonly used with the * showText command. * @memberof Scene_Map */ createMessageWindow(): void; /** * Creates a scrolling text window on the map scene. * * @memberof Scene_Map */ createScrollTextWindow(): void; /** * Checks if the player is transferring; * if the player is transferring, move to a new map scene. * @memberof Scene_Map */ updateTransferPlayer(): void; /** * Processes starting an encounter on the map scene. * * @memberof Scene_Map */ updateEncounter(): void; /** * Processes calling the menu on the map scene. * * @memberof Scene_Map */ updateCallMenu(): void; /** * Returns true if the menu is enabled * in the database. * @returns {boolean} * @memberof Scene_Map */ isMenuEnabled(): boolean; /** * Returns true if the menu is called * via an input trigger. * @returns {boolean} * @memberof Scene_Map */ isMenuCalled(): boolean; /** * Calls the standard RPGMakerMV menu scene. * * @memberof Scene_Map */ callMenu(): void; /** * Checks if debug is called via input trigger * and starts the debug scene. * * @memberof Scene_Map */ updateCallDebug(): void; /** * Returns true if the debug * scene is called via button press and in play test mode. * @returns {boolean} * @memberof Scene_Map */ isDebugCalled(): void; fadeInForTransfer(): void; fadeOutForTransfer(): void; /** * Launches into the battle scene. * * @memberof Scene_Map */ launchBattle(): void; /** * Stops all audio on battle start. * * @memberof Scene_Map */ stopAudioOnBattleStart(): void; /** * Starts the encounter effect on the map scene. * * @memberof Scene_Map */ startEncounterEffect(): void; updateEncounterEffect(): void; /** * Takes a snapshot of the map scene for displaying * on the battle scene if no battleback is present. * @memberof Scene_Map */ snapForBattleBackground(): void; /** * Starts a flash encounter effect on the map scene * given a duration of the flash. * @param {number} duration * @memberof Scene_Map */ startFlashForEncounter(duration: number): void; /** * Returns the speed of the encounter effect. * * @returns {number} * @memberof Scene_Map */ encounterEffectSpeed(): number; } /** * The menu scene in your RPGMakerMV game. */ declare class Scene_Menu extends Scene_MenuBase { protected constructor(); /** * Creates the main menu window on the * menu scene; contains the commands for * menu usage. * @memberof Scene_Menu */ createCommandWindow(): void; /** * Creates the gold window on the menu scene. * * @memberof Scene_Menu */ createGoldWindow(): void; /** * Creates the status window on the menu scene. * * @memberof Scene_Menu */ createStatusWindow(): void; /** * Handler for what to do when the 'item' * command is clicked. * @memberof Scene_Menu */ commandItem(): void; commandPersonal(): void; commandFormation(): void; /** * Handler for what to do when the 'option' * command is clicked. * @memberof Scene_Menu */ commandOptions(): void; /** * Handler for what to do when the 'save' * command is clicked. * @memberof Scene_Menu */ commandSave(): void; /** * Handler for what to do when the 'game end' * command is clicked. * @memberof Scene_Menu */ commandGameEnd(): void; onPersonalOk(): void; onPersonalCancel(): void; onFormationOk(): void; onFormationCancel(): void; } /** * Scene class of the name input screen. */ declare class Scene_Name extends Scene_MenuBase { protected constructor(); /** * Prepares the name input scene for giving the specified * actor at actorId a name with a maximum number of characters * given by maxLength. * @param {number} actorId * @param {number} maxLength * @memberof Scene_Name */ prepare(actorId: number, maxLength: number): void; /** * Creates the edit window. * * @memberof Scene_Name */ createEditWindow(): void; /** * Creates the input window. * * @memberof Scene_Name */ createInputWindow(): void; /** * Handler for when ok is processed on the name input scene. * * @memberof Scene_Name */ onInputOk(): void; } /** * Scene class of the options screen. */ declare class Scene_Options extends Scene_MenuBase { protected constructor(); createOptionsWindow(): void; } /** * Save game screen scene for RPGMakerMV. */ declare class Scene_Save extends Scene_File { protected constructor(); /** * Returns the mode of the * save scene. * @returns {string} * @memberof Scene_Save */ mode(): string; helpWindowText(): string; /** * Returns the index of the first * save file within the save scene. * @returns {number} * @memberof Scene_Save */ firstSavefileIndex(): number; /** * Handler for when a save file * is confirmed within the save scene. * @memberof Scene_Save */ onSavefileOk(): void; /** * Handler for when save is a success. * * @memberof Scene_Save */ onSaveSuccess(): void; /** * Handler for when save fails. * * @memberof Scene_Save */ onSaveFailure(): void; } declare namespace rm.types { export const enum Money { base = -1, } } /** * Scene class of the shop screen. */ declare class Scene_Shop extends Scene_MenuBase { protected constructor(); prepare(goods: any[][], purchaseOnly: boolean): void; /** * Creates the gold window on the shop scene. * * @memberof Scene_Shop */ createGoldWindow(): void; /** * Creates the command window for buying or selling. * * @memberof Scene_Shop */ createCommandWindow(): void; createDummyWindow(): void; /** * Creates the number input window on the shop scene. * * @memberof Scene_Shop */ createNumberWindow(): void; /** * Creates the status window. * * @memberof Scene_Shop */ createStatusWindow(): void; /** * Creates the buy window. * * @memberof Scene_Shop */ createBuyWindow(): void; /** * Creates the category window. * * @memberof Scene_Shop */ createCategoryWindow(): void; /** * Creates the sell window. * * @memberof Scene_Shop */ createSellWindow(): void; /** * Activates the buy window within the shop scene. * * @memberof Scene_Shop */ activateBuyWindow(): void; /** * Activates the sell window within the shop scene. * * @memberof Scene_Shop */ activateSellWindow(): void; /** * Handler for pressing buy within the shop scene. * * @memberof Scene_Shop */ commandBuy(): void; /** * Handler for pressing sell within the shop scene. * * @memberof Scene_Shop */ commandSell(): void; /** * Handler for when buying is confirmed. * * @memberof Scene_Shop */ onBuyOk(): void; /** * Handler for when buying is cancelled. * * @memberof Scene_Shop */ onBuyCancel(): void; onCategoryOk(): void; onCategoryCancel(): void; onSellOk(): void; onSellCancel(): void; onNumberOk(): void; onNumberCancel(): void; /** * Amount of item to buy. * @param number */ doBuy(number: number): void; /** * Amount of item to sell. * @param number */ doSell(number: number): void; endNumberInput(): void; /** * Returns the maximum number bought. * * @returns {number} * @memberof Scene_Shop */ maxBuy(): number; /** * Returns the maximum number sold. * * @returns {number} * @memberof Scene_Shop */ maxSell(): number; /** * Returns the player gold within * the shop scene. * @returns {number} * @memberof Scene_Shop */ money(): rm.types.Money; /** * Returns the currency unit of the * game within the shop scene. * @returns {string} * @memberof Scene_Shop */ currencyUnit(): string; /** * Returns the buying price for the current item. * * @returns {number} * @memberof Scene_Shop */ buyingPrice(): rm.types.Money; /** * Returns the selling price for the current item. * * @returns {number} * @memberof Scene_Shop */ sellingPrice(): rm.types.Money; } /** * The scene class of the skill screen. */ declare class Scene_Skill extends Scene_ItemBase { protected constructor(); /** * Creates the window for skill types * within the skill scene. * @memberof Scene_Skill */ createSkillTypeWindow(): void; /** * Creates the status window within * the skill scene. * @memberof Scene_Skill */ createStatusWindow(): void; /** * Creates the item window * within the skill scene. * @memberof Scene_Skill */ createItemWindow(): void; /** * Refreshes the current actor displayed in the Skill * window with updated information on changes. */ refreshActor(): void; /** * Handler for when a skill is * selected/confirmed within the skill scene. * @memberof Scene_Skill */ commandSkill(): void; /** * Function to run when selection is cancelled * on the skill scene. */ onItemCancel(): void; /** * Plays a sound effect on item * confirmation withiin the skill scene. * @memberof Scene_Skill */ playSeForItem(): void; /** * Handler for when an an actor is * changed within the skill scene. * @memberof Scene_Skill */ onActorChange(): void; } /** * Scene class of the status screen in RPGMakerMV. */ declare class Scene_Status extends Scene_MenuBase { protected constructor(); /** * Refreshes the actor within the status scene. * * @memberof Scene_Status */ refreshActor(): void; /** * Handler for when the actor is changed within the status scene. * * @memberof Scene_Status */ onActorChange(): void; } declare class Scene_Title extends Scene_Base { protected constructor(); /** * The command window for title scene commands like new game, continue, or options. */ _commandWindow: Window_TitleCommand; /** * The background sprite which loads the $dataSystem.title1Name image. */ _backSprite1: Sprite; /** * The background sprite which loads the $dataSystem.title2Name image. */ _backSprite2: Sprite; /** * The sprite which holds the game title text. */ _gameTitleSprite: Sprite; /** * Creates the title scene background. */ createBackground(): void; /** * Creates the title screen foreground. */ createForeground(): void; /** * Draws the game title. */ drawGameTitle(): void; /** * Scales the background images and centers it. */ adjustBackground(): void; /** * Creates the command window and sets it's handlers. */ createCommandWindow(): void; commandWindowRect(): Rectangle; centerSprite(sprite: Sprite): void; /** * Handler for the new game command. */ commandNewGame(): void; /** * Handler for the continue command. */ commandContinue(): void; /** * Handler for the options command. */ commandOptions(): void; /** * Plays the title screen music upon entering the scene. */ playTitleMusic(): void; } declare namespace rm.types { /** * The data class for the timing of an animation's SE and flash effects. */ export type AnimationTiming = { /** * The color of the flash (Color). */ flashColor: number[]; /** * The duration of the flash. */ flashDuration: number; /** * The flash area (0: none, 1: target, 2: screen; 3: hide target). */ flashScope: number; /** * The frame number. 1 less than the number displayed in RPG Maker. */ frame: number; /** * The sound effect or SE (RPG.AudioFile). */ se: rm.types.AudioFile; } } declare namespace rm.types { /** * The data class for animation. */ export type Animation = { /** * The adjustment value for the hue of the first animation's graphic (0..360). */ animation1Hue: string; /** * The file name of the first animation's graphic. */ animation1Name: string; /** * The adjustment value for the hue of the second animation's graphic (0..360). */ animation2Hue: number; /** * The file name of the second animation's graphic. */ animation2Name: string; /** * Number of frames. */ frameMax: number; /** * The three-dimensional array containing the frame contents. */ frames: number[][][]; /** * The animation ID. */ id: number; /** * The animation name. */ name: string; /** * The base position (0: head, 1: center, 2: feet, 3: screen). */ position: number; /** * Timing for SE and flash effects. An RPG.Animation.Timing array. */ timings: rm.types.AnimationTiming[]; } } declare class Sprite_Base extends Sprite { constructor(); /** * The animation sprites assigned to the * sprite object. * @protected * @type {Array} * @memberof Sprite_Base */ _animationSprites: Sprite_Animation[]; /** * The target that will have the animations applied * to it. * @protected * @type {Sprite_Base} * @memberof Sprite_Base */ _effectTarget: Sprite_Base; /** * Determines sprite's visibility */ _hiding: boolean; /** * Initializes the sprite. * * @memberof Sprite_Base */ initialize(): void; /** * Hides the sprite. */ hide(): void; /** * Shows the sprite. */ show(): void; /** * Updadtes the visibility of the sprite based * on the _hiding property. * @memberof Sprite_Base */ updateVisibility(): void; /** * Updates the animation sprites, cloning them; * if the sprite is playing, pushes the sprites into * animation sprites, otherwise the sprite is removed. * @memberof Sprite_Base */ updateAnimationSprites(): void; /** * Starts a new animation on the current * sprite by assigning a new Sprite_Animation object to the * sprite's parent. * @param {RPG.Animation} animation * @param {boolean} mirror * @param {number} delay * @memberof Sprite_Base */ startAnimation(animation: rm.types.Animation, mirror: boolean, delay: number): void; /** * Returns true if an animation is currently playing. * @returns {boolean} * @memberof Sprite_Base */ isAnimationPlaying(): boolean; } declare class Sprite_Battler extends Sprite_Base { protected constructor(); _battler: Game_Battler; _homeX: number; _homeY: number; _offsetX: number; _offsetY: number; _targetOffsetX: number; _targetOffsetY: number; _movementDuration: number; _selectionEffectCount: number; initMembers(): void; setHome(x: number, y: number): void; /** * Updates the main loop of the sprite battler. */ updateMain(): void; /** * Updates the bitmap of the sprite battler. */ updateBitmap(): void; /** * Updates movement on the sprite battler. */ updateMove(): void; /** * Updates the position of the sprite battler. */ updatePosition(): void; /** * Updates the sprite battler animation. */ updateAnimation(): void; } declare namespace rm.types { export type Motion = { index: number; loop: boolean; } } /** * ----------------------------------------------------------------------------- * Sprite_Actor * * The sprite for displaying an actor. */ declare class Sprite_Actor extends Sprite_Battler { /** * Creates an instance of Sprite_Actor; can be passed * a battler on creation. * @param {Game_Actor} [battler] * @memberof Sprite_Actor */ constructor(battler?: Game_Actor); _battlerName: string; _motion: rm.types.Motion; _motionCount: number; _pattern: rm.types.CharacterPattern; _mainSprite: Sprite_Base; _shadowSprite: Sprite; _weaponSprite: Sprite_Weapon; _stateSprite: Sprite_StateOverlay; _actor: Game_Actor; initialize(battler?: Game_Actor): void; /** * Creates the main sprite of the sprite actor. * * @memberof Sprite_Actor */ createMainSprite(): void; /** * Creates the shadow sprite of the sprite actor. * * @memberof Sprite_Actor */ createShadowSprite(): void; /** * Sets the weapon sprite of the sprite actor. * * @memberof Sprite_Actor */ createWeaponSprite(): void; /** * Creates the state sprite of the sprite actor. * * @memberof Sprite_Actor */ createStateSprite(): void; /** * Sets the battler of the sprite actor. * * @param {Game_Actor} battler * @memberof Sprite_Actor */ setBattler(battler: Game_Actor): void; /** * Moves the sprite actor to the start position. * * @memberof Sprite_Actor */ moveToStartPosition(): void; setActorHome(index: number): void; updateShadow(): void; /** * Sets up motion on the sprite actor. * * @memberof Sprite_Actor */ setupMotion(): void; /** * Sets up weapon animation on the sprite actor. * * @memberof Sprite_Actor */ setupWeaponAnimation(): void; /** * Starts the motion given the specified motion * type. * @param {string} motionType * @memberof Sprite_Actor */ startMotion(motionType: string): void; updateTargetPosition(): void; /** * Updates the sprite actor's movement. * * @memberof Sprite_Actor */ updateMove(): void; /** * Updates the sprite actor's motion. * * @memberof Sprite_Actor */ updateMotion(): void; updateMotionCount(): void; /** * Returns the speed of the motion for the sprite actor. * * @returns {Int} * @memberof Sprite_Actor */ motionSpeed(): number; /** * Refreshes the motion of the sprite actor. * * @memberof Sprite_Actor */ refreshMotion(): void; /** * Starts the entry motion of the sprite actor. * * @memberof Sprite_Actor */ startEntryMotion(): void; /** * Has the sprite actor step forward. * * @memberof Sprite_Actor */ stepForward(): void; /** * Has the sprite actor step back. * * @memberof Sprite_Actor */ stepBack(): void; /** * Has the sprite actor retreat. * * @memberof Sprite_Actor */ retreat(): void; damageOffsetX(): number; damageOffsetY(): number; static MOTIONS: { abnormal: rm.types.Motion, chant: rm.types.Motion, damage: rm.types.Motion, dead: rm.types.Motion, dying: rm.types.Motion, escape: rm.types.Motion, evade: rm.types.Motion, guard: rm.types.Motion, item: rm.types.Motion, missile: rm.types.Motion, skill: rm.types.Motion, sleep: rm.types.Motion, spell: rm.types.Motion, swing: rm.types.Motion, thrust: rm.types.Motion, victory: rm.types.Motion, wait: rm.types.Motion, walk: rm.types.Motion }; } /** * ----------------------------------------------------------------------------- * Sprite_Animation * * The sprite for displaying an animation. */ declare class Sprite_Animation extends Sprite { protected constructor(); /** * { * key: Animation * }; */ _checker1: { [key: string]: any }; _target: Sprite_Base; _animation: rm.types.Animation; _mirror: boolean; _delay: number; _rate: number; _duration: number; _flashColor: number[]; _flashDuration: number; _screenFlashDuration: number; _hidingDuration: number; _bitmap1: Bitmap; _bitmap2: Bitmap; _cellSprites: Sprite[]; _screenFlashSprite: ScreenSprite; _duplicated: boolean; _reduceArtifacts: boolean; initMembers(): void; setup(target: Sprite_Base, animation: rm.types.Animation, mirror: boolean, delay: number): void; /** * Removes the sprite animation. * * @memberof Sprite_Animation */ remove(): void; setupRate(): void; setupDuration(): void; /** * Updates the flash animation of the sprite animation. * * @memberof Sprite_Animation */ updateFlash(): void; updateScreenFlash(): void; /** * Returns the absolute x position of the sprite animation. * * @returns {number} * @memberof Sprite_Animation */ absoluteX(): number; /** * Returns the absolute y position of the sprite aniamtion. * * @returns {number} * @memberof Sprite_Animation */ absoluteY(): number; /** * Updates the hiding of the sprite animation. * * @memberof Sprite_Animation */ updateHiding(): void; /** * Returns true if the sprite animation is playing. * * @returns {boolean} * @memberof Sprite_Animation */ isPlaying(): boolean; /** * Loads the bitmaps of the sprite animation. * * @memberof Sprite_Animation */ loadBitmaps(): void; /** * Returns true if the sprite animation is ready. * * @returns {boolean} * @memberof Sprite_Animation */ isReady(): boolean; /** * Create the sprites of the sprite animation. * * @memberof Sprite_Animation */ createSprites(): void; /** * Create the cell sprites of the sprite animation. * * @memberof Sprite_Animation */ createCellSprites(): void; /** * Create the screen flash sprite of the sprite animation. * * @memberof Sprite_Animation */ createScreenFlashSprite(): void; /** * Updates the main loop of the sprite animation. * * @memberof Sprite_Animation */ updateMain(): void; /** * Updates the position of the sprite animation. * * @memberof Sprite_Animation */ updatePosition(): void; /** * Updates the frame of the sprite aniamtion. * * @memberof Sprite_Animation */ updateFrame(): void; /** * Returns the current frame index of the sprite aniamtion. * * @returns {number} * @memberof Sprite_Animation */ currentFrameIndex(): number; updateAllCellSprites(frame: number[][]): void; updateCellSprite(sprite: Sprite, cell: number[]): void; processTimingData(timing: rm.types.AnimationTiming): void; startFlash(color: number[], duration: number): void; startScreenFlash(color: number[], duration: number): void; /** * Starts hiding the sprite animation. * * @param {number} duration The duration of the hide. * @memberof Sprite_Animation */ startHiding(duration: number): void; /** * Structure * { * key: Animation * }; */ static _checker2: { [key: string]: any }; } /** * ----------------------------------------------------------------------------- * Sprite_Balloon * * The sprite for displaying a balloon icon. */ declare class Sprite_Balloon extends Sprite_Base { protected constructor(); _balloonId: rm.types.BalloonId; _duration: number; initMembers(): void; loadBitmap(): void; setup(balloonId: rm.types.BalloonId): void; /** * Updates the balloon sprite. * * @memberof Sprite_Balloon */ update(): void; /** * Updates the balloon sprite frame. * * @memberof Sprite_Balloon */ updateFrame(): void; /** * Returns the speed of the balloon animation. * * @returns {number} * @memberof Sprite_Balloon */ speed(): number; /** * Returns the wait time. * * @returns {number} * @memberof Sprite_Balloon */ waitTime(): number; /** * Returns the frame index of the balloon animation. * * @returns {number} * @memberof Sprite_Balloon */ frameIndex(): number; /** * Returns true if the balloon animation is playing. * * @returns {boolean} * @memberof Sprite_Balloon */ isPlaying(): boolean; } /** * ----------------------------------------------------------------------------- * Sprite_Button * * The sprite for displaying a button. */ declare class Sprite_Button extends Sprite { protected constructor(); _touching: boolean; _coldFrame: Rectangle; _hotFrame: Rectangle; _clickHandler: () => void; /** * Update method, which checks if the sprite is being touched and updates * the current frame. * * @memberof Sprite_Button */ updateFrame(): void; /** * Set the button sprites cold frame. * * @param {Int} x * @param {Int} y * @param {Int} width * @param {Int} height * * @memberof Sprite_Button * */ setColdFrame(x: number, y: number, width: number, height: number): void; /** * Set the button sprites hot frame * * @param {Int} x * @param {Int} y * @param {Int} width * @param {Int} height * * @memberof Sprite_Button * */ setHotFrame(x: number, y: number, width: number, height: number): void; /** * Creates a new handler and binds it to the button. * * @param {function} height * @memberof Sprite_Button */ setClickHandler(method: () => void): void; /** * Calls the handler method bound to the button. * * @param {function} height * @memberof Sprite_Button */ callClickHandler(): void; /** * Processes weather or not the button is being touched and calls the handler * bound to the button. * @memberof Sprite_Button */ processTouch(): void; /** * Returns true if the sprite button is currently active. * @returns {Bool} * @memberof Sprite_Button */ isActive(): boolean; /** * Returns true is the button is presently being touched. * @returns {Bool} * @memberof Sprite_Button */ isButtonTouched(): boolean; /** * Changes the x coordinate of the screen to local sprite x coordinate. * @param {Int} x * @returns {Int} * @memberof Sprite_Button */ canvasToLocalX(x: number): number; /** * Changes the y coordinate of the screen * to local sprite y coordinate. * @param {Int} y * @returns {Int} * @memberof Sprite_Button */ canvasToLocalY(y: number): number; } /** * ----------------------------------------------------------------------------- * Sprite_Character * * The sprite for displaying a character. */ declare class Sprite_Character extends Sprite_Base { /** * Creates an instance of Sprite_Character. * @param {Game_Character} character * @memberof Sprite_Character */ constructor(character: Game_Character); /** * The Game_Character object assigned * to the sprite. * @private var * @type {Game_Character} * @memberof Sprite_Character */ _character: Game_Character; _balloonDuration: number; _tilesetId: number; _upperBody: Sprite; _lowerBody: Sprite; _bushDepth: number; /** * The current balloon sprite * assigned to the sprite. * @private var * @type {Sprite_Balloon} * @memberof Sprite_Character */ _balloonSprite: Sprite_Balloon; initialize(character: Game_Character): void; initMembers(): void; /** * Sets the current Game_Character object * attached to the sprite. * @param {Game_Character} character * @memberof Sprite_Character */ setCharacter(character: Game_Character): void; /** * Returns true if the Game_Character object * tileId is greater than 0. * @returns {Bool} * @memberof Sprite_Character */ isTile(): boolean; tilesetBitmap(tileId: number): Bitmap; /** * Updates the bitmap of the sprite character. * * @memberof Sprite_Character */ updateBitmap(): void; /** * Returns true if the sprite character image has changed. * * @returns {Bool} * @memberof Sprite_Character */ isImageChanged(): boolean; setTileBitmap(): void; /** * Sets the sprite character bitmap. * * @memberof Sprite_Character */ setCharacterBitmap(): void; /** * Updates the sprite character frame. * * @memberof Sprite_Character */ updateFrame(): void; /** * Updates the sprite character tile frame. * * @memberof Sprite_Character */ updateTileFrame(): void; /** * Updates the sprite character -- character frame. * * @memberof Sprite_Character */ updateCharacterFrame(): void; characterBlockX(): number; characterBlockY(): number; /** * Returns the character x pattern. * * @returns {number} * @memberof Sprite_Character */ characterPatternX(): rm.types.CharacterPattern; /** * Returns the character y pattern. * * @returns {number} * @memberof Sprite_Character */ characterPatternY(): rm.types.CharacterPattern; /** * Returns the pattern width. * * @returns {number} * @memberof Sprite_Character */ patternWidth(): number; /** * Returns the pattern height. * * @returns {number} * @memberof Sprite_Character */ patternHeight(): number; updateHalfBodySprites(): void; createHalfBodySprites(): void; /** * Updates the position of the sprite character. * * @memberof Sprite_Character */ updatePosition(): void; updateAnimation(): void; updateOther(): void; setupAnimation(): void; /** * Sets up the Game_Character object * balloon sprite, and calls the startBalloon method. * @memberof Sprite_Character */ setupBalloon(): void; /** * Starts the balloon sprite on the * Game_Character object. * @memberof Sprite_Character */ startBalloon(): void; /** * Processes the balloon sprite, calls * the endBaloon method if the balloon sprite is done playing. * @memberof Sprite_Character */ updateBalloon(): void; /** * Ends the balloon sprite, removing it from * the Game_Character object sprite. * @memberof Sprite_Character */ endBalloon(): void; /** * Returns true if a balloon animation * is playing on the character. * @returns {Bool} * @memberof Sprite_Character */ isBalloonPlaying(): boolean; } /** * ----------------------------------------------------------------------------- * Sprite_Damage * * The sprite for displaying a popup damage. */ declare class Sprite_Damage extends Sprite { protected constructor(); __duration: number; /** * Array of 3 numbers of RGB */ _flashColor: number[]; _flashDuration: number; _damageBitmap: Bitmap; setup(target: Game_Actor): void; setupCriticalEffect(): void; /** * Returns the digit width of the sprite damage. * * @returns {number} * @memberof Sprite_Damage */ digitWidth(): number; /** * Returns the digit height of the sprite damage. * * @returns {number} * @memberof Sprite_Damage */ digitHeight(): number; /** * Creates the miss display of the damage sprite. * * @memberof Sprite_Damage */ createMiss(): void; createDigits(baseRow: number, value: number): void; /** * Creates the child sprite of the damage sprite for displaying damage. * * @returns {Sprite} * @memberof Sprite_Damage */ createChildSprite(): Sprite; updateChild(sprite: Sprite): void; /** * Updates the flash of the damage sprite. * * @memberof Sprite_Damage */ updateFlash(): void; /** * Updates the opacity of the damage sprite. * * @memberof Sprite_Damage */ updateOpacity(): void; /** * Returns true if the damage sprite is playing. * * @returns {boolean} * @memberof Sprite_Damage */ isPlaying(): boolean; } /** * ----------------------------------------------------------------------------- * Sprite_Destination * * The sprite for displaying the destination place of the touch input. */ declare class Sprite_Destination extends Sprite { protected constructor(); _frameCount: number; /** * Creates the destination bitmap of the destination sprite. * * @memberof Sprite_Destination */ createBitmap(): void; /** * Updates the position of the destination sprite. * * @memberof Sprite_Destination */ updatePosition(): void; /** * Updates the destination sprite animation. * * @memberof Sprite_Destination */ updateAnimation(): void; } /** * ----------------------------------------------------------------------------- * Sprite_Enemy * * The sprite for displaying an enemy. */ declare class Sprite_Enemy extends Sprite_Battler { constructor(battler: Game_Enemy); _enemy: Game_Enemy; _appeared: boolean; _battlerName: string; _battlerHue: number; _effectType: string; _effectDuration: number; _shake: number; _stateIconSprite: Sprite_StateIcon; initialize(battler: Game_Enemy): void; createStateIconSprite(): void; /** * Sets the battler to an instance of game enemy. * * @param {Game_Enemy} battler Instance of game enemy. * @memberof Sprite_Enemy */ setBattler(battler: Game_Enemy): void; loadBitmap(name: string, hue: number): void; /** * Updates the state sprite on the sprite enemy. * * @memberof Sprite_Enemy */ updateStateSprite(): void; initVisibility(): void; setupEffect(): void; startEffect(effectType: string): void; /** * Starts the appearinig effect on the sprite enemy. * * @memberof Sprite_Enemy */ startAppear(): void; /** * Starts the disappearing effect on the sprite enemy. * * @memberof Sprite_Enemy */ startDisappear(): void; /** * Starts the whiten effect on the sprite enemy. * * @memberof Sprite_Enemy */ startWhiten(): void; /** * Starts the blink effect on the sprite enemy. * * @memberof Sprite_Enemy */ startBlink(): void; /** * Starts the collapse effect of the sprite * enemy. * @memberof Sprite_Enemy */ startCollapse(): void; /** * Starts the boss collapse effect of the sprite * enemy. * @memberof Sprite_Enemy */ startBossCollapse(): void; /** * Starts the instant collapse effect of the sprite enemy. * * @memberof Sprite_Enemy */ startInstantCollapse(): void; updateEffect(): void; /** * Returns true if the effect type on the sprite enemy * is not null. * @returns {Bool} * @memberof Sprite_Enemy */ isEffecting(): boolean; /** * Revers the sprite enemy to a normal state. * * @memberof Sprite_Enemy */ revertToNormal(): void; /** * Updates the whiten effect on the sprite enemy. * * @memberof Sprite_Enemy */ updateWhiten(): void; /** * Updates the blink effect on the sprite enemy. * * @memberof Sprite_Enemy */ updateBlink(): void; /** * Updates the appear effect on the sprite enemy. * * @memberof Sprite_Enemy */ updateAppear(): void; updateDisappear(): void; /** * Updates the collapse effect. * * @memberof Sprite_Enemy */ updateCollapse(): void; /** * Updates the boss collapse effect. * * @memberof Sprite_Enemy */ updateBossCollapse(): void; /** * Updates the instant collapse effect. * * @memberof Sprite_Enemy */ updateInstantCollapse(): void; damageOffsetX(): number; damageOffsetY(): number; } /** * ----------------------------------------------------------------------------- * Sprite_Picture * * The sprite for displaying a picture. */ declare class Sprite_Picture { constructor(pictureId: number); _pictureId: number; _pictureName: string; _isPicture: boolean; picture(): Game_Picture; updateBitmap(): void; updateOrigin(): void; updatePosition(): void; updateScale(): void; updateTone(): void; updateOther(): void; loadBitmap(): void; } /** * ----------------------------------------------------------------------------- * Sprite_StateIcon * * The sprite for displaying state icons. */ declare class Sprite_StateIcon extends Sprite { protected constructor(); _battler: Game_Battler; _iconIndex: number; _animationCount: number; _animationIndex: number; /** * Initializes the sprite state icon properties. * * @memberof Sprite_StateIcon */ initMembers(): void; /** * Loads the bitmap of the sprite state icon. * * @memberof Sprite_StateIcon */ loadBitmap(): void; setup(battler: Game_Battler): void; animationWait(): number; /** * Updates the icon displayed in the icon sprite. * * @memberof Sprite_StateIcon */ updateIcon(): void; /** * Updates the state icon sprite frame. * * @memberof Sprite_StateIcon */ updateFrame(): void; static _iconWidth: number; static _iconHeight: number; } /** * ----------------------------------------------------------------------------- * Sprite_StateOverlay * * The sprite for displaying an overlay image for a state. */ declare class Sprite_StateOverlay extends Sprite_Base { protected constructor(); _battler: Game_Battler; _overlayIndex: number; _animationCount: number; _pattern: number; /** * Initialize the overlay sprite properties. * * @memberof Sprite_StateOverlay */ initMembers(): void; /** * Loads the bitmap of the overlay sprite. * * @memberof Sprite_StateOverlay */ loadBitmap(): void; setup(battler: Game_Battler): void; animationWait(): number; /** * Updates the overlay sprite pattern. * * @memberof Sprite_StateOverlay */ updatePattern(): void; /** * Updates the overlay sprite frame. * * @memberof Sprite_StateOverlay */ updateFrame(): void; } /** * ----------------------------------------------------------------------------- * Sprite_Timer * * The sprite for displaying the timer. */ declare class Sprite_Timer extends Sprite { protected constructor(); _seconds: number; /** * Creates the bitmap of the sprite timer. * * @memberof Sprite_Timer */ createBitmap(): void; /** * Updates the bitmap of the sprite timer. * * @memberof Sprite_Timer */ updateBitmap(): void; /** * Redraws the sprite timer. * * @memberof Sprite_Timer */ redraw(): void; /** * Returns the text of the timer. * * @returns {string} The text displayed on the timer. * @memberof Sprite_Timer */ timerText(): string; /** * Updates the positon of the sprite timer. * * @memberof Sprite_Timer */ updatePosition(): void; /** * Updates the visibility of the sprite timer. * * @memberof Sprite_Timer */ updateVisibility(): void; } /** * ----------------------------------------------------------------------------- * Sprite_Weapon * * The sprite for displaying a weapon image for attacking. */ declare class Sprite_Weapon extends Sprite_Base { protected constructor(); _weaponImageId: rm.types.WeaponImageId; _animaationCount: number; _pattern: number; /** * Initializes the members of the weapon sprite object. * * @memberof Sprite_Weapon */ initMembers(): void; setup(weaponImageId: rm.types.WeaponImageId): void; animationWait(): number; /** * Updates the pattern of the weapon sprite. * * @memberof Sprite_Weapon */ updatePattern(): void; /** * Loads the bitmap of the weapon sprite. * * @memberof Sprite_Weapon */ loadBitmap(): void; /** * Updates the weapon sprite frames. * * @memberof Sprite_Weapon */ updateFrame(): void; /** * Returns true if the weapon sprite is playing. * * @returns {boolean} * @memberof Sprite_Weapon */ isPlaying(): boolean; } /** * ----------------------------------------------------------------------------- * Spriteset_Base * * The superdeclare class of Spriteset_Map and Spriteset_Battle. */ declare class Spriteset_Base extends Sprite { protected constructor(); _tone: number[]; _baseSprite: Sprite; _blackScreen: ScreenSprite; _toneFilter: ToneFilter; _toneSprite: ToneSprite; _pictureContainer: Sprite; _timerSprite: Sprite_Timer; _flashSprite: ScreenSprite; _fadeSprite: ScreenSprite; /** * Creates the lower layer including the base sprites. * * @memberof Spriteset_Base */ createLowerLayer(): void; /** * Creates the upper layer including the pictures, * timer, and screen sprites. * @memberof Spriteset_Base */ createUpperLayer(): void; /** * Create the base sprite. * * @memberof Spriteset_Base */ createBaseSprite(): void; /** * Creates the tone changer sprite. * * @memberof Spriteset_Base */ createToneChanger(): void; /** * Creates the WebGL toner. * * @memberof Spriteset_Base */ createWebGLToneChanger(): void; /** * Creates the Canvas tone. * * @memberof Spriteset_Base */ createCanvasToneChanger(): void; /** * Creates a new sprite picture on the spritesetb ase. * * @memberof Spriteset_Base */ createPictures(): void; /** * Creates a new Sprite timer on the spriteset base. * * @memberof Spriteset_Base */ createTimer(): void; /** * Creates the screen sprite. * * @memberof Spriteset_Base */ createScreenSprites(): void; /** * Updates the screen sprites on the spriteset base. * * @memberof Spriteset_Base */ updateScreenSprites(): void; updateToneChanger(): void; /** * Updates the WebGL tone changer. * * @memberof Spriteset_Base */ updateWebGLToneChanger(): void; /** * Updates the Canvas tone changer. * * @memberof Spriteset_Base */ updateCanvasToneChanger(): void; /** * Updates the position of spriteset base. * * @memberof Spriteset_Base */ updatePosition(): void; } /** * ----------------------------------------------------------------------------- * Spriteset_Battle * * The set of sprites on the battle screen. */ declare class Spriteset_Battle extends Spriteset_Base { protected constructor(); _battlebackLocated: boolean; _backgroundSprite: Sprite; _battleField: Sprite; _back1Sprite: TilingSprite; _back2Sprite: TilingSprite; _enemySprites: Sprite_Enemy[]; _actorSprites: Sprite_Actor[]; /** * Creates the background of the battle spriteset. * * @memberof Spriteset_Battle */ createBackground(): void; /** * Creates the battlefield of the battle spriteset. * * @memberof Spriteset_Battle */ createBattleField(): void; /** * Creates the battleback of the battle spriteset. * * @memberof Spriteset_Battle */ createBattleback(): void; /** * Updates the battleback of the battle spriteset. * * @memberof Spriteset_Battle */ updateBattleback(): void; /** * Locates the battleback and adjusts the coordinates of the * battleback. * @memberof Spriteset_Battle */ locateBattleback(): void; /** * Returns battleb ack 2 of the battle spriteset. * * @returns {Bitmap} Instance of the Bitmap class. * @memberof Spriteset_Battle */ battleback1Bitmap(): Bitmap; /** * Returns battleback 2 of the battle spriteset. * * @returns {Bitmap} Instance of the Bitmap class. * @memberof Spriteset_Battle */ battleback2Bitmap(): Bitmap; /** * * * @returns {string} Name of battleback 1 bitmap. * @memberof Spriteset_Battle */ battleback1Name(): string; /** * * * @returns {string} Name of battleback 2 bitmap. * @memberof Spriteset_Battle */ battleback2Name(): string; /** * Returns the battleback 1 name as a string. * * @returns {string} Name of overworld battleback 1 bitmap. * @memberof Spriteset_Battle */ overworldBattleback1Name(): string; /** * Returns the battleback 2 name as a string. * * @returns {string} Name of overworld battleback 2 bitmap. * @memberof Spriteset_Battle */ overworldBattleback2Name(): string; /** * * * @returns {string} Name of the normal battleback 1 bitmap. * @memberof Spriteset_Battle */ normalBattleback1Name(): string; /** * * * @returns {string} Name of the normal battleback 2 bitmap. * @memberof Spriteset_Battle */ normalBattleback2Name(): string; /** * Given the specified terrtain type, return * the battleback 1 name. * @param {number} type Terrain type. * @returns {string} Name of the terrtain battleback 1 bitmap. * @memberof Spriteset_Battle */ terrainBattleback1Name(type: number): string; /** * Given the specified terrain type, return * the battleback 2 name. * @param {number} type Terrain type. * @returns {string} Name of the terrain battleback 2 bitmap. * @memberof Spriteset_Battle */ terrainBattleback2Name(type: number): string; /** * * * @returns {string} Name of the default battleback 1 name. * @memberof Spriteset_Battle */ defaultBattleback1Name(): string; /** * * * @returns {string} Name of the default battleback 2 name. * @memberof Spriteset_Battle */ defaultBattleback2Name(): string; /** * * * @returns {string} Name of the ship battleback 1 bitmap. * @memberof Spriteset_Battle */ shipBattleback1Name(): string; /** * * * @returns {string} Name of the ship battleback 2 bitmap. * @memberof Spriteset_Battle */ shipBattleback2Name(): string; autotileType(z: number): number; /** * Creates sprite enemies for the battle spriteset. * * @memberof Spriteset_Battle */ createEnemies(): void; compareEnemySprite(a: Sprite_Enemy, b: Sprite_Enemy): number; /** * Creates sprite actors for the battle spriteset. * * @memberof Spriteset_Battle */ createActors(): void; /** * Updates the actor sprites on the battle spriteset. * * @memberof Spriteset_Battle */ updateActors(): void; /** * Returns all battler sprites on the battle spriteset. * * @returns {Array} * @memberof Spriteset_Battle */ battlerSprites(): Sprite_Battler[]; /** * Returns true if animation is playing on the battle spriteset. * * @returns {boolean} * @memberof Spriteset_Battle */ isAnimationPlaying(): boolean; isEffecting(): boolean; /** * Returns true if any sprite actor or enemy is moving. * * @returns {boolean} Representing whether any battle participants are moving. * @memberof Spriteset_Battle */ isAnyoneMoving(): boolean; /** * Returns true if the battle spriteset is busy. * * @returns {boolean} * @memberof Spriteset_Battle */ isBusy(): boolean; } /** * ----------------------------------------------------------------------------- * Spriteset_Map * * The set of sprites on the map screen. */ declare class Spriteset_Map extends Spriteset_Base { protected constructor(); _parallax: TilingSprite; _tilemap: Tilemap | ShaderTilemap; _tileset: rm.types.Tileset; _characterSprites: Sprite_Character[]; _shadowSprite: Sprite; _destinationSprite: Sprite_Destination; _weather: Weather; _parallaxName: string; /** * Hides the map spriteset character sprites. * * @memberof Spriteset_Map */ hideCharacters(): void; /** * Creates the map spriteset parallax. * * @memberof Spriteset_Map */ createParallax(): void; /** * Creates the map spriteset tile map. * * @memberof Spriteset_Map */ createTilemap(): void; /** * Loads the map spriteset tileset. * * @memberof Spriteset_Map */ loadTileset(): void; /** * Creates the map spriteset character sprite. * * @memberof Spriteset_Map */ createCharacters(): void; /** * Creates the map spriteset shadow sprite. * * @memberof Spriteset_Map */ createShadow(): void; /** * Creates the map spriteset destination sprite. * * @memberof Spriteset_Map */ createDestination(): void; /** * Creates the map spriteset weather. * * @memberof Spriteset_Map */ createWeather(): void; /** * Updates the map spriteset tileset. * * @memberof Spriteset_Map */ updateTileset(): void; updateParallax(): void; /** * Updates the map spriteset tile map. * * @memberof Spriteset_Map */ updateTilemap(): void; /** * Updates the map spriteset shadow. * * @memberof Spriteset_Map */ updateShadow(): void; /** * Updates the map spriteset weather. * * @memberof Spriteset_Map */ updateWeather(): void; } declare class Window_Selectable extends Window_Base { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, height: number, width: number): void; /** * Returns the current position of the _index property. * * @returns {Int} * @memberof Window_Selectable */ index(): number; /** * Returns true if the _cursorFixed property is true; * this means the cursor is locked to a position. * @returns {boolean} * @memberof Window_Selectable */ cursorFixed(): boolean; /** * Sets the _cursorFixed property of the * window. * @param {boolean} cursorFixed * @memberof Window_Selectable */ setCursorFixed(cursorFixed: boolean): void; cursorAll(): boolean; setCursorAll(cursorAll: boolean): void; /** * Returns the maximum number of columns * for the window. * @returns {number} * @memberof Window_Selectable */ maxCols(): number; /** * Returns the maximum number of items within the window; * useful to overwrite when creating a new window. * This method is used to calculate the number of rows and more. * @returns {number} * @memberof Window_Selectable */ maxItems(): number; spacing(): number; /** * Returns the width of an item within the window; * determines the width of a column. * @returns {number} * @memberof Window_Selectable */ itemWidth(): number; /** * Returns the height of an item within the window; * determines the height of a row. * @returns {number} * @memberof Window_Selectable */ itemHeight(): number; /** * Selects the current index within the window given a number. * * @param {number} index * @memberof Window_Selectable */ select(index: number): void; /** * Deselects the currently selected index. * * @memberof Window_Selectable */ deselect(): void; /** * Reselects the index based on the window's _index property. * * @memberof Window_Selectable */ reselect(): void; row(): number; topRow(): number; maxTopRow(): number; /** * Sets the current top row of the given a number. * The top row will then be moved to an index * of the window. * @param {number} row * @memberof Window_Selectable */ setTopRow(row: number): void; resetScroll(): void; maxPageRows(): number; maxPageItems(): number; /** * Returns true if the window is horizontal; * means the window only has a single row. * @returns {boolean} * @memberof Window_Selectable */ isHorizontal(): boolean; bottomRow(): number; setBottomRow(row: number): void; /** * Creates a new rectangle based on itemWidth and itemHeight. * The rectangle is mainly used for positioning items within * the selectable window. * @param {number} index * @returns {Rectangle} * @memberof Window_Selectable */ itemRect(index: number): Rectangle; /** * Creates a new rectangle based on itemWidth and itemHeight * The rectangle is used for positioning text within * the selectable window. * @param {number} index * @returns {Rectangle} * @memberof Window_Selectable */ itemRectForText(index: number): Rectangle; setHelpWindow(helpWindow: Window_Help): void; /** * Shows the attached help window. * * @memberof Window_Selectable */ showHelpWindow(): void; /** * Hides the attached help window. * * @memberof Window_Selectable */ hideHelpWindow(): void; /** * Creates a new handler with the symbol as the handler name * and a method (JS function) bound to it. * @param {string} symbol * @param {*} method * @memberof Window_Selectable */ setHandler(symbol: string, method: any): void; isHandled(symbol: string): boolean; callHandler(symbol: string): void; isOpenAndActive(): boolean; isCursorMovable(): boolean; /** * Moves the cursor down; if wrap is passed * as true, then it will return to the top when * at the end of the list. * @param {boolean} wrap * @memberof Window_Selectable */ cursorDown(wrap: boolean): void; /** * Moves the cursor up; if wrap is passed * as true, then it will return to the bottom * when at the top of the list. * @param {boolean} wrap * @memberof Window_Selectable */ cursorUp(wrap: boolean): void; cursorRight(wrap: boolean): void; cursorLeft(wrap: boolean): void; cursorPagedown(): void; cursorPageup(): void; scrollDown(): void; scrollUp(): void; updateArrows(): void; /** * Handles the processing of cursor movement. * * @memberof Window_Selectable */ processCursorMove(): void; /** * Handles the process of attached handlers. * * @memberof Window_Selectable */ processHandling(): void; /** * Handles the processing of the scroll wheel within * the window. * @memberof Window_Selectable */ processWheel(): void; /** * Handles the processing of touch input. * * @memberof Window_Selectable */ processTouch(): void; isTouchedInsideFrame(): boolean; onTouch(triggered: boolean): void; hitTest(x: number, y: number): number; isContentsArea(x: number, y: number): boolean; /** * Determines if touch ok is enabled as an option; * this means whether you can confirm the selection * of an item within the window with touch input. * @returns {boolean} * @memberof Window_Selectable */ isTouchOkEnabled(): boolean; /** * Determines if ok is enabled as an option; * this means whether you can confirm selection * of an item within the window. * @returns {boolean} * @memberof Window_Selectable */ isOkEnabled(): boolean; isCancelEnabled(): boolean; isOkTriggered(): boolean; isCancelTriggered(): boolean; processOk(): void; callOkHandler(): void; processCancel(): void; callCancelHandler(): void; processPageup(): void; processPagedown(): void; updateInputData(): void; updateCursor(): void; /** * Determines if the cursor is visible within * the window. * @returns {boolean} * @memberof Window_Selectable */ isCursorVisible(): boolean; ensureCursorVisible(): void; callUpdateHelp(): void; updateHelp(): void; setHelpWindowItem(item: any): void; isCurrentItemEnabled(): boolean; /** * Draws all items within the window; this method * cals drawItem multiple times. * @memberof Window_Selectable */ drawAllItems(): void; drawItem(index: number): void; clearItem(index: number): void; redrawItem(index: number): void; redrawCurrentItem(): void; /** * Refreshes the window contents. * * @memberof Window_Selectable */ refresh(): void; } declare class Window_Command extends Window_Selectable { /** * Creates an instance of Window_Command. * @param {number} x * @param {number} y * @memberof Window_Command */ constructor(x: number, y: number); initialize(x: number, y: number): void; /** * Returns the width of the window; * default is 240. * @returns {number} * @memberof Window_Command */ windowWidth(): number; /** * Returns the height of the window; * takes the visible rows and passes it to the fittingHeight method. * @returns {number} * @memberof Window_Command */ windowHeight(): number; /** * Returns the number of visible rows within the window. * * @returns {number} * @memberof Window_Command */ numVisibleRows(): number; /** * Returns the maximum number of items within the window. * * @returns {number} * @memberof Window_Command */ maxItems(): number; /** * Clears the list of commands from the window; * this is useful for refreshing changing commands. * @memberof Window_Command */ clearCommandList(): void; /** * Convenient method for overwriting and adding * commands with the addCommand method. * @memberof Window_Command */ makeCommandList(): void; /** * Adds commands to the window list with the specified * parameters. The actual command can be found as an object. * @param {String} name * @param {String} symbol * @param {boolean} enabled * @param {(any | object)} [ext] * @memberof Window_Command */ addCommand(name: string, symbol: string, enabled: boolean, ext?: any): void; /** * Returns the command name given an index. * * @param {number} index * @returns {String} * @memberof Window_Command */ commandName(index: number): string; /** * Returns the command symbol given an index. * * @param {number} index * @returns {String} * @memberof Window_Command */ commandSymbol(index: number): string; /** * Determines if the command is enabled; * checks the enabled property of the command. * @param {number} index * @returns {boolean} * @memberof Window_Command */ isCommandEnabled(index: number): boolean; /** * Returns the command object at the current index. * * @returns {object} * @memberof Window_Command */ currentData(): any; /** * Returns the command symbol at the current index. * * @returns {String} * @memberof Window_Command */ currentSymbol(): string; /** * Returns the ext property of the command at the current index. * * @returns {(any | object)} * @memberof Window_Command */ currentExt(): any; /** * Finds a command object and returns the index number based * on the symbol property. * @param {String} symbol * @returns {number} * @memberof Window_Command */ findSymbol(symbol: string): boolean; /** * Selects a command object based on the symbol property. * * @param {String} symbol * @memberof Window_Command */ selectSymbol(symbol: string): void; /** * Finds a command object and returns the index number * based on the ext property. * @param {(any | object)} ext * @returns {number} * @memberof Window_Command */ findExt(ext: any): number; /** * Selects a command object based on the ext property. * * @param {(any | object)} ext * @memberof Window_Command */ selectExt(ext: any): void; /** * Returns the text align of the commands; * possible values are: 'left', 'center', 'right'. * @returns {String} * @memberof Window_Command */ itemTextAlign(): string; } /** * ----------------------------------------------------------------------------- * Window_ActorCommand * * The window for selecting an actor's action on the battle screen. * @class Window_ActorCommand */ declare class Window_ActorCommand extends Window_Command { constructor(); /** * Adds the attack command to the actor command window. * * @memberof Window_ActorCommand */ addAttackCommand(): void; /** * Adds the skill command to the actor command window. * * @memberof Window_ActorCommand */ addSkillCommands(): void; /** * Adds the guard command to the actor command window. * * @memberof Window_ActorCommand */ addGuardCommand(): void; /** * Adds the item command to the actor command window. * * @memberof Window_ActorCommand */ addItemCommand(): void; /** * Sets up the actor command window with a specified actor. * * @param {Game_Actor} actor * @memberof Window_ActorCommand */ setup(actor: Game_Actor): void; selectLast(): void; } /** * ----------------------------------------------------------------------------- * Window_BattleStatus * * The window for displaying the status of party members on the battle screen. * @class Window_BattleStatus */ declare class Window_BattleStatus extends Window_Selectable { constructor(); /** * Returns the window width. * * @returns {number} * @memberof Window_BattleStatus */ windowWidth(): number; /** * Returns the window height. * * @returns {number} * @memberof Window_BattleStatus */ windowHeight(): number; /** * Returns the number of visible rows. * * @returns {number} * @memberof Window_BattleStatus */ numVisibleRows(): number; basicAreaRect(index: number): Rectangle; /** * returns a rectangle for the gauges in the gauge area. * * @param {number} index * @returns {Rectangle} * @memberof Window_BattleStatus */ gaugeAreaRect(index: number): Rectangle; /** * Returns the width of the guage area. * * @returns {number} * @memberof Window_BattleStatus */ gaugeAreaWidth(): number; /** * Draws the basic area for actors within the battle status window. * * @param {Rectangle} rect * @param {Game_Actor} actor * @memberof Window_BattleStatus */ drawBasicArea(rect: Rectangle, actor: Game_Actor): void; /** * Draws the gauge area for the actors within the battle status window. * * @param {Rectangle} rect * @param {Game_Actor} actor * @memberof Window_BattleStatus */ drawGaugeArea(rect: Rectangle, actor: Game_Actor): void; /** * Draws the gauges in the basic area with tp included. * * @param {Rectangle} rect * @param {Game_Actor} actor * @memberof Window_BattleStatus */ drawGaugeAreaWithTp(rect: Rectangle, actor: Game_Actor): void; /** * Draws the gauges in the basic area without tp included. * * @param {Rectangle} rect * @param {Game_Actor} actor * @memberof Window_BattleStatus */ drawGaugeAreaWithoutTp(rect: Rectangle, actor: Game_Actor): void; } /** * ----------------------------------------------------------------------------- * Window_BattleActor * * The window for selecting a target actor on the battle screen. * @class Window_BattleActor */ declare class Window_BattleActor extends Window_BattleStatus { constructor(x: number, y: number); initialize(x: number, y: number): void; /** * Selects an actor within the battle actor window. * * @param {number} index * @memberof Window_BattleActor */ select(index: number): void; /** * Returns the current selected actor. * * @returns {Game_Actor} * @memberof Window_BattleActor */ actor(): Game_Actor; } /** * ----------------------------------------------------------------------------- * Window_BattleEnemy * * The window for selecting a target enemy on the battle screen. * @class Window_BattleEnemy */ declare class Window_BattleEnemy extends Window_Selectable { constructor(x: number, y: number); initialize(x: number, y: number): void; /** * Returns the window width. * * @returns {number} * @memberof Window_BattleEnemy */ windowWidth(): number; /** * Returns the window height. * * @returns {number} * @memberof Window_BattleEnemy */ windowHeight(): number; /** * Returns the number of visible rows. * * @returns {number} * @memberof Window_BattleEnemy */ numVisibleRows(): number; /** * Returns the current enemy. * * @returns {Game_Enemy} * @memberof Window_BattleEnemy */ enemy(): Game_Enemy; /** * Returns the current index selected. * * @returns {number} * @memberof Window_BattleEnemy */ enemyIndex(): number; /** * Selects a specified enemy using the index. * * @param {number} index * @memberof Window_BattleEnemy */ select(index: number): void; } declare class Window_ItemList extends Window_Selectable { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, width: number, height: number): void; needsNumber(): boolean; selectLast(): void; makeItemList(): void; numberWidth(): number; } /** * ----------------------------------------------------------------------------- * Window_BattleItem * * The window for selecting an item to use on the battle screen. * @class Window_BattleItem */ declare class Window_BattleItem extends Window_ItemList { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, width: number, height: number): void; includes(item: rm.types.UsableItem): boolean; } /** * ----------------------------------------------------------------------------- * Window_BattleLog * * The window for displaying battle progress. No frame is displayed, but it is * handled as a window for convenience. * @class Window_BattleLog */ declare class Window_BattleLog extends Window_Base { constructor(); initialize(): void; setSpriteset(spriteset: Spriteset_Battle): void; windowWidth(): number; windowHeight(): number; maxLines(): number; createBackBitmap(): void; createBackSprite(): void; numLines(): number; messageSpeed(): number; isBusy(): boolean; updateWait(): boolean; updateWaitCount(): boolean; updateWaitMode(): boolean; setWaitMode(waitMode: string): void; callNextMethod(): void; isFastForward(): boolean; push(methodName: string, args: any[]): void; clear(): void; wait(): void; waitForEffect(): void; waitForMovement(): void; addText(text: string): void; pushBaseLine(): void; popBaseLine(): void; waitForNewLine(): void; popupDamage(target: Game_Battler): void; performActionStart(subject: Game_Battler, action: Game_Action): void; performAction(subject: Game_Battler, action: Game_Action): void; performActionEnd(subject: Game_Battler): void; performDamage(target: Game_Battler): void; performMiss(target: Game_Battler): void; performRecovery(target: Game_Battler): void; performEvasion(target: Game_Battler): void; performMagicEvasion(target: Game_Battler): void; performCounter(target: Game_Battler): void; performReflection(target: Game_Battler): void; performSubstitute(substitute: Game_Battler, target: Game_Battler): void; performCollapse(target: Game_Battler): void; showAnimation(subject: Game_Battler, targets: Game_Battler, animationId: number): void; showAttackAnimation(subject: Game_Battler, targets: Game_Battler): void; showActorAttackAnimation(subject: Game_Battler, targets: Game_Battler): void; showEnemyAttackAnimation(subject: Game_Battler, targets: Game_Battler): void; showNormalAnimation(targets: Game_Battler, animationId: number, mirror: boolean): void; animationBaseDelay(): number; animationNextDelay(): number; drawBackground(): void; backRect(): Rectangle; backColor(): string; backPaintOpacity(): number; drawLineText(index: number): void; startTurn(): void; startAction(subject: Game_Battler, action: Game_Action, targets: Game_Battler[]): void; endAction(subject: Game_Battler): void; displayCurrentState(subject: Game_Battler): void; displayRegeneration(subject: Game_Battler): void; displayAction(subject: Game_Battler, item: rm.types.UsableItem): void; displayCounter(target: Game_Battler): void; displayReflection(target: Game_Battler): void; displaySubstitute(substitute: Game_Battler, target: Game_Battler): void; displayActionResults(subject: Game_Battler, targt: Game_Battler): void; displayFailure(target: Game_Battler): void; displayCritical(target: Game_Battler): void; displayDamage(target: Game_Battler): void; displayMiss(target: Game_Battler): void; displayEvasion(target: Game_Battler): void; displayHpDamage(target: Game_Battler): void; displayMpDamage(target: Game_Battler): void; displayTpDamage(target: Game_Battler): void; displayAffectedStatus(target: Game_Battler): void; displayAutoAffectedStatus(target: Game_Battler): void; displayChangedStates(target: Game_Battler): void; displayAddedStates(target: Game_Battler): void; displayRemovedStates(target: Game_Battler): void; displayChangedBuffs(target: Game_Battler): void; /** * * @param target * @param buffs list of integers representing buff Ids * @param fmt */ displayBuffs(target: Game_Battler, buffs: number[], fmt: string): void; makeHpDamageText(target: Game_Battler): void; makeMpDamageText(target: Game_Battler): string; makeTpDamageText(target: Game_Battler): string; } declare namespace rm.types { export const enum SkillTypeIdA { base = -1, } } /** * ----------------------------------------------------------------------------- * Window_SkillList * * The window for selecting a skill on the skill screen. * @class Window_SkillList */ declare class Window_SkillList extends Window_Selectable { constructor(x: number, y: number, witth: number, height: number); _actor: Game_Actor; /** * Returns the Skill Type Id, which is an Int. */ _stypeId: rm.types.SkillTypeIdA; _data: rm.types.Skill[]; initialize(x: number, y: number, width: number, height: number): void; /** * Sets the current actor of the skill list window. * * @param {Game_Actor} actor * @memberof Window_SkillList */ setActor(actor: Game_Actor): void; /** * Sets the skill type id of the skill list window. * * @param {number} stypeId - Integer * @memberof Window_SkillList */ setStypeId(stypeId: rm.types.SkillTypeIdA): void; /** * Returns the current skill at the window index * loaded from the databse. * * @returns {RPG.Skill} * @memberof Window_SkillList */ item(): rm.types.Skill; /** * Returns true if the given skill is included. * * @param {RPG.Skill} item * @returns {boolean} * @memberof Window_SkillList */ includes(item: rm.types.Skill): boolean; /** * Returns true if the given skill is enabled. * * @param {RPG.Skill} item * @returns {boolean} * @memberof Window_SkillList */ isEnabled(item: rm.types.Skill): boolean; /** * Creates the item list. * * @memberof Window_SkillList */ makeItemList(): void; selectLast(): void; costWidth(): number; drawSkillCost(skill: rm.types.Skill, x: number, y: number, width: number): void; } /** * ----------------------------------------------------------------------------- * Window_BattleSkill * * The window for selecting a skill to use on the battle screen. * @class Window_BattleSkill */ declare class Window_BattleSkill extends Window_SkillList { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, width: number, height: number): void; } /** * ----------------------------------------------------------------------------- * Window_ChoiceList * * The window used for the event command [Show Choices]. * @class Window_ChoiceList */ declare class Window_ChoiceList extends Window_Command { constructor(messageWindow: Window_Message); initialize(messageWindow: Window_Message): void; start(): void; selectDefault(): void; updatePlacement(): void; updateBackground(): void; maxChoiceWidth(): number; textWidthEx(text: string): number; } /** * ----------------------------------------------------------------------------- * Window_DebugEdit * * The window for displaying switches and variables on the debug screen. * @class Window_DebugEdit */ declare class Window_DebugEdit extends Window_Selectable { constructor(x: number, y: number, width: number); itemName(dataId: number): string; itemStatus(dataId: string): string; setMode(mode: string): void; setTopId(id: number): void; currentId(): number; updateSwitch(): void; updateVariable(): void; } /** * ----------------------------------------------------------------------------- * Window_DebugRange * * The window for selecting a block of switches/variables on the debug screen. * @class Window_DebugRange */ declare class Window_DebugRange extends Window_Selectable { constructor(x: number, y: number); windowWidth(): number; windowHeight(): number; mode(): string; topId(): number; setEditWindow(editWindow: Window_DebugEdit): void; } declare class Window_HorzCommand extends Window_Command { constructor(x: number, y: number); } declare class Window_EquipCommand extends Window_HorzCommand { protected constructor(); } /** * ----------------------------------------------------------------------------- * Window_EquipItem * * The window for selecting an equipment item on the equipment screen. * @class Window_EquipItem */ declare class Window_EquipItem { constructor(x: number, y: number, width: number, height: number); setActor(actor: Game_Actor): void; setSlotId(slotId: number): void; includes(item: rm.types.EquipItem): boolean; isEnabled(item: rm.types.EquipItem): boolean; setStatusWindow(statusWindow: Window_EquipStatus): void; } /** * ----------------------------------------------------------------------------- * Window_EquipSlot * * The window for selecting an equipment slot on the equipment screen. * @class Window_EquipSlot */ declare class Window_EquipSlot extends Window_Selectable { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, width: number, height: number): void; /** * Sets the current game actor. * * @param {Game_Actor} actor * @memberof Window_EquipSlot */ setActor(actor: Game_Actor): void; /** * Returns the current equip item. * * @returns {RPG.EquipItem} * @memberof Window_EquipSlot */ item(): rm.types.EquipItem; /** * Returns the name of the slot at the specified index. * * @param {number} index * @returns {string} * @memberof Window_EquipSlot */ slotName(index: number): string; /** * Returns true if the current slot is enabled. * * @param {number} index * @returns {boolean} * @memberof Window_EquipSlot */ isEnabled(index: number): boolean; /** * Sets the status window within the equip slot window. * * @param {Window_EquipStatus} statusWindow * @memberof Window_EquipSlot */ setStatusWindow(statusWindow: Window_EquipStatus): void; /** * Sets the item window within the equip slot window. * * @param {Window_EquipItem} itemWindow * @memberof Window_EquipSlot */ setItemWindow(itemWindow: Window_EquipItem): void; } declare class Window_EquipStatus extends Window_Base { protected constructor(); } /** * ----------------------------------------------------------------------------- * Window_EventItem * * The window used for the event command [Select Item]. * @class Window_EventItem */ declare class Window_EventItem extends Window_ItemList { constructor(messageWindow: Window_Message); /** * Returns the height off the window. * * @returns {number} * @memberof Window_EventItem */ windowHeight(): number; /** * Returns the number of visible rows. * * @returns {number} * @memberof Window_EventItem */ numVisibleRows(): number; /** * Starts the event item window. * * @memberof Window_EventItem */ start(): void; updatePlacement(): void; includes(item: rm.types.BaseItem): boolean; isEnabled(item: rm.types.BaseItem): boolean; onOk(): void; onCancel(): void; } /** * ----------------------------------------------------------------------------- * Window_GameEnd * * The window for selecting "Go to Title" on the game end screen. * @class Window_GameEnd */ declare class Window_GameEnd extends Window_Base { constructor(); updatePlacement(): void; } declare class Window_Gold extends Window_Base { constructor(x: number, y: number); /** * Returns the $gameParty gold as a number. * * @returns {number} * @memberof Window_Gold */ value(): number; /** * Returns the RPGMakerMV database currency * as a string. * @returns {string} * @memberof Window_Gold */ currencyUnit(): string; } declare class Window_Help extends Window_Base { /** * Creates an instance of Window_Help. * @param {number} numLines * @memberof Window_Help */ constructor(numLines: number); /** * Sets the _text property of the window; * this text will be displayed within the window. * @param {string} text * @memberof Window_Help */ setText(text: string): void; clear(): void; /** * Sets the current item of the help window. * * @param {RPG.BaseItem} item * @memberof Window_Help */ setItem(item: rm.types.BaseItem): void; } declare class Window_ItemCategory extends Window_HorzCommand { protected constructor(); } /** * ----------------------------------------------------------------------------- * Window_MapName * * The window for displaying the map name on the map screen. * @class Window_MapName */ declare class Window_MapName extends Window_Base { constructor(); /** * Returns the window width. * * @returns {number} * @memberof Window_MapName */ windowWidth(): number; /** * Returns the window height. * * @returns {number} * @memberof Window_MapName */ windowHeight(): number; updateFadeIn(): void; updateFadeOut(): void; /** * Windows the map name window. * * @memberof Window_MapName */ refresh(): void; /** * Draws the background of the map name window. * * @param {number} x * @param {number} y * @param {number} width * @param {number} height * @memberof Window_MapName */ drawBackground(x: number, y: number, width: number, height: number): void; } /** * ----------------------------------------------------------------------------- * Window_MenuStatus * * The window for displaying party member status on the menu screen. * @class Window_MenuStatus * @extends {Window_Selectable} */ declare class Window_MenuStatus extends Window_Selectable { /** * Creates an instance of Window_MenuStatus. * @param {number} x * @param {number} y * @memberof Window_MenuStatus */ constructor(x: number, y: number); /** * Window width. * @return Int */ windowWidth(): number; /** * Window height. * @return Int */ windowHeight(): number; /** * Returns the height of each item (actor status) in the main menu * window. * @returns {number} * @memberof Window_MenuStatus */ itemHeight(): number; /** * Returns the number of visible rows in * menu status. * @returns {number} * @memberof Window_MenuStatus */ numVisibleRows(): number; /** * Loads the images for the main menu status window. * * @memberof Window_MenuStatus */ loadImages(): void; /** * Draws the item background at the given index. * * @param {number} index * @memberof Window_MenuStatus */ drawItemBackground(index: number): void; drawItemImage(index: number): void; drawItemStatus(index: number): void; selectLast(): void; /** * Determines if the window is in formation mode; * if true, the player can select characters to swap * positions with. * @returns {boolean} * @memberof Window_MenuStatus */ formationMode(): boolean; /** * Sets the formation mode to true or false. * * @param {boolean} formationMode * @memberof Window_MenuStatus */ setFormationMode(formationMode: boolean): void; pendingIndex(): number; setPendingIndex(index: number): void; } declare class Window_MenuActor extends Window_MenuStatus { constructor(); initialize(): void; selectForItem(item: rm.types.BaseItem): void; } declare class Window_MenuCommand extends Window_Command { constructor(x: number, y: number); /** * Adds the standard game commands to the * RPGMakerMV main menu. * @memberof Window_MenuCommand */ addMainCommands(): void; /** * Adds the standard formation command to the * RPGMakerMV main menu. * @memberof Window_MenuCommand */ addFormationCommand(): void; /** * Adds any user created commands to the * RPGMakerMV main menu. * @memberof Window_MenuCommand */ addOriginalCommands(): void; /** * Adds the save command to the * RPGMakerMV main menu. * @memberof Window_MenuCommand */ addSaveCommand(): void; addGameEndCommand(): void; /** * Checks if the standard game commands for the menu * are needed based on database system options. * @param {string} name * @returns {boolean} * @memberof Window_MenuCommand */ needsCommand(name: string): boolean; /** * Determines if the main commands are enabled; * this is based on the settings in the database. * @returns {boolean} * @memberof Window_MenuCommand */ areMainCommandsEnabled(): boolean; /** * Determines if the option command is enabled; * based on the setting in the database. * @returns {boolean} * @memberof Window_MenuCommand */ isOptionsEnabled(): boolean; /** * Determines if the save command is enabled; * based on the setting in the database. * @returns {boolean} * @memberof Window_MenuCommand */ isSaveEnabled(): boolean; /** * Selects the last command in menu. * * @memberof Window_MenuCommand */ selectLast(): void; static initCommandPosition(): void; static _lastCommandSymbol: any; } declare class Window_Message extends Window_Base { protected constructor(); initialize(): void; initMembers(): void; /** * Processes normal characters displayed within the message window. * @param textState */ processNormalCharacter(textState: string): void; /** * Returns the sub windows attached to the message window. * * @returns {Array} * @memberof Window_Message */ subWindows(): Window_Base[]; /** * Creates the sub windows for the message window. * * @memberof Window_Message */ createSubWindows(): void; /** * Returns the width of the window. * * @returns {number} * @memberof Window_Message */ windowWidth(): number; /** * Returns the height of the window. * * @returns {number} * @memberof Window_Message */ windowHeight(): number; /** * Returns the number of visible rows within the message window. * * @returns {number} * @memberof Window_Message */ numVisibleRows(): number; checkToNotClose(): void; /** * Returns true if the message window can start. * * @returns {boolean} * @memberof Window_Message */ canStart(): boolean; /** * Starts the displaying of the message within the message window. * * @memberof Window_Message */ startMessage(): void; /** * Updates the placement of the message window. * * @memberof Window_Message */ updatePlacement(): void; /** * Clears the message window flags for * fast text, pause skip, and line show fast */ clearFlags(): void; /** * Sets the background type of the window in terms * of transparency. * 0, * 1, * 2 */ setBackgroundType(backgroundType: number): void; /** * Processes the escape characters in the message window. * @param code * @param textState */ processEscapeCharacter(code: string, textState: string): void; /** * Starts the wait count for the message window. * @param count */ startWait(count: number): void; /** * Starts the pause for the window. * Sets the wait count to 10 and pauses * the window. */ startPause(): void; /** * Updates the background of the message window. * * @memberof Window_Message */ updateBackground(): void; /** * Terminates the message and closes the gold and message window. * * @memberof Window_Message */ terminateMessage(): void; /** * Updates the wait of the message window. * * @returns {Bool} * @memberof Window_Message */ updateWait(): boolean; updateLoading(): boolean; /** * Updates input when the message window is processing. * * @returns {Bool} * @memberof Window_Message */ updateInput(): boolean; /** * Returns true if any sub window is active. * * @returns {Bool} * @memberof Window_Message */ isAnySubWindowActive(): boolean; /** * Updates the message. * * @returns {Bool} * @memberof Window_Message */ updateMessage(): boolean; /** * Handler for when there is no text left to display within * the message window. * @memberof Window_Message */ onEndOfText(): void; startInput(): boolean; /** * Returns true if the ok or cancel inputs have been triggered * multiple times. * @returns {Bool} * @memberof Window_Message */ isTriggered(): boolean; /** * Returns true if the message window still has text * and settings have not changed. * @returns {Bool} * @memberof Window_Message */ doesContinue(): boolean; /** * Returns true if the message window settings have been changed. * * @returns {Bool} * @memberof Window_Message */ areSettingsChanged(): boolean; updateShowFast(): void; newPage(textState: rm.types.TextState): void; loadMessageFace(): void; drawMessageFace(): void; newLineX(): number; processNewLine(textState: rm.types.TextState): void; processNewPage(textState: rm.types.TextState): void; } declare class Window_NameBox extends Window_Base { constructor(); baseTextRect(): Rectangle; } /** * ----------------------------------------------------------------------------- * Window_NameEdit * * The window for editing an actor's name on the name input screen. * @class Window_NameEdit */ declare class Window_NameEdit { /** * Creates an instance of Window_NameEdit. * @param {Game_Actor} actor * @param {number} maxLength * @memberof Window_NameEdit */ constructor(actor: Game_Actor, maxLength: number); /** * Returns the window width. * * @returns {number} * @memberof Window_NameEdit */ windowWidth(): number; /** * Returns the window height. * * @returns {number} * @memberof Window_NameEdit */ windowHeight(): number; restoreDefault(): boolean; add(ch: string): boolean; back(): boolean; /** * Returns the width of the character face. * * @returns {number} * @memberof Window_NameEdit */ faceWidth(): number; /** * Returns the width of a character. * * @returns {number} * @memberof Window_NameEdit */ charWidth(): number; left(): number; underlineRect(index: number): Rectangle; /** * Returns the color of the underline as a css color String. * * @returns {String} * @memberof Window_NameEdit */ underlineColor(): string; /** * Draws the underline at the given index of the window. * * @param {number} index * @memberof Window_NameEdit */ drawUnderline(index: number): void; /** * Draws a character within the window at the specified index. * * @param {number} index * @memberof Window_NameEdit */ drawChar(index: number): void; /** * Refreshes the window contents. * * @memberof Window_NameEdit */ refresh(): void; } /** * ----------------------------------------------------------------------------- * Window_NameInput * * The window for selecting text characters on the name input screen. * @class Window_NameInputt */ declare class Window_NameInput extends Window_Selectable { constructor(editWindow: Window_NameEdit); /** * Returns the window height. * * @returns {number} * @memberof Window_NameInput */ windowHeight(): number; /** * Returns the table of characters to input. * * @returns {Array>} * @memberof Window_NameInput */ table(): string[][]; character(): string; isPageChange(): boolean; isOk(): boolean; processJump(): void; processBack(): void; onNameAdd(): void; onNameOk(): void; static LATIN1: string[]; static LATIN2: string[]; static RUSSIA: string[]; static JAPAN1: string[]; static JAPAN2: string[]; static JAPAN3: string[]; } declare class Window_NumberInput extends Window_Selectable { constructor(messageWindow: Window_Message); start(): void; updatePlacement(): void; /** * Returns the window width. * * @returns {number} * @memberof Window_NumberInput */ windowWidth(): number; /** * Returns the window height. * * @returns {number} * @memberof Window_NumberInput */ windowHeight(): number; /** * Returns the item width. * * @returns {number} * @memberof Window_NumberInput */ itemWidth(): number; /** * Creates the number input window buttons. * * @memberof Window_NumberInput */ createButtons(): void; /** * Places the number input window buttons. * * @memberof Window_NumberInput */ placeButtons(): void; updateButtonsVisiblity(): void; showButtons(): void; hideButtons(): void; buttonY(): number; processDigitChange(): void; changeDigit(up: boolean): void; onButtonUp(): void; onButtonDown(): void; onButtonOk(): void; } declare class Window_Options extends Window_Command { constructor(); updatePlacement(): void; addGeneralOptions(): void; addVolumeOptions(): void; statusWidth(): number; statusText(index: number): string; isVolumeSymbol(symbol: string): boolean; booleanStatusText(value: boolean): string; volumeStatusText(value: number): string; volumeOffset(): number; changeValue(symbol: string, value: boolean | number): void; getConfigValue(symbol: string): boolean; setConfigValue(symbol: string, volume: boolean | number): void; } /** * ----------------------------------------------------------------------------- * Window_PartyCommand * * The window for selecting whether to fight or escape on the battle screen. * @class Window_PartyCommand */ declare class Window_PartyCommand extends Window_Command { constructor(); setup(): void; } declare namespace rm.windows { export type Info = { key: string; } } declare class Window_SavefileList extends Window_Selectable { constructor(x: number, y: number, width: number, height: number); /** * Sets the mode of the save file window. * * @param {string} mode * @memberof Window_SavefileList */ setMode(mode: string): void; /** * Returns the maximum number of visible items. * * @returns {number} * @memberof Window_SavefileList */ maxVisibleItems(): number; itemHeight(): number; /** * Draws the file id at the specified x and y coordinates. * * @param {number} id * @param {number} x * @param {number} y * @memberof Window_SavefileList */ drawFileId(id: number, x: number, y: number): void; drawContents(info: rm.windows.Info, rect: Rectangle, valid: boolean): void; drawGameTitle(info: rm.windows.Info, x: number, y: number, width: number): void; drawPartyCharacters(info: rm.windows.Info, x: number, y: number): void; /** * Draws the current playtime at the specified x and y coordinates within the given * width. * @param {{key: string}} info * @param {number} x * @param {number} y * @param {number} width * @memberof Window_SavefileList */ drawPlaytime(info: rm.windows.Info, x: number, y: number, width: number): void; } /** * ----------------------------------------------------------------------------- * Window_ScrollText * * The window for displaying scrolling text. No frame is displayed, but it * is handled as a window for convenience. * @class Window_ScrollText */ declare class Window_ScrollText extends Window_Base { constructor(); /** * Starts the displaying of a message in the scroll text window. * * @memberof Window_ScrollText */ startMessage(): void; refresh(): void; updateMessage(): void; scrollSpeed(): number; /** * Returns true if the scene is in fast forward mode. * * @returns {boolean} * @memberof Window_ScrollText */ isFastForward(): boolean; /** * Returns the fast forward rate of the scroll text window. * * @returns {number} * @memberof Window_ScrollText */ fastForwardRate(): number; /** * Terminates the message and the scroll text window is hidden. * * @memberof Window_ScrollText */ terminateMessage(): void; } /** * ----------------------------------------------------------------------------- * Window_ShopBuy * * The window for selecting an item to buy on the shop screen. * @class Window_ShopBuy */ declare class Window_ShopBuy extends Window_Selectable { /** * Creates an instance of Window_ShopBuy. * @param {number} x * @param {number} y * @param {number} height * @param {Array>} shopGoods * @memberof Window_ShopBuy */ constructor(x: number, y: number, height: number, shopGoods: any[][]); /** * Returns the width of the window. * * @returns {number} * @memberof Window_ShopBuy */ windowWidth(): number; /** * Returns the current item of the window. * * @returns {RPG.BaseItem} * @memberof Window_ShopBuy */ item(): rm.types.BaseItem; setMoney(money: number): void; /** * Returns the p rice of an item * @param item * @return Int */ price(item: rm.types.BaseItem): number; /** * Checks if the current item is enabled (can be bought/sold). * * @param {RPG.BaseItem} item * @returns {boolean} * @memberof Window_ShopBuy */ isEnabled(item: rm.types.BaseItem): boolean; /** * Creates a list of items for the shop window. * * @memberof Window_ShopBuy */ makeItemList(): void; /** * Sets the status window for the shop buy window. * @param statusWindow */ setStatusWindow(statusWindow: Window_ShopStatus): void; } /** * ----------------------------------------------------------------------------- * Window_ShopCommand * * The window for selecting buy/sell on the shop screen. * @class Window_ShopCommand */ declare class Window_ShopCommand extends Window_HorzCommand { protected constructor(); _purchaseOnly: boolean; /** * Determines the width of the shop buy/sell window; * also determines if the shop is purchase only. * @param {number} width * @param {boolean} purchaseOnly * @memberof Window_ShopCommand */ initialize(width: number, purchaseOnly: boolean): void; } /** * ----------------------------------------------------------------------------- * Window_ShopNumber * * The window for inputting quantity of items to buy or sell on the shop * screen. * @class Window_ShopNumber */ declare class Window_ShopNumber extends Window_Selectable { /** * Creates an instance of Window_ShopNumber. * @param {number} x * @param {number} y * @param {number} height * @memberof Window_ShopNumber */ constructor(x: number, y: number, height: number); /** * Returns the width of the window. * * @returns {number} * @memberof Window_ShopNumber */ windowWidth(): number; number(): number; setup(item: rm.types.BaseItem, max: number, price: number): void; setCurrencyUnit(currencyUnit: string): void; createButtons(): void; placeButtons(): void; updateButtonsVisiblity(): void; /** * Shows the quantity input buttons. * * @memberof Window_ShopNumber */ showButtons(): void; /** * Hides the quantity input buttons. * * @memberof Window_ShopNumber */ hideButtons(): void; drawMultiplicationSign(): void; /** * Draws the number. */ drawNumber(): void; /** * Draws the total price of the selected * quantity of item. * @memberof Window_ShopNumber */ drawTotalPrice(): void; /** * Item y position. * @return Int */ itemY(): number; /** * Y position of the price. * @return Int */ priceY(): number; /** * Y position of the button. * @return Int */ buttonY(): number; /** * Returns the width of the cursor. * * @returns {number} * @memberof Window_ShopNumber */ cursorWidth(): number; /** * Cursor x position. * @return Int */ cursorX(): number; /** * The max number of digits for the shop number display * window. */ maxDigits(): number; /** * Processes the change in quantity. * * @memberof Window_ShopNumber */ processNumberChange(): void; /** * Changes the quantity, given a number. * * @param {number} amount * @memberof Window_ShopNumber */ changeNumber(amount: number): void; /** * Handle for button up event. */ onButtonUp(): void; /** * Handler for button up event 2. */ onButtonUp2(): void; /** * Handler for button down event. */ onButtonDown(): void; /** * Handler for button down event. */ onButtonDown2(): void; /** * Handler for button ok event. */ onButtonOk(): void; } /** * ----------------------------------------------------------------------------- * Window_ShopSell * * The window for selecting an item to sell on the shop screen. * @class Window_ShopSell */ declare class Window_ShopSell extends Window_ItemList { constructor(x: number, y: number, width: number, height: number); /** * Determines if the item is sellable, otherwise, greyed out. * * @param {RPG.BaseItem} item * @returns {boolean} * @memberof Window_ShopSell */ isEnabled(item: rm.types.BaseItem): boolean; } declare namespace rm.types { export const enum EquipTypeId { base = -1, } } /** * ----------------------------------------------------------------------------- * Window_ShopStatus * * The window for displaying number of items in possession and the actor's * equipment on the shop screen. * @class Window_ShopStatus */ declare class Window_ShopStatus extends Window_Base { /** * Creates an instance of Window_ShopStatus. * @param {number} x * @param {number} y * @param {number} width * @param {number} height * @memberof Window_ShopStatus */ constructor(x: number, y: number, width: number, height: number); /** * Refreshes the window contents. * * @memberof Window_ShopStatus */ refresh(): void; /** * Sets the item in the window shop status for display. */ setItem(item: rm.types.BaseItem): void; /** * Returns true if the item in the * shop status window is an equippable item. */ isEquipItem(): boolean; drawPossession(x: number, y: number): void; /** * Draw Equip Information. */ drawEquipInfo(x: number, y: number): void; statusMembers(): Game_Actor[]; /** * Returns the page size. * * @returns {number} * @memberof Window_ShopStatus */ pageSize(): number; /** * Returns the max number of pages. * * @returns {number} * @memberof Window_ShopStatus */ maxPages(): number; drawActorEquipInfo(x: number, y: number, actor: Game_Actor): void; drawActorParamChange(x: number, y: number, actor: Game_Actor, item1: rm.types.EquipItem): void; /** * Returns the parameter id. * * @returns {number} * @memberof Window_ShopStatus */ paramId(): number; /** * Returns the current item equiped by the given actor when * the respective equipment Id is passed. * @param {Game_Actor} actor * @param {number} etypeId * @returns {RPG.EquipItem} * @memberof Window_ShopStatus */ currentEquippedItem(actor: Game_Actor, etypeId: rm.types.EquipTypeId): rm.types.EquipItem; /** * Updates the current page. * * @memberof Window_ShopStatus */ updatePage(): void; /** * Determines if page can be changed. * * @returns {boolean} * @memberof Window_ShopStatus */ isPageChangeEnabled(): boolean; isPageChangeRequested(): boolean; /** * Determines if the window is touched within it's frame. * * @returns {boolean} * @memberof Window_ShopStatus */ isTouchedInsideFrame(): boolean; /** * Changes the current page. * * @memberof Window_ShopStatus */ changePage(): void; } /** * ----------------------------------------------------------------------------- * Window_SkillStatus * * The window for displaying the skill user's status on the skill screen. * @class Window_SkillStatus */ declare class Window_SkillStatus extends Window_Base { /** * Creates an instance of Window_SkillStatus. * @param x * @param y * @param width * @param height * @memberof Window_SkillStatus */ constructor(x: number, y: number, width: number, height: number); /** * Sets the current actor for the window. * * @param {Game_Actor} actor * @memberof Window_SkillStatus */ setActor(actor: Game_Actor): void; /** * Refreshes the window contents. * * @memberof Window_SkillStatus */ refresh(): void; } /** * ----------------------------------------------------------------------------- * Window_SkillType * * The window for selecting a skill type on the skill screen. * @class Window_SkillType */ declare class Window_SkillType extends Window_Command { /** * Creates an instance of Window_SkillType. * @param x * @param y * @memberof Window_SkillType */ constructor(x: number, y: number); /** * Sets the current actor for the skill type window. * * @param {Game_Actor} actor * @memberof Window_SkillType */ setActor(actor: Game_Actor): void; /** * Sets the skill window for the current skill type. * * @param {Window_SkillList} skillWindow * @memberof Window_SkillType */ setSkillWindow(skillWindow: Window_SkillList): void; /** * Selects the last command in the window. * * @memberof Window_SkillType */ selectLast(): void; } declare class Window_Status extends Window_Selectable { constructor(x: number, y: number, width: number, height: number); initialize(x: number, y: number, width: number, height: number): void; /** * Sets the skill type id of the skill list window. * * @param {number} stypeId * @memberof Window_SkillList */ setStypeId(stypeId: number): void; /** * Returns the current skill from the databse. * * @returns {RPG.Skill} * @memberof Window_SkillList */ item(): rm.types.Skill; /** * Returns true if the given skill is included. * * @param {RPG.Skill} item * @returns {boolean} * @memberof Window_SkillList */ includes(item: rm.types.Skill): boolean; /** * Returns true if the given skill is enabled. * * @param {RPG.Skill} item * @returns {boolean} * @memberof Window_SkillList */ isEnabled(item: rm.types.Skill): boolean; /** * Creates the item list. * * @memberof Window_SkillList */ makeItemList(): void; selectLast(): void; costWidth(): number; drawSkillCost(skill: rm.types.Skill, x: number, y: number, width: number): void; /** * Sets the current actor of the skill list window. * * @param {Game_Actor} actor * @memberof Window_SkillList */ setActor(actor: Game_Actor): void; } /** * ----------------------------------------------------------------------------- * Window_TitleCommand * * The window for selecting New Game/Continue on the title screen. * @class Window_TitleCommand */ declare class Window_TitleCommand extends Window_Command { protected constructor(); updatePlacement(): void; isContinueEnabled(): boolean; initCommandPosition(): void; selectLast(): void; } interface AttackMotion { /** * The type of the motion. */ type: number; /** * The ID of the weapon image. */ weaponImageId: number; } interface Terms { /** * The basic status. A string array with the following subscripts: * * 0: Level * 1: Level (short) * 2: HP * 3: HP (short) * 4: MP * 5: MP (short) * 6: TP * 7: TP (short) * 8: EXP * 9: EXP (short) */ basic: Array; /** * Parameters. A string array with the following subscripts: * * 0: Maximum hit points * 1: Maximum magic points * 2: Attack power * 3: Defense power * 4: Magic attack power * 5: Magic defense power * 6: Agility * 7: Luck * 8: Hit * 9: Evasion */ params: Array; /** * 0: Fight * 1: Escape * 2: Attack * 3: Defend * 4: Item * 5: Skill * 6: Equip * 7: Status * 8: Sort * 9: Save * 10: Exit Game * 11: Option * 12: Weapon * 13: Armor * 14: Key Item * 15: Change Equipment * 16: Ultimate Equipment * 17: Remove All * 18: New Game * 19: Continue * 20: (not used) * 21: Go to Title * 22: Cancel * 23: (not used) * 24: Buy * 25: Sell */ commands: Array; /** * The messages. */ messages: { [key: string]: string }; } interface TestBattler { /** * The actor ID. */ actorId: number; /** * The actor's level. */ level: number; /** * The actor's equipment. An array of weapon IDs or armor IDs with the following subscripts: * * 0: Weapon * 1: Shield * 2: Head * 3: Body * 4: Accessory */ equips: Array; } type MapInfo = { /** * The map name. */ name: string; /** * The parent map ID. */ parentId: number; /** * The map tree display order, which is used internally. */ order: number; } interface MetaData { /** * The text of the note. */ note: string; /** * The Meta. */ meta: { [key: string]: any }; } /** * The data class for maps. */ interface Map extends MetaData { /** * The map's display name. */ displayName: string; /** * The map's tile set. */ tilesetId: number; /** * The map's width. */ width: number; /** * The map's height. */ height: number; /** * The scroll type (0: No Loop, 1: Vertical Loop, 2: Horizontal Loop, 3: Both Loop). */ scrollType: number; /** * The truth value indicating whether the battle background specification is enabled. */ specifyBattleback: boolean; /** * The file name of the floor graphic if the battle background specification is enabled. */ battleback1Name: string; /** * The file name of the wall graphic if the battle background specification is enabled. */ battleback2_name: string; /** * The truth value indicating whether BGM autoswitching is enabled. */ autoplayBgm: boolean; /** * The name of that BGM (RPG.AudioFile) if BGM autoswitching is enabled. */ bgm: rm.types.AudioFile; /** * The truth value indicating whether BGS autoswitching is enabled. */ autoplayBgs: boolean; /** * The name of that BGS (RPG.AudioFile) if BGS autoswitching is enabled. */ bgs: rm.types.AudioFile; /** * The truth value of the [Disable Dashing] option. */ disableDashing: boolean; /** * An encounter list. A RPG.Map.Encounter ID array. */ encounterList: Array; /** * The average number of steps between encounters. */ encounterStep: number; /** * The file name of the parallax background's graphic. */ parallaxName: string; /** * The truth value of the [Loop Horizontal] option for the parallax background. */ parallaxLoopX: boolean; /** * The truth value of the [Loop Vertical] option for the parallax background. */ parallaxLoopY: boolean; /** * The automatic x-axis scrolling speed for the parallax background. */ parallaxSx: number; /** * The automatic y-axis scrolling speed for the parallax background. */ parallaxSy: number; /** * The truth value of the [Show in the Editor] option for the parallax background. */ parallaxShow: boolean; /** * The map data. A 3-dimensional tile ID array (Table). */ data: Array; /** * The array of RPG.Event data. */ events: Array; } interface System { /** * The game title. */ gameTitle: string; /** * A random number used for update checks. The number changes every time data is saved in RPG Maker. */ versionId: number; /** * The locale string such as "ja_JP" and "en_US". */ locale: string; /** * The initial party. An array of actor IDs. */ partyMembers: Array; /** * The unit of currency. */ currencyUnit: string; /** * The window color. */ windowTone: Array; /** * The array of System.AttackMotion data. */ attackMotions: Array; /** * A list of elements. A string array using element IDs as subscripts, with the element in the 0 position being nil. */ elements: Array; /** * he equipment type. A string array with the following subscripts: * 1: Weapon * 2: Shield * 3: Head * 4: Body * 5: Accessory */ equipTypes: Array; /** * A list of skill types. A string array using skill type IDs as subscripts, with the element in the 0 position being nil. */ skillTypes: Array; /** * A list of weapon types. A string array using weapon type IDs as subscripts, with the element in the 0 position being nil. */ weaponTypes: Array; /** * A list of armor types. A string array using armor type IDs as subscripts, with the element in the 0 position being nil. */ armorTypes: Array; /** * A switch name list. A string array using switch IDs as subscripts, with the element in the 0 position being nil. */ switches: Array; /** * A variable name list. A string array using variable IDs as subscripts, with the element in the 0 position being nil. */ variables: Array; /** * Boat settings (RPG.System.Vehicle). */ boat: rm.types.SystemVehicle; /** * Ship settings (RPG.System.Vehicle). */ ship: rm.types.SystemVehicle; /** * Airship settings (RPG.System.Vehicle). */ airship: rm.types.SystemVehicle; /** * The file name of the title (background) graphic. */ title1Name: string; /** * The file name of the title (frame) graphic. */ title2Name: string; /** * The truth value of the [Draw Game Title] option. */ optDrawTitle: boolean; /** * The truth value of the [Start Transparent] option. */ optTransparent: boolean; /** * The truth value of the [Show Player Followers] option. */ optFollowers: boolean; /** * The truth value of the [K.O. by Slip Damage] option. */ optSlipDeath: boolean; /** * The truth value of the [K.O. by Floor Damage] option. */ optFloorDeath: boolean; /** * The truth value of the [Display TP in Battle] option. */ optDisplayTp: boolean; /** * The truth value of the [Reserve Members' EXP] option. */ optExtraExp: boolean; /** * The truth value of the [use side-view battle] option. */ optSideView: boolean; /** * The title BGM (RPG.AudioFile). */ titleBgm: rm.types.AudioFile; /** * The battle BGM (RPG.AudioFile). */ battleBgm: rm.types.AudioFile; /** * The battle end ME (RPG.AudioFile). */ battleEndMe: rm.types.AudioFile; /** * The gameover ME (RPG.AudioFile). */ gameoverMe: rm.types.AudioFile; /** * Sound effects. An RPG.SE array. */ sounds: Array; /** * The map ID of the player's initial position. */ startMapId: number; /** * The map's x-coordinate of the player's initial position. */ startX: number; /** * The map's y-coordinate of the player's initial position. */ startY: number; /** * Terms (RPG.System.Terms). */ terms: Terms; /** * Party settings for battle tests. An RPG.System.TestBattler array. */ testBattlers: Array; /** * The enemy troop ID for battle tests. */ testTroopId: number; /** * The file name of the battle background (floor) graphic for use in editing enemy troops and battle tests. */ battleback1Name: string; /** * The file name of the battle background (wall) graphic for use in editing enemy troops and battle tests. */ battleback2Name: string; /** * The battler graphic file name for use in editing animations. */ battlerName: string; /** * The adjustment value for the battler graphic's hue (0..360) for use in editing animations. */ battlerHue: number; /** * The ID of the map currently being edited. For internal use. */ editMapId: number; } /** @global RPGMaker Plugin's Object */ declare var $plugins: Array; /** @global RPGMakerMV Actor data. */ declare var $dataActors: Array; /** @global RPGMakerMV Class data. */ declare var $dataClasses: Array; /** @global RPGMakerMV Skill data. */ declare var $dataSkills: Array; /** @global RPGMakerMV Item data. */ declare var $dataItems: Array; /** @global RPGMakerMV Weapon data. */ declare var $dataWeapons: Array; /** @global RPGMakerMV Armor data. */ declare var $dataArmors: Array; /** @global RPGMakerMV Enemy data. */ declare var $dataEnemies: Array; /** @global RPGMakerMV Troop data. */ declare var $dataTroops: Array; /** @global RPGMakerMV State data. */ declare var $dataStates: Array; /** @global RPGMakerMV Animation data. */ declare var $dataAnimations: Array; /** @global RPGMakerMV Tileset data. */ declare var $dataTilesets: Array; /** @global RPGMakerMV CommonEvent data. */ declare var $dataCommonEvents: Array; /** @global RPGMakerMV System data. */ declare var $dataSystem: System; /** @global RPGMakerMV MapInfo data. */ declare var $dataMapInfos: Array; /** @global RPGMakerMV Map data for the current map. */ declare var $dataMap: Map; /** @global RPGMakerMV Temporary game data; not saved with the game. */ declare var $gameTemp: Game_Temp; /** @global RPGMakerMV Game System data; saved with the game. * @type {Game_Temp} */ declare var $gameSystem: Game_System; /** @global RPGMakerMV Game Screen; contains properties and methods * for adjusting the game screen. * @type {Game_Screen} */ declare var $gameScreen: Game_Screen; declare var $gameTimer: Game_Timer; /** @global RPGMakerMV Game Message; contains properties and methods * for displaying messages in the game message window. * @type {Game_Message} */ declare var $gameMessage: Game_Message; /** @global RPGMakerMV Game Switches; contains properties and methods * for modifying in game switches while the game is running. * These are boolean values: true or false. * @type {Game_Switches} */ declare var $gameSwitches: Game_Switches; /** @global RPGMakerMV Game Variables; contains properties and methods * for modifying the values of game variables. * The variables can contain anything. * @type {Game_Variables} */ declare var $gameVariables: Game_Variables; declare var $gameSelfSwitches: Game_SelfSwitches; declare var $gameActors: Game_Actors; /** @global RPGmakerMV Game Party; contains properties and methods * for interacting with the game party. Some of the methods include * number of party members, etc. * @type {Game_Party} */ declare var $gameParty: Game_Party; /** @global RPGMakerMV Game Troop; contains properties and methods * for interacting with the game troops. Some of the methods include * enemy data, enemy names, etc. * @type {Game_Troop} */ declare var $gameTroop: Game_Troop; /** @global RPGMakerMV Game Map; contains properties and methods * for interacting with the game map. Some of these methods include * interacting with the map's game_interpreter, and event information. * @type {Game_Map} */ declare var $gameMap: Game_Map; /** @global RPGMakerMV Game Player; contains properties and methods * for interacting with the game player. Some of these methods * include interacting with the player's position and move route. * @type {Game_Player} */ declare var $gamePlayer: Game_Player; declare var $testEvent: Array;