Options
All
  • Public
  • Public/Protected
  • All
Menu

toupie

Index

Enumerations

Classes

Type Aliases

Variables

Functions

Type Aliases

Game

Game: { render?: any; stop?: any; update: any }

Run the main loop.

Type declaration

  • render?:function
    • render(): void

    • Returns void

  • stop?:function
    • stop(): void

    • Returns void

  • update:function
    • update(number: any): void

    • Parameters

      • number: any

      Returns void

GamepadAxisMapping

GamepadAxisMapping: { index: number; inverse: boolean; type: "axis" } | { index: number; indexNegative?: number; type: "button" }

GamepadButtonMapping

GamepadButtonMapping: { index: number; type: "button" } | { direction: -1 | 1; index: number; type: "axis" }

GamepadMapping

GamepadMapping: { axes: Map<string, GamepadAxisMapping>; buttons: Map<string, GamepadButtonMapping>; supported: { browser: string; id: string; os: string }[] }

Gamepad mapping

Type declaration

ToupieEventHandler

ToupieEventHandler: ((...args: any) => undefined)

Type declaration

    • (...args: any): undefined

    • A general function type for handling custom events

      Parameters

      • Rest ...args: any

      Returns undefined

Variables

Const HALF_PI

HALF_PI: number = ...

Const PI

PI: number = Math.PI

Const TWO_PI

TWO_PI: number = ...

Const arrowMappings

arrowMappings: { : KeyType[][]; hjkl: KeyType[][]; ijkl: KeyType[][]; wasd: KeyType[][]; zqsd: KeyType[][] } = ...

Type declaration

Const dirIndex

dirIndex: { DOWN: number; LEFT: number; RIGHT: number; UP: number } = ...

Type declaration

  • DOWN: number
  • LEFT: number
  • RIGHT: number
  • UP: number

Functions

attr

  • attr(element: HTMLElement, attributeName: string, value?: any): string

  • Parameters

    • element: HTMLElement
    • attributeName: string
    • Optional value: any

    Returns string

chunk

  • chunk(arr: unknown[], chunkSize: number): any[]

  • Split an array into chunks of constant sizes.

    Parameters

    • arr: unknown[]

      array

    • chunkSize: number

      size of chunks

    Returns any[]

circleInCircle

  • circleInCircle(c1: Vec2, r1: number, c2: Vec2, r2: number): boolean

  • circle in circle collision detection

    Parameters

    • c1: Vec2

      center of first circle

    • r1: number

      radius of first circle

    • c2: Vec2

      center of second circle

    • r2: number

      radius of second circle

    Returns boolean

    true if circles are overlapping

circleInRect

  • circleInRect(c: Vec2, radius: number, r: Rect): any

  • Circle in Rectangle collision detection

    Parameters

    • c: Vec2
    • radius: number

      of the circle

    • r: Rect

      rectangle

    Returns any

clamp

  • clamp(num: number, a: number, b: number): number

  • clamp num between a and b

    Parameters

    • num: number
    • a: number
    • b: number

    Returns number

clearPersistent

  • clearPersistent(name?: string): void

  • Remove on or all records from the local storage.

    Parameters

    • Optional name: string

    Returns void

crc32

  • crc32(str: string): number

  • Parameters

    • str: string

    Returns number

el

  • el(selector: string, isSvg?: boolean): any

  • Create a new DOM element

    Parameters

    • selector: string

      CSS style selector

    • isSvg: boolean = false

      if true, create a SVG element

    Returns any

emit

  • emit(element: EventTarget, event: string | Event, details: object): Event

  • Parameters

    • element: EventTarget
    • event: string | Event
    • details: object

    Returns Event

frag

  • frag(): DocumentFragment

  • Create a new document fragment.

    Returns DocumentFragment

gamepadAvailable

  • gamepadAvailable(): boolean

  • Returns boolean

    true if the browser supports gamepads

isTouchscreen

  • isTouchscreen(): boolean

  • Returns boolean

    true if the device have touch screen capabilities

loadPersistent

  • loadPersistent(name: string): object | null

  • Load an object from local storage. If the name is not available in local storage, return null.

    Parameters

    • name: string

    Returns object | null

on

  • on(element: EventTarget, type: string, handler: EventListenerOrEventListenerObject): (() => void)

  • Setup an event listener.

    Parameters

    • element: EventTarget
    • type: string

      event type

    • handler: EventListenerOrEventListenerObject

      event handler

    Returns (() => void)

      • (): void

      • Returns void

pointInCircle

  • pointInCircle(p: Vec2, c: Vec2, r: number): boolean

  • point in circle collision check

    Parameters

    • p: Vec2

      point

    • c: Vec2

      center of circle

    • r: number

    Returns boolean

    true if point is inside circle

pointInRect

  • point in rectangle check detection

    Parameters

    Returns boolean

qs

  • qs(selectors: string, ctx?: Document): Element

  • Wrapper to querySelector.

    Parameters

    • selectors: string
    • ctx: Document = doc

      default to document

    Returns Element

qsa

  • qsa(selectors: string, ctx?: Document): NodeListOf<Element>

  • Wrapper to querySelectorAll.

    Parameters

    • selectors: string
    • ctx: Document = doc

      default to document

    Returns NodeListOf<Element>

random

  • random(a?: number, b?: number): number

  • return a random float between min and max

    Parameters

    • a: number = 0
    • b: number = 1

    Returns number

randomInt

  • randomInt(a?: number, b?: number): number

  • return a random integer between a and b included

    example
    import { randomInt } from "toupie"
    const res = randomInt(1, 6) + randomInt(1, 6)  // roll 2d6

    Parameters

    • a: number = 0

      default to 0

    • b: number = 1

      default to 1

    Returns number

ready

  • ready(app: any): void

  • Check if the context is ready and call app.

    Parameters

    • app: any

      called when context is ready.

    Returns void

rectInRect

  • AABB rectangle in rectangle overlap detection

    Parameters

    • r1: Rect

      left side of first rectangle

    • r2: Rect

      top side of first rectangle

    Returns boolean

resolveCollision

  • resolve 2d rect vs rect collision

    Parameters

    • r1: any
    • r2: any

    Returns CollisionSide

run

  • run(game: Game): (() => void)

  • Setup a game and run its main loop.

    Parameters

    Returns (() => void)

      • (): void

      • Setup a game and run its main loop.

        Returns void

savePersistent

  • savePersistent(name: string, data: object): void

  • Save an object in local storage.

    Parameters

    • name: string
    • data: object

    Returns void

shuffle

  • shuffle(arr: unknown[]): unknown[]

  • Randomly shuffle elements of an array in place.

    Parameters

    • arr: unknown[]

      array

    Returns unknown[]

style

  • style(element: HTMLElement, styleObj: CSSStyleDeclaration): CSSStyleDeclaration

  • Set style of an element.

    Parameters

    • element: HTMLElement

      element whose style should be set

    • styleObj: CSSStyleDeclaration

    Returns CSSStyleDeclaration

unique

  • unique(arr: unknown[]): unknown[]

  • Copy the array without duplicates

    Parameters

    • arr: unknown[]

    Returns unknown[]

Generated using TypeDoc