Class Game

constructor

• new Game(options?): Game

• Parameters

  • options: GameOptions = {}

  Returns Game

chats

client

data

events

history

id

options

level

• get level(): number

• Calculate the player's level based on their experience

  Returns number

overburdened

• get overburdened(): boolean

• Determine if the player is overburdened

  Returns boolean

weightCarried

• get weightCarried(): number

• Calculate the player's weight carried

  Returns number

action

• action(action): Promise<Game>

• Commit an action on the game

  Parameters

  • action: string

    The action to commit

  Returns Promise<Game>

chat

• chat(data): Promise<void>

• Send a chat message to a character

  Listen for game.events.on(GameEvent.chat) to get the response

  Parameters

  • data: {
        character: Character;
        dialog: string;
    }

    • character: Character

    • dialog: string

  Returns Promise<void>

  Todo

  Prune chat history to fit context window

export

• export(): {
      chats: Chat[];
      data: GameData;
      history: (ChatCompletionUserMessageParam | ChatCompletionMessage)[];
      id: string;
      options: GameOptions;
      tokens: number;
  }

• Export the game data object

  Returns {
      chats: Chat[];
      data: GameData;
      history: (ChatCompletionUserMessageParam | ChatCompletionMessage)[];
      id: string;
      options: GameOptions;
      tokens: number;
  }

  • chats: Chat[]

  • data: GameData

  • history: (ChatCompletionUserMessageParam | ChatCompletionMessage)[]

  • id: string

  • options: GameOptions

  • tokens: number

images

• images(__namedParameters?, imageOptions?): Promise<{
      ability?: Image;
      character?: Image;
      cover?: Image;
      item?: Image;
      player?: Image;
      scene?: Image;
  }>

• Create images of various game objects

  Call game.client.image to manually use any prompt

  Parameters

  • __namedParameters: {
        ability?: Ability;
        character?: Character;
        cover?: boolean;
        item?: InventoryItem;
        player?: boolean;
        scene?: boolean;
    } = {}

    • Optional ability?: Ability

    • Optional character?: Character

    • Optional cover?: boolean

    • Optional item?: InventoryItem

    • Optional player?: boolean

    • Optional scene?: boolean

  • Optional imageOptions: {
        ability?: GameClientImageOptions;
        character?: GameClientImageOptions;
        cover?: GameClientImageOptions;
        item?: GameClientImageOptions;
        player?: GameClientImageOptions;
        scene?: GameClientImageOptions;
    }

    • Optional ability?: GameClientImageOptions

    • Optional character?: GameClientImageOptions

    • Optional cover?: GameClientImageOptions

    • Optional item?: GameClientImageOptions

    • Optional player?: GameClientImageOptions

    • Optional scene?: GameClientImageOptions

  Returns Promise<{
      ability?: Image;
      character?: Image;
      cover?: Image;
      item?: Image;
      player?: Image;
      scene?: Image;
  }>

import

• import(data): void

• Import a game data object

  Parameters

  • data: any

  Returns void

init

• init(): Promise<void>

• Initialize a new game

  Returns Promise<void>

inspect

• inspect(): string

• Inspect the game data

  Returns string

off

• off(event, listener): void

• Stop listening for game events

  Parameters

  • event: GameEvent

  • listener: ((...args) => void)

    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns void

on

• on(event, listener): void

• Listen for game events

  Parameters

  • event: GameEvent

  • listener: ((...args) => void)

    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns void

resolvePath

• resolvePath(obj, path): {
      value: any;
  }

• Resolve a path in the game data

  Parameters

  • obj: any

  • path: string

  Returns {
      value: any;
  }

  • get value(): any

  • set value(newValue: any): void

set

• set(key, value): void

• Manually set a value in the game data

  Parameters

  • key: string

  • value: any

  Returns void