Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Battlefield

Hierarchy

  • EventEmitter
    • Battlefield

Index

Enumerations

Interfaces

Type aliases

Constructors

Properties

Methods

Object literals

Type aliases

Static BanList

BanList: BanEntry[]

Static BattlefieldVariables

BattlefieldVariables: VeniceUnleashedVariables | VanillaVariables

Static IdType

IdType: ["name" | "ip" | "guid", string]

Static MapList

MapList: MapEntry[]

Static PlayerList

PlayerList: Player[]

Static PlayerSubset

PlayerSubset: [Subset, undefined | string | number]

Static Subset

Subset: "all" | "team" | "squad" | "player"

Static Timeout

Timeout: ["perm" | "rounds" | "seconds", undefined | number]

Static VanillaVariables

VanillaVariables: "vars.ranked" | "vars.serverName" | "vars.gamePassword" | "vars.autoBalance" | "vars.friendlyFire" | "vars.maxPlayers" | "vars.serverDescription" | "vars.serverMessage" | "vars.killCam" | "vars.miniMap" | "vars.hud" | "vars.crossHair" | "vars.3dSpotting" | "vars.miniMapSpotting" | "vars.nametag" | "vars.3pCam" | "vars.regenerateHealth" | "vars.teamKillCountForKick" | "vars.teamKillValueForKick" | "vars.teamKillValueIncrease" | "vars.teamKillValueDecreasePerSecond" | "vars.teamKillKickForBan" | "vars.idleTimeout" | "vars.idleBanRounds" | "vars.roundStartPlayerCount" | "vars.roundRestartPlayerCount" | "vars.roundLockdownCountdown" | "vars.vehicleSpawnAllowed" | "vars.vehicleSpawnDelay" | "vars.soldierHealth" | "vars.playerRespawnTime" | "vars.playerManDownTime" | "vars.bulletDamage" | "vars.gameModeCounter" | "vars.onlySquadLeaderSpawn" | "vars.unlockMode" | "vars.premiumStatus" | "vars.gunMasterWeaponsPreset"

Static VeniceUnleashedVariables

VeniceUnleashedVariables: "vu.ColorCorrectionEnabled" | "vu.DesertingAllowed" | "vu.DestructionEnabled" | "vu.FadeInAll" | "vu.FadeOutAll" | "vu.FrequencyMode" | "vu.HighPerformanceReplication" | "vu.ServerBanner" | "vu.SpectatorCount" | "vu.SquadSize" | "vu.SunFlareEnabled" | "vu.SuppressionMultiplier" | "vu.VehicleDisablingEnabled" | "vu.TimeScale"

Constructors

constructor

Properties

Private abortReconnectAction

abortReconnectAction: boolean = false

Private closeHandler

closeHandler: onClose = this.onClose.bind(this)

Private errorHandler

errorHandler: (...args: A) => R = this.emit.bind(this, "error")

Type declaration

    • (...args: A): R

    • Parameters

      • Rest ...args: A

      Returns R

Private isReconnecting

isReconnecting: boolean = false

Readonly options

options: Options

Private pbAddressCache

pbAddressCache: Record<string, string>

Private rcon

rcon: Rcon

Readonly var

var: Variable<Variables>

Readonly vu

vu: Variable<VuVariable>

Static defaultMaxListeners

defaultMaxListeners: number

Static Readonly errorMonitor

errorMonitor: unique symbol

This symbol shall be used to install a listener for only monitoring 'error' events. Listeners installed using this symbol are called before the regular 'error' listeners are called.

Installing a listener using this symbol does not change the behavior once an 'error' event is emitted, therefore the process will still crash if no regular 'error' listener is installed.

Methods

abortReconnect

  • abortReconnect(): void

addBan

  • addBan(type: IdType, timeout: Timeout, reason?: undefined | string, save?: boolean): Promise<unknown>

  • adding a new name/IP/GUID ban will replace any previous ban for that name/IP/GUID

    Parameters

    • type: IdType

      define wether its a guid, ip or name

    • timeout: Timeout
    • Optional reason: undefined | string

      displayed ban reason

    • Default value save: boolean = true

      save the list

    Returns Promise<unknown>

Private addEventHandler

  • addEventHandler(): void

addListener

  • addListener(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

addMap

  • addMap(map: string, mode: string, rounds?: number, index?: undefined | number, save?: boolean): Promise<unknown>

  • Adds the map , with gamemode , for rounds, to the maplist. If is not specified, it is appended to the end; otherwise, it is inserted before the map which is currently at position .

    Parameters

    • map: string
    • mode: string
    • Default value rounds: number = 2
    • Optional index: undefined | number
    • Default value save: boolean = true

    Returns Promise<unknown>

addMod

  • addMod(name: string): Promise<unknown>

  • Adds a mod to the list of mods to load on the next server restart and saves the changes to the ModList.txt file. This will not load the mod immediately.

    Parameters

    • name: string

      name of the mod to add

    Returns Promise<unknown>

addReservedSlot

  • addReservedSlot(name: string, save?: boolean): Promise<unknown>

  • Add player to VIP list

    Parameters

    • name: string

      player to add

    • Default value save: boolean = true

      save the list

    Returns Promise<unknown>

aggressiveJoin

  • aggressiveJoin(enable: boolean): Promise<unknown>

  • enable or disable aggressive join

    Parameters

    • enable: boolean

      wether it should be enabled or not

    Returns Promise<unknown>

clearBanList

  • clearBanList(save?: boolean): Promise<unknown>

  • clears ban list

    Parameters

    • Default value save: boolean = true

    Returns Promise<unknown>

clearMaps

  • clearMaps(save?: boolean): Promise<unknown>

  • clears the map list

    Parameters

    • Default value save: boolean = true

    Returns Promise<unknown>

clearMods

  • clearMods(): Promise<unknown>

  • Clears the list of mods to loads on the next server restart and saves the changes to the ModList.txt file. This will not unload any currently running mods.

    Returns Promise<unknown>

clearReservedSlots

  • clearReservedSlots(save?: boolean): Promise<unknown>

  • clears VIP list

    Parameters

    • Default value save: boolean = true

    Returns Promise<unknown>

connect

  • connect(forceReconnect?: boolean): Promise<this>

  • connects and initializes the query

    Parameters

    • Default value forceReconnect: boolean = true

    Returns Promise<this>

createCommand

debugExtensions

  • debugExtensions(toggle: boolean): Promise<unknown>

  • accepts a single boolean argument (true or false) which toggles debug mode for any loaded extensions when set to true, any scripts will be built with debug symbols enabled, which will make it so errors printed on the server and the clients will contain more useful information about their source.

    Parameters

    • toggle: boolean

    Returns Promise<unknown>

delBan

  • delBan(type: string[], save?: boolean): Promise<unknown>

  • Remove name/ip/guid from banlist

    Parameters

    • type: string[]

      id type to remove

    • Default value save: boolean = true

      save the list

    Returns Promise<unknown>

delMap

  • delMap(index: number, save?: boolean): Promise<unknown>

  • Removes the map at offset from the maplist

    Parameters

    • index: number
    • Default value save: boolean = true

    Returns Promise<unknown>

delMod

  • delMod(name: string): Promise<unknown>

  • Removes a mod from the list of mods to load on the next server restart and saves the changes to the ModList.txt file. This will not unload any currently running mods.

    Parameters

    • name: string

      name of the mod to remove

    Returns Promise<unknown>

delReservedSlot

  • delReservedSlot(name: string, save?: boolean): Promise<unknown>

  • Remove a player from the VIP list

    Parameters

    • name: string

      player to remove

    • Default value save: boolean = true

    Returns Promise<unknown>

effectiveMaxPlayers

  • effectiveMaxPlayers(): Promise<number>

emit

  • emit(event: string | symbol, ...args: any[]): boolean

  • Parameters

    • event: string | symbol
    • Rest ...args: any[]

    Returns boolean

enableEvents

  • enableEvents(set: boolean): Promise<unknown>

  • Set whether or not the server will send events to the current connection

    Parameters

    • set: boolean

      enable or disable events

    Returns Promise<unknown>

endRound

  • endRound(winner: number): Promise<unknown>

  • dnd the current round, declaring as the winning team

    Parameters

    • winner: number

    Returns Promise<unknown>

Private eventHandler

  • eventHandler(event: string, words: Word[]): any

eventNames

  • eventNames(): Array<string | symbol>

  • Returns Array<string | symbol>

Private fetchVersion

  • fetchVersion(): Promise<{ game: Version; version: number }>

  • Game server type and build ID uniquely identify the server, and the protocol it is running.

    Returns Promise<{ game: Version; version: number }>

get

getAvailableMods

  • getAvailableMods(): Promise<string[]>

  • lists the mods that are available to be added to the mod list

    Returns Promise<string[]>

getBans

getMapIndices

  • getMapIndices(): Promise<{ index: number; next: number }>

  • returns the index of the map that is currently being played, and the index of the next map to run.

    Returns Promise<{ index: number; next: number }>

getMaps

  • getMaps(offset?: undefined | number): Promise<MapList>

  • Returns a section of the map list. At most 100 entries will be returned by the command. To retrieve the full list, perform several mapList.list calls with increasing offset until the server returns 0 entries. (There is an unsolved synchronization problem hidden there: if the map list is edited by another RCON client during this process, then entries may be missed during retrieval. There is no known workaround for this.)

    Parameters

    • Optional offset: undefined | number

    Returns Promise<MapList>

getMaxListeners

  • getMaxListeners(): number

  • Returns number

getMods

  • getMods(): Promise<string[]>

  • Lists the mods to load on the next server restart. This basically lists all mods present in the ModList.txt file and may not be the same as the list of mods that are currently running.

    Returns Promise<string[]>

Private getPasswordHash

  • getPasswordHash(password: string, hash: Buffer): string

  • creates the hashed password from the actual password and the hash

    Parameters

    • password: string
    • hash: Buffer

    Returns string

getPlayerByName

  • getPlayerByName(name: string): Promise<undefined | Player>

getPlayers

getPlayersByName

  • getPlayersByName(names: string[] | Record<string, string>): Promise<{}>

  • retrieves multiple players by their name

    Parameters

    • names: string[] | Record<string, string>

    Returns Promise<{}>

getReservedSlots

  • getReservedSlots(offset?: undefined | number): Promise<unknown>

  • return a section of the list of VIP players’ name

    Parameters

    • Optional offset: undefined | number

    Returns Promise<unknown>

getRounds

  • getRounds(): Promise<{ current: number; total: number }>

  • returns the (1-based) current round number, and total number of rounds before switching map.

    Returns Promise<{ current: number; total: number }>

getRunningMods

  • getRunningMods(): Promise<string[]>

Private getSalt

  • getSalt(): Promise<Buffer>

Private getScores

  • getScores(words: Word[]): { scores: number[]; targetScore: number }

  • Parameters

    Returns { scores: number[]; targetScore: number }

    • scores: number[]
    • targetScore: number

help

  • help(): Promise<unknown>

idleDuration

  • idleDuration(name: string): Promise<number>

  • gets the idle duration of a specific client in seconds

    Parameters

    • name: string

      name of the player to retrieve idle duration for

    Returns Promise<number>

Private initialize

  • initialize(): Promise<this>

listenerCount

  • listenerCount(event: string | symbol): number

  • Parameters

    • event: string | symbol

    Returns number

listeners

  • listeners(event: string | symbol): Function[]

  • Parameters

    • event: string | symbol

    Returns Function[]

loadBans

  • loadBans(): Promise<unknown>

loadMaps

  • loadMaps(): Promise<unknown>

loadReservedSlots

  • loadReservedSlots(): Promise<unknown>

Private login

  • login(password: string): Promise<string[]>

  • Securely logs you in with a hashed password

    Parameters

    • password: string

      password to login with

    Returns Promise<string[]>

logout

  • logout(): Promise<unknown>

nextRound

  • nextRound(): Promise<unknown>

  • switches immediately to the next round, without going through the end-of-round sequence.

    Returns Promise<unknown>

off

  • off(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

on

  • on(event: "close", handler: (err: Error | undefined) => void): this
  • on(event: "ready", handler: () => void): this
  • on(event: "error", handler: (error: Error) => void): this
  • on(event: "requestSend", handler: (data: RequestSend) => void): this
  • on(event: "requestReceive", handler: (data: RequestReceive) => void): this
  • on(event: "eventReceive", handler: (data: EventReceive) => void): this
  • on(event: "chat", handler: (data: Event.PlayerOnChat) => void): this
  • on(event: "spawn", handler: (data: PlayerOnSpawn) => void): this
  • on(event: "kill", handler: (data: PlayerOnKill) => void): this
  • on(event: "punkbuster", handler: (data: PunkBuster) => void): this
  • on(event: "playerAuthenticated", handler: (data: OnAuthenticated) => void): this
  • on(event: "playerJoin", handler: (data: OnJoining) => void): this
  • on(event: "playerLeave", handler: (data: OnLeave) => void): this
  • on(event: "teamChange", handler: (data: OnTeamChange) => void): this
  • on(event: "squadChange", handler: (data: OnSquadChange) => void): this
  • on(event: "maxPlayerCountChange", handler: (data: MaxPlayerCountChange) => void): this
  • on(event: "levelLoaded", handler: (data: MaxPlayerCountChange) => void): this
  • on(event: "roundOver", handler: (data: OnRoundOver) => void): this
  • on(event: "roundOverPlayers", handler: (data: OnRoundOver) => void): this
  • on(event: "roundOverTeamScores", handler: (data: OnRoundOverTeamScores) => void): this
  • on(event: "event", handler: (data: OnUnhandled) => void): this
  • on(event: "request", handler: (data: OnRequestCreate) => void): this
  • on(event: "reconnect", handler: (data: Event.ReconnectEvent) => void): this

Private onAuthenticated

  • onAuthenticated(words: Word[]): Promise<void>

Private onClose

  • onClose(): void

Private onJoin

  • onJoin(words: Word[]): Promise<void>

Private onLevelLoaded

  • onLevelLoaded(words: Word[]): void

Private onMaxPlayerCountChange

  • onMaxPlayerCountChange(words: Word[]): void

Private onPunkBuster

  • onPunkBuster(event: string, words: Word[]): void

Private onRoundOver

  • onRoundOver(words: Word[]): void

Private onRoundOverPlayers

  • onRoundOverPlayers(words: Word[]): void

Private onRoundOverTeamScores

  • onRoundOverTeamScores(words: Word[]): void

Private onSquadChange

  • onSquadChange(words: Word[]): Promise<void>

Private onTeamChange

  • onTeamChange(words: Word[]): Promise<void>

once

  • once(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

Private parseClientList

  • parseClientList(): (words: Word[]) => T[]

Private parseList

  • Type parameters

    • T: {}

    Parameters

    • cb: (word: Word, name: keyof T) => any
        • (word: Word, name: keyof T): any

        • Parameters

          • word: Word
          • name: keyof T

          Returns any

    • Default value replace: Record<string, string | ParseListReplaceOption> = {}

    Returns (words: Word[]) => T[]

      • (words: Word[]): T[]

      • Parameters

        Returns T[]

playerAlive

  • playerAlive(name: string): Promise<boolean>

  • checks wether a client is dead or alive

    Parameters

    • name: string

      name of the player to check

    Returns Promise<boolean>

playerKick

  • playerKick(name: string, reason?: undefined | string): Promise<unknown>

  • Kick player from server

    Parameters

    • name: string

      player name to kick

    • Optional reason: undefined | string

      kick reason

    Returns Promise<unknown>

playerKill

  • playerKill(name: string): Promise<unknown>

  • Kill a player without any stats effect

    Parameters

    • name: string

    Returns Promise<unknown>

playerMove

  • playerMove(name: string, teamId: number, squadId: number, forceKill: boolean): Promise<unknown>

  • Move a player to another team and/or squad Only works if player is dead. This command will kill player if forceKill is true

    Parameters

    • name: string

      player name to move

    • teamId: number
    • squadId: number
    • forceKill: boolean

      kill the player to move?

    Returns Promise<unknown>

Private playerOnChat

  • playerOnChat(words: Word[]): Promise<void>

Private playerOnKill

  • playerOnKill(words: Word[]): Promise<void>

Private playerOnLeave

  • playerOnLeave(words: Word[]): void

Private playerOnSpawn

  • playerOnSpawn(words: Word[]): Promise<void>

playerPing

  • playerPing(name: string): Promise<boolean>

  • returns the players ping

    Parameters

    • name: string

      name of the player to check

    Returns Promise<boolean>

prependListener

  • prependListener(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

prependOnceListener

  • prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

punkBusterActivate

  • punkBusterActivate(): Promise<unknown>

  • Attempt to activate PunkBuster server module if it currently is inactive

    Returns Promise<unknown>

punkBusterActive

  • punkBusterActive(): Promise<boolean>

  • Query whether the PunkBuster server module is active

    Returns Promise<boolean>

punkBusterSendCommand

  • punkBusterSendCommand(cmd: string): Promise<unknown>

  • Send a raw PunkBuster command to the PunkBuster server

    Parameters

    • cmd: string

      command to send

    Returns Promise<unknown>

quit

  • quit(): void

rawListeners

  • rawListeners(event: string | symbol): Function[]

  • Parameters

    • event: string | symbol

    Returns Function[]

reconnect

  • reconnect(maxAttempts?: number, timeout?: number, increase?: number): Promise<void>

  • attempts to reconnects to the battlefield server

    Parameters

    • Default value maxAttempts: number = -1

      number of tries <= 0 tries to connect forever

    • Default value timeout: number = 1000

      timeout in ms between connection attempts

    • Default value increase: number = 0

      increase timeout after every unsuccessful reconnect try

    Returns Promise<void>

reloadExtensions

  • reloadExtensions(): Promise<unknown>

  • reloads all currently loaded mods. keep in mind that this can cause significant server and client lag and also crashes as not all mods support reloading

    Returns Promise<unknown>

removeAllListeners

  • removeAllListeners(event?: string | symbol): this

  • Parameters

    • Optional event: string | symbol

    Returns this

Private removeEventHandler

  • removeEventHandler(): void

removeListener

  • removeListener(event: string | symbol, listener: (...args: any[]) => void): this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

restartRound

  • restartRound(): Promise<unknown>

  • restarts the current round, without going through the end of round sequence

    Returns Promise<unknown>

saveBans

  • saveBans(): Promise<unknown>

saveMaps

  • saveMaps(): Promise<unknown>

saveReservedSlots

  • saveReservedSlots(): Promise<unknown>

say

  • say(msg: string, subset: string[]): Promise<unknown>

  • Send a chat message to players. The message must be less than 128 characters long.

    Parameters

    • msg: string

      message to send

    • subset: string[]

      subset to send message to

    Returns Promise<unknown>

serverInfo

set

setMaxListeners

  • setMaxListeners(n: number): this

  • Parameters

    • n: number

    Returns this

setNextMapIndex

  • setNextMapIndex(index: number): Promise<unknown>

  • Specifies which map to switch to once the current round completes. If there are rounds remaining on the current map, those rounds will be skipped.

    Parameters

    • index: number

    Returns Promise<unknown>

setTeamticketCount

  • setTeamticketCount(team: number, count: number): Promise<unknown>

  • sets the tickets a team has to a certain amount

    Parameters

    • team: number

      team to set the ticket amount

    • count: number

      amount of tickets they should have

    Returns Promise<unknown>

yell

  • yell(msg: string, duration?: undefined | number, subset?: string[]): Promise<unknown>

  • Show an obnoxious message on players’ screens for the specified duration. If duration is left out, a default of 10 seconds is assumed. If players are left out, the message will go to all players. The message must be less than 256 characters long.

    Parameters

    • msg: string

      message to send

    • Optional duration: undefined | number

      duration in seconds to display the message

    • Default value subset: string[] = []

      subset to send message to

    Returns Promise<unknown>

Static connect

Static listenerCount

  • listenerCount(emitter: EventEmitter, event: string | symbol): number
  • deprecated

    since v4.0.0

    Parameters

    • emitter: EventEmitter
    • event: string | symbol

    Returns number

Static sleep

  • sleep(time: number): Promise<void>

Static testConnection

  • testConnection(options: Omit<Options, "autoconnect">): Promise<true | Error>

Object literals

version

version: object

game

game: UNKNOWN = Battlefield.Version.UNKNOWN

version

version: number = 0

Generated using TypeDoc