mwg API
    Preparing search index...

    Class MessageBox

    The dialogue box.

    It reveals text a character at a time, advances page by page on confirm, and can end on a set of choices. Pressing confirm while text is still appearing completes the page instead of advancing: the behaviour every player expects, and the reason the reveal is driven by a character count rather than by animating the label.

    This is the one window that is not closable by cancel: a conversation ends when it ends, or a cutscene would be left half-run. It swallows clicks for the same reason, and because it is not closable that can only ever swallow them: a click under the box does not move the player or open something, it does nothing at all.

    import { MessageBox } from '@datamoc/mwg/two-d/ui';

    const box = new MessageBox({
    	width: 400,
    	height: 120,
    	pages: [
    		{ text: 'The old door creaks open. {sound:door-creak.wav}' },
    		{ speaker: 'Guard', text: 'Who goes there?' },
    	],
    	choices: [{ text: 'A friend' }, { text: 'None of your business' }],
    	onDone: (chosen) => console.log('player answered', chosen),
    	onSound: (path) => console.log('play sound', path),
    });

    box.handleAction('confirm'); // reveals the rest of the first page instantly
    box.handleAction('confirm'); // advances to the second page

    Hierarchy (View Summary)

    Index
    constructor
    anchor closable content delegate dims modal onClose
    closed contentHeight contentWidth
    close destroy handleAction handleOutsideClick open place resize setColors setTitle update
    anchor: "top" | "center" | "bottom"
    closable: boolean

    Readonlycontent

    content: Container<ContainerChild> = ...
    delegate: { handleAction(action: string): boolean } | null = null

    A widget offered actions before the window itself sees them.

    Set it to the list or field the window exists to show. Without it, every window holding a widget has to override handleAction just to forward, which is noise at best and, done by assigning over the method, a trap.

    dims: boolean
    modal: boolean
    onClose: Signal<void> = ...
    • get closed(): boolean

      true once close() (or destroy()) has run. A closed window is spent: close() freed it and its contents through Pixi, so the caller's this.someWindow reference must not be written to any more. Guard with this rather than discovering it as a null-internal throw, and drop the reference.

      Returns boolean

    • get contentWidth(): number

      the space available inside the frame, which is what contents should lay out against

      Returns number

    • Announces the close and frees this window and its contents. Idempotent, so a second close() (a pop() racing a cancel, a closeAll() after a manual close) is a no-op rather than a second destroy. The instance is spent afterwards; see closed.

      With animation it plays the opening backwards first and closes when it ends (driven by update(dt)), unless reduced motion is on, when it closes at once.

      Parameters

      Returns void

    • Removes all internal references and listeners as well as removes children from the display list. Do not use a Container after calling destroy.

      Parameters

      • Optionaloptions: DestroyOptions

        Options parameter. A boolean will act as if all options have been set to that value

      Returns void

      container.destroy();
      container.destroy(true);
      container.destroy({ children: true });
      container.destroy({ children: true, texture: true, textureSource: true });

    • Offered every action while this window is on top of the stack.

      Parameters

      • action: string

      Returns boolean

      true if the window used it, which stops it going any further down

    • Offered a click that landed on the blocker, at x, y in this window's own coordinates (its top-left corner is 0, 0). A click outside the window closes it when it is closable - the pointer's answer to handleAction('cancel') - and a click on the window itself is swallowed without closing, so its frame and empty body are never a dismiss button.

      The blocker calls this for every click it takes, which is all a game usually needs; it is public because it is also the whole decision, and a headless test can ask it directly.

      Parameters

      • x: number
      • y: number

      Returns boolean

      true when the click closed the window

    • Plays the opening animation from the window's current position. The stack calls update(dt) on its top window, which drives it. Under reduced motion the window simply appears.

      Parameters

      Returns void

      import { Window } from '@datamoc/mwg/two-d/ui';

      const window = new Window({ width: 240, height: 120, title: 'Result' });
      window.open({ animation: 'pop' });
      window.update(0.25); // normally the WindowStack's update does this
      console.log(window.scale.x); // 1

    • positions the window in a viewport of the given size, per its anchor

      Parameters

      • viewportWidth: number
      • viewportHeight: number

      Returns void

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Accessors
    Methods