Interface Utilities

Hierarchy

  • Utilities

Properties

chat color filter serialize

Properties

chat

chat: {
    generateTitle: ((p: Player, message: string) => string);
    removeColorTags: ((input: string) => string);
    validateMessage: ((p: Player, message: string) => boolean);
}

Type declaration

  • generateTitle: ((p: Player, message: string) => string)
      • (p: Player, message: string): string

      • Parameters

        Returns string

  • removeColorTags: ((input: string) => string)
      • (input: string): string

      • Parameters

        • input: string

        Returns string

  • validateMessage: ((p: Player, message: string) => boolean)
      • (p: Player, message: string): boolean

      • Parameters

        Returns boolean

color

color: {
    convertRGB: ((r: number, g: number, b: number) => number[]);
    hexToDec: ((hex: string, bgr?: boolean) => string);
    hexToRGB: ((hex: string) => number[]);
    randomHexColor: (() => string);
    rgbToBgr: ((rgb: string) => string);
    rgbToDec: ((r: number, g: number, b: number) => string);
    rgbToHex: ((r: number, g: number, b: number) => string);
}

Type declaration

  • convertRGB: ((r: number, g: number, b: number) => number[])
      • (r: number, g: number, b: number): number[]

      • Parameters

        • r: number
        • g: number
        • b: number

        Returns number[]

  • hexToDec: ((hex: string, bgr?: boolean) => string)
      • (hex: string, bgr?: boolean): string

      • Parameters

        • hex: string
        • bgr: boolean = false

        Returns string

  • hexToRGB: ((hex: string) => number[])
      • (hex: string): number[]

      • Parameters

        • hex: string

        Returns number[]

  • randomHexColor: (() => string)
      • (): string

      • Returns string

  • rgbToBgr: ((rgb: string) => string)
      • (rgb: string): string

      • Parameters

        • rgb: string

        Returns string

  • rgbToDec: ((r: number, g: number, b: number) => string)
      • (r: number, g: number, b: number): string

      • Parameters

        • r: number
        • g: number
        • b: number

        Returns string

  • rgbToHex: ((r: number, g: number, b: number) => string)
      • (r: number, g: number, b: number): string

      • Parameters

        • r: number
        • g: number
        • b: number

        Returns string

filter

filter: {
    addFilter: ((input: string) => void);
    getFilter: (() => string[]);
    isSwear: ((input: string) => boolean);
    setFilter: ((filter: string[]) => void);
}

Type declaration

  • addFilter: ((input: string) => void)
      • (input: string): void

      • Parameters

        • input: string

        Returns void

  • getFilter: (() => string[])
      • (): string[]

      • Returns string[]

  • isSwear: ((input: string) => boolean)
      • (input: string): boolean

      • Parameters

        • input: string

        Returns boolean

  • setFilter: ((filter: string[]) => void)
      • (filter: string[]): void

      • Parameters

        • filter: string[]

        Returns void

serialize

serialize: {
    deserialize: ((data: Buffer) => Brick[]);
    serialize: ((bricks: Brick[]) => Buffer);
}

Type declaration

  • deserialize: ((data: Buffer) => Brick[])
      • (data: Buffer): Brick[]

      • Parameters

        • data: Buffer

        Returns Brick[]

  • serialize: ((bricks: Brick[]) => Buffer)
      • (bricks: Brick[]): Buffer

      • A module used for serializing bricks into a storeable-data format.

        Can be used for saving user build creations.

        Example

        const MAP_DATABASE = new Enmap({
              name: "mapBuffer",
              autoFetch: true,
              fetchAll: false
          });

          // Save the data if it isn't already saved.
          if (!MAP_DATABASE.has("mapBuffer")) {
              console.log("Map not found, saving it ...")
              
              let { bricks } = Game.parseBrk("./maps/headquarters2.brk")

              let data = util.serialize.serialize(bricks)

              MAP_DATABASE.set("mapBuffer", data)
          }

          // Clear the map
          Game.clearMap()

          Game.on("initialSpawn", (p) => {
              let mapData = Buffer.from(MAP_DATABASE.get("mapBuffer"))

              mapData = util.serialize.deserialize(mapData)

              p.loadBricks(mapData)
          })

        Parameters

        Returns Buffer

Settings

Member Visibility

Theme