├── .gitignore ├── LICENSE ├── README.md ├── dist ├── BotClient.d.ts ├── BotManager.d.ts ├── BotManager.d.ts.map ├── Controller.d.ts ├── ControllerManager.d.ts ├── GameState.d.ts ├── QuickChats.d.ts ├── RenderManager.d.ts ├── flat │ ├── flatstructs.d.ts │ ├── rlbot │ │ └── flat │ │ │ ├── ball-bounciness-option.d.ts │ │ │ ├── ball-info.d.ts │ │ │ ├── ball-max-speed-option.d.ts │ │ │ ├── ball-prediction.d.ts │ │ │ ├── ball-rigid-body-state.d.ts │ │ │ ├── ball-size-option.d.ts │ │ │ ├── ball-type-option.d.ts │ │ │ ├── ball-weight-option.d.ts │ │ │ ├── bool.d.ts │ │ │ ├── boost-option.d.ts │ │ │ ├── boost-pad-state.d.ts │ │ │ ├── boost-pad.d.ts │ │ │ ├── boost-strength-option.d.ts │ │ │ ├── box-shape.d.ts │ │ │ ├── collision-shape.d.ts │ │ │ ├── color.d.ts │ │ │ ├── console-command.d.ts │ │ │ ├── controller-state.d.ts │ │ │ ├── cylinder-shape.d.ts │ │ │ ├── demolish-option.d.ts │ │ │ ├── desired-ball-state.d.ts │ │ │ ├── desired-boost-state.d.ts │ │ │ ├── desired-car-state.d.ts │ │ │ ├── desired-game-info-state.d.ts │ │ │ ├── desired-game-state.d.ts │ │ │ ├── desired-physics.d.ts │ │ │ ├── drop-shot-ball-info.d.ts │ │ │ ├── dropshot-tile.d.ts │ │ │ ├── existing-match-behavior.d.ts │ │ │ ├── field-info.d.ts │ │ │ ├── float.d.ts │ │ │ ├── game-info.d.ts │ │ │ ├── game-map.d.ts │ │ │ ├── game-message-wrapper.d.ts │ │ │ ├── game-message.d.ts │ │ │ ├── game-mode.d.ts │ │ │ ├── game-speed-option.d.ts │ │ │ ├── game-tick-packet.d.ts │ │ │ ├── goal-info.d.ts │ │ │ ├── gravity-option.d.ts │ │ │ ├── human-player.d.ts │ │ │ ├── loadout-paint.d.ts │ │ │ ├── match-length.d.ts │ │ │ ├── match-settings.d.ts │ │ │ ├── max-score.d.ts │ │ │ ├── message-packet.d.ts │ │ │ ├── mutator-settings.d.ts │ │ │ ├── overtime-option.d.ts │ │ │ ├── party-member-bot-player.d.ts │ │ │ ├── physics.d.ts │ │ │ ├── player-class.d.ts │ │ │ ├── player-configuration.d.ts │ │ │ ├── player-info.d.ts │ │ │ ├── player-input-change.d.ts │ │ │ ├── player-input.d.ts │ │ │ ├── player-loadout.d.ts │ │ │ ├── player-rigid-body-state.d.ts │ │ │ ├── player-spectate.d.ts │ │ │ ├── player-stat-event.d.ts │ │ │ ├── prediction-slice.d.ts │ │ │ ├── psyonix-bot-player.d.ts │ │ │ ├── quaternion.d.ts │ │ │ ├── quick-chat-messages.d.ts │ │ │ ├── quick-chat-selection.d.ts │ │ │ ├── quick-chat.d.ts │ │ │ ├── ready-message.d.ts │ │ │ ├── render-group.d.ts │ │ │ ├── render-message.d.ts │ │ │ ├── render-type.d.ts │ │ │ ├── respawn-time-option.d.ts │ │ │ ├── rigid-body-state.d.ts │ │ │ ├── rigid-body-tick.d.ts │ │ │ ├── rlbot-player.d.ts │ │ │ ├── rotator-partial.d.ts │ │ │ ├── rotator.d.ts │ │ │ ├── rumble-option.d.ts │ │ │ ├── score-info.d.ts │ │ │ ├── series-length-option.d.ts │ │ │ ├── sphere-shape.d.ts │ │ │ ├── team-info.d.ts │ │ │ ├── tile-state.d.ts │ │ │ ├── tiny-ball.d.ts │ │ │ ├── tiny-packet.d.ts │ │ │ ├── tiny-player.d.ts │ │ │ ├── touch.d.ts │ │ │ ├── vector3.d.ts │ │ │ └── vector3partial.d.ts │ └── rlbot_generated.d.ts ├── index.d.ts ├── index.js ├── index.js.map └── utils.d.ts ├── esbuild.js ├── package.json ├── pnpm-lock.yaml ├── src ├── BotClient.ts ├── BotManager.ts ├── Controller.ts ├── ControllerManager.ts ├── GameState.ts ├── QuickChats.ts ├── RenderManager.ts ├── flat │ ├── rlbot.fbs │ ├── rlbot │ │ └── flat │ │ │ ├── ball-bounciness-option.ts │ │ │ ├── ball-info.ts │ │ │ ├── ball-max-speed-option.ts │ │ │ ├── ball-prediction.ts │ │ │ ├── ball-rigid-body-state.ts │ │ │ ├── ball-size-option.ts │ │ │ ├── ball-type-option.ts │ │ │ ├── ball-weight-option.ts │ │ │ ├── bool.ts │ │ │ ├── boost-option.ts │ │ │ ├── boost-pad-state.ts │ │ │ ├── boost-pad.ts │ │ │ ├── boost-strength-option.ts │ │ │ ├── box-shape.ts │ │ │ ├── collision-shape.ts │ │ │ ├── color.ts │ │ │ ├── console-command.ts │ │ │ ├── controller-state.ts │ │ │ ├── cylinder-shape.ts │ │ │ ├── demolish-option.ts │ │ │ ├── desired-ball-state.ts │ │ │ ├── desired-boost-state.ts │ │ │ ├── desired-car-state.ts │ │ │ ├── desired-game-info-state.ts │ │ │ ├── desired-game-state.ts │ │ │ ├── desired-physics.ts │ │ │ ├── drop-shot-ball-info.ts │ │ │ ├── dropshot-tile.ts │ │ │ ├── existing-match-behavior.ts │ │ │ ├── field-info.ts │ │ │ ├── float.ts │ │ │ ├── game-info.ts │ │ │ ├── game-map.ts │ │ │ ├── game-message-wrapper.ts │ │ │ ├── game-message.ts │ │ │ ├── game-mode.ts │ │ │ ├── game-speed-option.ts │ │ │ ├── game-tick-packet.ts │ │ │ ├── goal-info.ts │ │ │ ├── gravity-option.ts │ │ │ ├── human-player.ts │ │ │ ├── loadout-paint.ts │ │ │ ├── match-length.ts │ │ │ ├── match-settings.ts │ │ │ ├── max-score.ts │ │ │ ├── message-packet.ts │ │ │ ├── mutator-settings.ts │ │ │ ├── overtime-option.ts │ │ │ ├── party-member-bot-player.ts │ │ │ ├── physics.ts │ │ │ ├── player-class.ts │ │ │ ├── player-configuration.ts │ │ │ ├── player-info.ts │ │ │ ├── player-input-change.ts │ │ │ ├── player-input.ts │ │ │ ├── player-loadout.ts │ │ │ ├── player-rigid-body-state.ts │ │ │ ├── player-spectate.ts │ │ │ ├── player-stat-event.ts │ │ │ ├── prediction-slice.ts │ │ │ ├── psyonix-bot-player.ts │ │ │ ├── quaternion.ts │ │ │ ├── quick-chat-messages.ts │ │ │ ├── quick-chat-selection.ts │ │ │ ├── quick-chat.ts │ │ │ ├── ready-message.ts │ │ │ ├── render-group.ts │ │ │ ├── render-message.ts │ │ │ ├── render-type.ts │ │ │ ├── respawn-time-option.ts │ │ │ ├── rigid-body-state.ts │ │ │ ├── rigid-body-tick.ts │ │ │ ├── rlbot-player.ts │ │ │ ├── rotator-partial.ts │ │ │ ├── rotator.ts │ │ │ ├── rumble-option.ts │ │ │ ├── score-info.ts │ │ │ ├── series-length-option.ts │ │ │ ├── sphere-shape.ts │ │ │ ├── team-info.ts │ │ │ ├── tile-state.ts │ │ │ ├── tiny-ball.ts │ │ │ ├── tiny-packet.ts │ │ │ ├── tiny-player.ts │ │ │ ├── touch.ts │ │ │ ├── vector3.ts │ │ │ └── vector3partial.ts │ └── rlbot_generated.ts ├── index.ts └── utils.ts └── tsconfig.json /.gitignore: -------------------------------------------------------------------------------- 1 | # Because of really bad code 2 | test/ 3 | 4 | 5 | 6 | # Created by https://www.toptal.com/developers/gitignore/api/node 7 | # Edit at https://www.toptal.com/developers/gitignore?templates=node 8 | 9 | ### Node ### 10 | # Logs 11 | logs 12 | *.log 13 | npm-debug.log* 14 | yarn-debug.log* 15 | yarn-error.log* 16 | lerna-debug.log* 17 | 18 | # Diagnostic reports (https://nodejs.org/api/report.html) 19 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json 20 | 21 | # Runtime data 22 | pids 23 | *.pid 24 | *.seed 25 | *.pid.lock 26 | 27 | # Directory for instrumented libs generated by jscoverage/JSCover 28 | lib-cov 29 | 30 | # Coverage directory used by tools like istanbul 31 | coverage 32 | *.lcov 33 | 34 | # nyc test coverage 35 | .nyc_output 36 | 37 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) 38 | .grunt 39 | 40 | # Bower dependency directory (https://bower.io/) 41 | bower_components 42 | 43 | # node-waf configuration 44 | .lock-wscript 45 | 46 | # Compiled binary addons (https://nodejs.org/api/addons.html) 47 | build/Release 48 | 49 | # Dependency directories 50 | node_modules/ 51 | jspm_packages/ 52 | 53 | # TypeScript v1 declaration files 54 | typings/ 55 | 56 | # TypeScript cache 57 | *.tsbuildinfo 58 | 59 | # Optional npm cache directory 60 | .npm 61 | 62 | # Optional eslint cache 63 | .eslintcache 64 | 65 | # Microbundle cache 66 | .rpt2_cache/ 67 | .rts2_cache_cjs/ 68 | .rts2_cache_es/ 69 | .rts2_cache_umd/ 70 | 71 | # Optional REPL history 72 | .node_repl_history 73 | 74 | # Output of 'npm pack' 75 | *.tgz 76 | 77 | # Yarn Integrity file 78 | .yarn-integrity 79 | 80 | # dotenv environment variables file 81 | .env 82 | .env.test 83 | .env*.local 84 | 85 | # parcel-bundler cache (https://parceljs.org/) 86 | .cache 87 | .parcel-cache 88 | 89 | # Next.js build output 90 | .next 91 | 92 | # Nuxt.js build / generate output 93 | .nuxt 94 | 95 | # Gatsby files 96 | .cache/ 97 | # Comment in the public line in if your project uses Gatsby and not Next.js 98 | # https://nextjs.org/blog/next-9-1#public-directory-support 99 | # public 100 | 101 | # vuepress build output 102 | .vuepress/dist 103 | 104 | # Serverless directories 105 | .serverless/ 106 | 107 | # FuseBox cache 108 | .fusebox/ 109 | 110 | # DynamoDB Local files 111 | .dynamodb/ 112 | 113 | # TernJS port file 114 | .tern-port 115 | 116 | # Stores VSCode versions used for testing VSCode extensions 117 | .vscode-test 118 | 119 | # End of https://www.toptal.com/developers/gitignore/api/node -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright © 2021 Simon Lindgren 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # EasyRLBot 2 | 3 | A javascript implementation of RLBot with Sockets. 4 | 5 | The documentation is located at [the github wiki page](https://github.com/swz-git/EasyRLBot/wiki) and a example bot is avaliable [here](https://github.com/RLBot/EasyRLBotExample) 6 | -------------------------------------------------------------------------------- /dist/BotClient.d.ts: -------------------------------------------------------------------------------- 1 | /// 2 | import "colors"; 3 | import * as Net from "net"; 4 | import * as flat from "./flat/rlbot_generated"; 5 | import { ControllerManager } from "./ControllerManager"; 6 | import { GameState } from "./GameState"; 7 | import { RenderManager } from "./RenderManager"; 8 | import * as utils from "./utils"; 9 | declare class BotClient { 10 | ws: Net.Socket | null; 11 | standalone: boolean; 12 | readyMessageAccepted: boolean; 13 | latestFieldInfo: flat.FieldInfoT | null; 14 | latestBallPrediction: flat.BallPredictionT | null; 15 | latestMatchSettings: flat.MatchSettingsT | null; 16 | botIndex: number; 17 | logger: utils.Logger; 18 | renderer: RenderManager; 19 | controller: ControllerManager; 20 | GameTickPacketRate: number; 21 | private internalName; 22 | constructor(botIndex: number, ws?: Net.Socket | null); 23 | onReady(): void; 24 | getOutput(gameTickPacket: flat.GameTickPacketT, fieldInfo: flat.FieldInfoT | null, ballPrediction: flat.BallPredictionT | null, matchSettings: flat.MatchSettingsT | null): void; 25 | onGameTickPacket(gameTickPacket: flat.GameTickPacketT): void; 26 | onFieldInfo(fieldInfo: flat.FieldInfoT): void; 27 | onMatchSettings(matchSettings: flat.MatchSettingsT): void; 28 | onQuickChat(quickChat: flat.QuickChatT): void; 29 | onBallPrediction(ballPrediction: flat.BallPredictionT): void; 30 | private messageHandler; 31 | setGameState(newGameState: GameState): void; 32 | setMatchSettings(newMatchSettings: flat.MatchSettingsT): void; 33 | sendQuickChat(QuickChatSelection: number, teamOnly?: boolean): void; 34 | kill(): void; 35 | private start; 36 | } 37 | export { BotClient }; 38 | -------------------------------------------------------------------------------- /dist/BotManager.d.ts: -------------------------------------------------------------------------------- 1 | /// 2 | import "colors"; 3 | import * as Net from "net"; 4 | import * as utils from "./utils"; 5 | interface BotContainer { 6 | [botIndex: string]: any; 7 | } 8 | declare class BotManager { 9 | ws: Net.Socket; 10 | bots: BotContainer; 11 | Bot: any; 12 | agentPort: number; 13 | agentIP: string; 14 | logger: utils.Logger; 15 | constructor(BotClass: any, agentPort: number, rlbotPort?: number); 16 | private start; 17 | } 18 | export { BotManager }; 19 | -------------------------------------------------------------------------------- /dist/BotManager.d.ts.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"BotManager.d.ts","sourceRoot":"","sources":["../src/BotManager.ts"],"names":[],"mappings":";AAAA,OAAO,QAAQ,CAAC;AAChB,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC,UAAU,YAAY;IACpB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AAED,cAAM,UAAU;IACd,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC;IACf,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC,MAAM,CAA+B;gBAEvC,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,MAAc;YA0BzD,KAAK;CA2DpB;AACD,OAAO,EAAE,UAAU,EAAE,CAAC"} -------------------------------------------------------------------------------- /dist/Controller.d.ts: -------------------------------------------------------------------------------- 1 | declare class Controller { 2 | throttle: number; 3 | steer: number; 4 | pitch: number; 5 | roll: number; 6 | yaw: number; 7 | boost: boolean; 8 | jump: boolean; 9 | handbrake: boolean; 10 | useItem: boolean; 11 | constructor(); 12 | } 13 | export default Controller; 14 | -------------------------------------------------------------------------------- /dist/ControllerManager.d.ts: -------------------------------------------------------------------------------- 1 | import { BotClient } from "./BotClient"; 2 | declare class Controller { 3 | throttle: number; 4 | steer: number; 5 | pitch: number; 6 | roll: number; 7 | yaw: number; 8 | boost: boolean; 9 | jump: boolean; 10 | handbrake: boolean; 11 | useItem: boolean; 12 | constructor(); 13 | } 14 | declare class ControllerManager { 15 | client: BotClient; 16 | constructor(client: BotClient); 17 | sendInput(controller: Controller): void; 18 | } 19 | export { Controller, ControllerManager }; 20 | -------------------------------------------------------------------------------- /dist/GameState.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from "flatbuffers"; 2 | declare class Vector3 { 3 | x: number; 4 | y: number; 5 | z: number; 6 | constructor(x?: number, y?: number, z?: number); 7 | fromFlat(flat: any): this; 8 | convertToFlat(builder: flatbuffers.Builder): number | null; 9 | convertToFlatPartial(builder: flatbuffers.Builder): number | null; 10 | } 11 | declare class Rotator { 12 | pitch: number; 13 | yaw: number; 14 | roll: number; 15 | constructor(pitch?: number, yaw?: number, roll?: number); 16 | fromFlat(flat: any): this; 17 | convertToFlat(builder: flatbuffers.Builder): number | null; 18 | } 19 | declare class Physics { 20 | location: Vector3; 21 | rotation: Rotator; 22 | velocity: Vector3; 23 | angularVelocity: Vector3; 24 | constructor(location?: Vector3, rotation?: Rotator, velocity?: Vector3, angularVelocity?: Vector3); 25 | fromFlat(flat: any): this; 26 | convertToFlat(builder: flatbuffers.Builder): number | null; 27 | } 28 | declare class BallState { 29 | physics: Physics; 30 | constructor(physics: Physics); 31 | convertToFlat(builder: flatbuffers.Builder): number | null; 32 | } 33 | declare class CarState { 34 | physics: Physics; 35 | boostAmount: number; 36 | jumped: boolean; 37 | doubleJumped: boolean; 38 | constructor(physics: Physics, boostAmount: number, jumped: boolean, doubleJumped: boolean); 39 | convertToFlat(builder: flatbuffers.Builder): number; 40 | } 41 | declare class BoostState { 42 | respawnTime: number; 43 | constructor(respawnTime: number); 44 | convertToFlat(builder: flatbuffers.Builder): number; 45 | } 46 | declare class GameInfoState { 47 | worldGravityZ: number; 48 | gameSpeed: number; 49 | constructor(worldGravityZ: number, gameSpeed: number); 50 | convertToFlat(builder: flatbuffers.Builder): number; 51 | } 52 | declare class GameState { 53 | ballState: BallState; 54 | carStates: (CarState | any)[]; 55 | boostStates: (BoostState | any)[]; 56 | gameInfoState: GameInfoState; 57 | constructor(ballState: BallState, carStates: (CarState | any)[], boostStates: (BoostState | any)[], gameInfoState: GameInfoState); 58 | convertToFlat(builder: flatbuffers.Builder): number; 59 | } 60 | export { Vector3, Rotator, Physics, BallState, BoostState, GameInfoState, CarState, GameState, }; 61 | -------------------------------------------------------------------------------- /dist/QuickChats.d.ts: -------------------------------------------------------------------------------- 1 | declare const _default: { 2 | information: { 3 | IGotIt: number; 4 | NeedBoost: number; 5 | TakeTheShot: number; 6 | Defending: number; 7 | GoForIt: number; 8 | Centering: number; 9 | AllYours: number; 10 | InPosition: number; 11 | Incoming: number; 12 | NiceShot: number; 13 | GreatPass: number; 14 | Thanks: number; 15 | WhatASave: number; 16 | NiceOne: number; 17 | WhatAPlay: number; 18 | GreatClear: number; 19 | NiceBlock: number; 20 | }; 21 | compliments: { 22 | NiceShot: number; 23 | GreatPass: number; 24 | Thanks: number; 25 | WhatASave: number; 26 | NiceOne: number; 27 | WhatAPlay: number; 28 | GreatClear: number; 29 | NiceBlock: number; 30 | }; 31 | reactions: { 32 | OMG: number; 33 | Noooo: number; 34 | Wow: number; 35 | CloseOne: number; 36 | NoWay: number; 37 | HolyCow: number; 38 | Whew: number; 39 | Siiiick: number; 40 | Calculated: number; 41 | Savage: number; 42 | Okay: number; 43 | }; 44 | apologies: { 45 | Cursing: number; 46 | NoProblem: number; 47 | Whoops: number; 48 | Sorry: number; 49 | MyBad: number; 50 | Oops: number; 51 | MyFault: number; 52 | }; 53 | postGame: { 54 | Gg: number; 55 | WellPlayed: number; 56 | ThatWasFun: number; 57 | Rematch: number; 58 | OneMoreGame: number; 59 | WhatAGame: number; 60 | NiceMoves: number; 61 | EverybodyDance: number; 62 | }; 63 | custom: { 64 | Toxic_WasteCPU: number; 65 | Toxic_GitGut: number; 66 | Toxic_DeAlloc: number; 67 | Toxic_404NoSkill: number; 68 | Toxic_CatchVirus: number; 69 | Useful_Passing: number; 70 | Useful_Faking: number; 71 | Useful_Demoing: number; 72 | Useful_Bumping: number; 73 | Compliments_TinyChances: number; 74 | Compliments_SkillLevel: number; 75 | Compliments_proud: number; 76 | Compliments_GC: number; 77 | Compliments_Pro: number; 78 | Custom_Excuses_Lag: number; 79 | Custom_Excuses_GhostInputs: number; 80 | Custom_Excuses_Rigged: number; 81 | Custom_Toxic_MafiaPlays: number; 82 | Custom_Exclamation_Yeet: number; 83 | }; 84 | }; 85 | export default _default; 86 | -------------------------------------------------------------------------------- /dist/RenderManager.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from "flatbuffers"; 2 | import { BotClient } from "./BotClient"; 3 | import { Vector3 } from "./GameState"; 4 | declare class Color { 5 | alpha: number; 6 | red: number; 7 | green: number; 8 | blue: number; 9 | constructor(alpha: number, red: number, green: number, blue: number); 10 | convertToFlat(builder: flatbuffers.Builder): number; 11 | } 12 | declare class RenderManager { 13 | client: BotClient; 14 | builder: flatbuffers.Builder | null; 15 | index: number; 16 | Color: typeof Color; 17 | renderList: flatbuffers.Offset[]; 18 | groupID: string; 19 | constructor(botClient: BotClient); 20 | beginRendering(groupID: string): void; 21 | endRendering(): void; 22 | drawString2D(x: number, y: number, scaleX: number, scaleY: number, text: string, color: Color): void; 23 | drawString3D(vector: Vector3, scaleX: number, scaleY: number, text: string, color: Color): void; 24 | drawLine2D_3D(x: number, y: number, end: Vector3, color: Color): void; 25 | drawLine2D(startX: number, startY: number, endX: number, endY: number, color: Color): void; 26 | drawLine3D(start: Vector3, end: Vector3, color: Color): void; 27 | drawRect2D(x: number, y: number, width: number, height: number, color: Color): void; 28 | drawRect3D(vector: Vector3, width: number, height: number, color: Color, centered: Boolean): void; 29 | black(): Color; 30 | white(): Color; 31 | gray(): Color; 32 | blue(): Color; 33 | red(): Color; 34 | green(): Color; 35 | lime(): Color; 36 | yellow(): Color; 37 | orange(): Color; 38 | cyan(): Color; 39 | pink(): Color; 40 | purple(): Color; 41 | teal(): Color; 42 | } 43 | export { RenderManager, Color }; 44 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-bounciness-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BallBouncinessOption { 2 | Default = 0, 3 | Low = 1, 4 | High = 2, 5 | Super_High = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { BoxShapeT } from '../../rlbot/flat/box-shape'; 3 | import { CollisionShape } from '../../rlbot/flat/collision-shape'; 4 | import { CylinderShapeT } from '../../rlbot/flat/cylinder-shape'; 5 | import { DropShotBallInfo, DropShotBallInfoT } from '../../rlbot/flat/drop-shot-ball-info'; 6 | import { Physics, PhysicsT } from '../../rlbot/flat/physics'; 7 | import { SphereShapeT } from '../../rlbot/flat/sphere-shape'; 8 | import { Touch, TouchT } from '../../rlbot/flat/touch'; 9 | export declare class BallInfo { 10 | bb: flatbuffers.ByteBuffer | null; 11 | bb_pos: number; 12 | __init(i: number, bb: flatbuffers.ByteBuffer): BallInfo; 13 | static getRootAsBallInfo(bb: flatbuffers.ByteBuffer, obj?: BallInfo): BallInfo; 14 | static getSizePrefixedRootAsBallInfo(bb: flatbuffers.ByteBuffer, obj?: BallInfo): BallInfo; 15 | physics(obj?: Physics): Physics | null; 16 | latestTouch(obj?: Touch): Touch | null; 17 | dropShotInfo(obj?: DropShotBallInfo): DropShotBallInfo | null; 18 | shapeType(): CollisionShape; 19 | shape(obj: any): any | null; 20 | static startBallInfo(builder: flatbuffers.Builder): void; 21 | static addPhysics(builder: flatbuffers.Builder, physicsOffset: flatbuffers.Offset): void; 22 | static addLatestTouch(builder: flatbuffers.Builder, latestTouchOffset: flatbuffers.Offset): void; 23 | static addDropShotInfo(builder: flatbuffers.Builder, dropShotInfoOffset: flatbuffers.Offset): void; 24 | static addShapeType(builder: flatbuffers.Builder, shapeType: CollisionShape): void; 25 | static addShape(builder: flatbuffers.Builder, shapeOffset: flatbuffers.Offset): void; 26 | static endBallInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 27 | unpack(): BallInfoT; 28 | unpackTo(_o: BallInfoT): void; 29 | } 30 | export declare class BallInfoT { 31 | physics: PhysicsT | null; 32 | latestTouch: TouchT | null; 33 | dropShotInfo: DropShotBallInfoT | null; 34 | shapeType: CollisionShape; 35 | shape: BoxShapeT | CylinderShapeT | SphereShapeT | null; 36 | constructor(physics?: PhysicsT | null, latestTouch?: TouchT | null, dropShotInfo?: DropShotBallInfoT | null, shapeType?: CollisionShape, shape?: BoxShapeT | CylinderShapeT | SphereShapeT | null); 37 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 38 | } 39 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-max-speed-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BallMaxSpeedOption { 2 | Default = 0, 3 | Slow = 1, 4 | Fast = 2, 5 | Super_Fast = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-prediction.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { PredictionSlice, PredictionSliceT } from '../../rlbot/flat/prediction-slice'; 3 | export declare class BallPrediction { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): BallPrediction; 7 | static getRootAsBallPrediction(bb: flatbuffers.ByteBuffer, obj?: BallPrediction): BallPrediction; 8 | static getSizePrefixedRootAsBallPrediction(bb: flatbuffers.ByteBuffer, obj?: BallPrediction): BallPrediction; 9 | /** 10 | * A list of places the ball will be at specific times in the future. 11 | * It is guaranteed to sorted so that time increases with each slice. 12 | * It is NOT guaranteed to have a consistent amount of time between slices. 13 | */ 14 | slices(index: number, obj?: PredictionSlice): PredictionSlice | null; 15 | slicesLength(): number; 16 | static startBallPrediction(builder: flatbuffers.Builder): void; 17 | static addSlices(builder: flatbuffers.Builder, slicesOffset: flatbuffers.Offset): void; 18 | static createSlicesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 19 | static startSlicesVector(builder: flatbuffers.Builder, numElems: number): void; 20 | static endBallPrediction(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | static createBallPrediction(builder: flatbuffers.Builder, slicesOffset: flatbuffers.Offset): flatbuffers.Offset; 22 | unpack(): BallPredictionT; 23 | unpackTo(_o: BallPredictionT): void; 24 | } 25 | export declare class BallPredictionT { 26 | slices: (PredictionSliceT)[]; 27 | constructor(slices?: (PredictionSliceT)[]); 28 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 29 | } 30 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-rigid-body-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { RigidBodyState, RigidBodyStateT } from '../../rlbot/flat/rigid-body-state'; 3 | /** 4 | * Rigid body state for the ball. 5 | */ 6 | export declare class BallRigidBodyState { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): BallRigidBodyState; 10 | static getRootAsBallRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: BallRigidBodyState): BallRigidBodyState; 11 | static getSizePrefixedRootAsBallRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: BallRigidBodyState): BallRigidBodyState; 12 | state(obj?: RigidBodyState): RigidBodyState | null; 13 | static startBallRigidBodyState(builder: flatbuffers.Builder): void; 14 | static addState(builder: flatbuffers.Builder, stateOffset: flatbuffers.Offset): void; 15 | static endBallRigidBodyState(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | static createBallRigidBodyState(builder: flatbuffers.Builder, stateOffset: flatbuffers.Offset): flatbuffers.Offset; 17 | unpack(): BallRigidBodyStateT; 18 | unpackTo(_o: BallRigidBodyStateT): void; 19 | } 20 | export declare class BallRigidBodyStateT { 21 | state: RigidBodyStateT | null; 22 | constructor(state?: RigidBodyStateT | null); 23 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | } 25 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-size-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BallSizeOption { 2 | Default = 0, 3 | Small = 1, 4 | Large = 2, 5 | Gigantic = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-type-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BallTypeOption { 2 | Default = 0, 3 | Cube = 1, 4 | Puck = 2, 5 | Basketball = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ball-weight-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BallWeightOption { 2 | Default = 0, 3 | Light = 1, 4 | Heavy = 2, 5 | Super_Light = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/bool.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class Bool { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): Bool; 6 | val(): boolean; 7 | static sizeOf(): number; 8 | static createBool(builder: flatbuffers.Builder, val: boolean): flatbuffers.Offset; 9 | unpack(): BoolT; 10 | unpackTo(_o: BoolT): void; 11 | } 12 | export declare class BoolT { 13 | val: boolean; 14 | constructor(val?: boolean); 15 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | } 17 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/boost-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BoostOption { 2 | Normal_Boost = 0, 3 | Unlimited_Boost = 1, 4 | Slow_Recharge = 2, 5 | Rapid_Recharge = 3, 6 | No_Boost = 4 7 | } 8 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/boost-pad-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class BoostPadState { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): BoostPadState; 6 | static getRootAsBoostPadState(bb: flatbuffers.ByteBuffer, obj?: BoostPadState): BoostPadState; 7 | static getSizePrefixedRootAsBoostPadState(bb: flatbuffers.ByteBuffer, obj?: BoostPadState): BoostPadState; 8 | /** 9 | * True if the boost can be picked up 10 | */ 11 | isActive(): boolean; 12 | /** 13 | * The number of seconds since the boost has been picked up, or 0.0 if the boost is active. 14 | */ 15 | timer(): number; 16 | static startBoostPadState(builder: flatbuffers.Builder): void; 17 | static addIsActive(builder: flatbuffers.Builder, isActive: boolean): void; 18 | static addTimer(builder: flatbuffers.Builder, timer: number): void; 19 | static endBoostPadState(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | static createBoostPadState(builder: flatbuffers.Builder, isActive: boolean, timer: number): flatbuffers.Offset; 21 | unpack(): BoostPadStateT; 22 | unpackTo(_o: BoostPadStateT): void; 23 | } 24 | export declare class BoostPadStateT { 25 | isActive: boolean; 26 | timer: number; 27 | constructor(isActive?: boolean, timer?: number); 28 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 29 | } 30 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/boost-pad.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 3 | export declare class BoostPad { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): BoostPad; 7 | static getRootAsBoostPad(bb: flatbuffers.ByteBuffer, obj?: BoostPad): BoostPad; 8 | static getSizePrefixedRootAsBoostPad(bb: flatbuffers.ByteBuffer, obj?: BoostPad): BoostPad; 9 | location(obj?: Vector3): Vector3 | null; 10 | isFullBoost(): boolean; 11 | static startBoostPad(builder: flatbuffers.Builder): void; 12 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 13 | static addIsFullBoost(builder: flatbuffers.Builder, isFullBoost: boolean): void; 14 | static endBoostPad(builder: flatbuffers.Builder): flatbuffers.Offset; 15 | static createBoostPad(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset, isFullBoost: boolean): flatbuffers.Offset; 16 | unpack(): BoostPadT; 17 | unpackTo(_o: BoostPadT): void; 18 | } 19 | export declare class BoostPadT { 20 | location: Vector3T | null; 21 | isFullBoost: boolean; 22 | constructor(location?: Vector3T | null, isFullBoost?: boolean); 23 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | } 25 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/boost-strength-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum BoostStrengthOption { 2 | One = 0, 3 | OneAndAHalf = 1, 4 | Two = 2, 5 | Ten = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/box-shape.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class BoxShape { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): BoxShape; 6 | static getRootAsBoxShape(bb: flatbuffers.ByteBuffer, obj?: BoxShape): BoxShape; 7 | static getSizePrefixedRootAsBoxShape(bb: flatbuffers.ByteBuffer, obj?: BoxShape): BoxShape; 8 | length(): number; 9 | width(): number; 10 | height(): number; 11 | static startBoxShape(builder: flatbuffers.Builder): void; 12 | static addLength(builder: flatbuffers.Builder, length: number): void; 13 | static addWidth(builder: flatbuffers.Builder, width: number): void; 14 | static addHeight(builder: flatbuffers.Builder, height: number): void; 15 | static endBoxShape(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | static createBoxShape(builder: flatbuffers.Builder, length: number, width: number, height: number): flatbuffers.Offset; 17 | unpack(): BoxShapeT; 18 | unpackTo(_o: BoxShapeT): void; 19 | } 20 | export declare class BoxShapeT { 21 | length: number; 22 | width: number; 23 | height: number; 24 | constructor(length?: number, width?: number, height?: number); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/collision-shape.d.ts: -------------------------------------------------------------------------------- 1 | import { BoxShape } from '../../rlbot/flat/box-shape'; 2 | import { CylinderShape } from '../../rlbot/flat/cylinder-shape'; 3 | import { SphereShape } from '../../rlbot/flat/sphere-shape'; 4 | export declare enum CollisionShape { 5 | NONE = 0, 6 | BoxShape = 1, 7 | SphereShape = 2, 8 | CylinderShape = 3 9 | } 10 | export declare function unionToCollisionShape(type: CollisionShape, accessor: (obj: BoxShape | CylinderShape | SphereShape) => BoxShape | CylinderShape | SphereShape | null): BoxShape | CylinderShape | SphereShape | null; 11 | export declare function unionListToCollisionShape(type: CollisionShape, accessor: (index: number, obj: BoxShape | CylinderShape | SphereShape) => BoxShape | CylinderShape | SphereShape | null, index: number): BoxShape | CylinderShape | SphereShape | null; 12 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/color.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class Color { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): Color; 6 | static getRootAsColor(bb: flatbuffers.ByteBuffer, obj?: Color): Color; 7 | static getSizePrefixedRootAsColor(bb: flatbuffers.ByteBuffer, obj?: Color): Color; 8 | a(): number; 9 | r(): number; 10 | g(): number; 11 | b(): number; 12 | static startColor(builder: flatbuffers.Builder): void; 13 | static addA(builder: flatbuffers.Builder, a: number): void; 14 | static addR(builder: flatbuffers.Builder, r: number): void; 15 | static addG(builder: flatbuffers.Builder, g: number): void; 16 | static addB(builder: flatbuffers.Builder, b: number): void; 17 | static endColor(builder: flatbuffers.Builder): flatbuffers.Offset; 18 | static createColor(builder: flatbuffers.Builder, a: number, r: number, g: number, b: number): flatbuffers.Offset; 19 | unpack(): ColorT; 20 | unpackTo(_o: ColorT): void; 21 | } 22 | export declare class ColorT { 23 | a: number; 24 | r: number; 25 | g: number; 26 | b: number; 27 | constructor(a?: number, r?: number, g?: number, b?: number); 28 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 29 | } 30 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/console-command.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * A console command which we will try to execute inside Rocket League. 4 | * See https://github.com/RLBot/RLBot/wiki/Console-Commands for a list of known commands. 5 | */ 6 | export declare class ConsoleCommand { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): ConsoleCommand; 10 | static getRootAsConsoleCommand(bb: flatbuffers.ByteBuffer, obj?: ConsoleCommand): ConsoleCommand; 11 | static getSizePrefixedRootAsConsoleCommand(bb: flatbuffers.ByteBuffer, obj?: ConsoleCommand): ConsoleCommand; 12 | command(): string | null; 13 | command(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null; 14 | static startConsoleCommand(builder: flatbuffers.Builder): void; 15 | static addCommand(builder: flatbuffers.Builder, commandOffset: flatbuffers.Offset): void; 16 | static endConsoleCommand(builder: flatbuffers.Builder): flatbuffers.Offset; 17 | static createConsoleCommand(builder: flatbuffers.Builder, commandOffset: flatbuffers.Offset): flatbuffers.Offset; 18 | unpack(): ConsoleCommandT; 19 | unpackTo(_o: ConsoleCommandT): void; 20 | } 21 | export declare class ConsoleCommandT { 22 | command: string | Uint8Array | null; 23 | constructor(command?: string | Uint8Array | null); 24 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 25 | } 26 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/controller-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class ControllerState { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): ControllerState; 6 | static getRootAsControllerState(bb: flatbuffers.ByteBuffer, obj?: ControllerState): ControllerState; 7 | static getSizePrefixedRootAsControllerState(bb: flatbuffers.ByteBuffer, obj?: ControllerState): ControllerState; 8 | /** 9 | * -1 for full reverse, 1 for full forward 10 | */ 11 | throttle(): number; 12 | /** 13 | * -1 for full left, 1 for full right 14 | */ 15 | steer(): number; 16 | /** 17 | * -1 for nose down, 1 for nose up 18 | */ 19 | pitch(): number; 20 | /** 21 | * -1 for full left, 1 for full right 22 | */ 23 | yaw(): number; 24 | /** 25 | * -1 for roll left, 1 for roll right 26 | */ 27 | roll(): number; 28 | /** 29 | * true if you want to press the jump button 30 | */ 31 | jump(): boolean; 32 | /** 33 | * true if you want to press the boost button 34 | */ 35 | boost(): boolean; 36 | /** 37 | * true if you want to press the handbrake button 38 | */ 39 | handbrake(): boolean; 40 | /** 41 | * true if you want to press the 'use item' button, used in rumble etc. 42 | */ 43 | useItem(): boolean; 44 | static startControllerState(builder: flatbuffers.Builder): void; 45 | static addThrottle(builder: flatbuffers.Builder, throttle: number): void; 46 | static addSteer(builder: flatbuffers.Builder, steer: number): void; 47 | static addPitch(builder: flatbuffers.Builder, pitch: number): void; 48 | static addYaw(builder: flatbuffers.Builder, yaw: number): void; 49 | static addRoll(builder: flatbuffers.Builder, roll: number): void; 50 | static addJump(builder: flatbuffers.Builder, jump: boolean): void; 51 | static addBoost(builder: flatbuffers.Builder, boost: boolean): void; 52 | static addHandbrake(builder: flatbuffers.Builder, handbrake: boolean): void; 53 | static addUseItem(builder: flatbuffers.Builder, useItem: boolean): void; 54 | static endControllerState(builder: flatbuffers.Builder): flatbuffers.Offset; 55 | static createControllerState(builder: flatbuffers.Builder, throttle: number, steer: number, pitch: number, yaw: number, roll: number, jump: boolean, boost: boolean, handbrake: boolean, useItem: boolean): flatbuffers.Offset; 56 | unpack(): ControllerStateT; 57 | unpackTo(_o: ControllerStateT): void; 58 | } 59 | export declare class ControllerStateT { 60 | throttle: number; 61 | steer: number; 62 | pitch: number; 63 | yaw: number; 64 | roll: number; 65 | jump: boolean; 66 | boost: boolean; 67 | handbrake: boolean; 68 | useItem: boolean; 69 | constructor(throttle?: number, steer?: number, pitch?: number, yaw?: number, roll?: number, jump?: boolean, boost?: boolean, handbrake?: boolean, useItem?: boolean); 70 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 71 | } 72 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/cylinder-shape.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class CylinderShape { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): CylinderShape; 6 | static getRootAsCylinderShape(bb: flatbuffers.ByteBuffer, obj?: CylinderShape): CylinderShape; 7 | static getSizePrefixedRootAsCylinderShape(bb: flatbuffers.ByteBuffer, obj?: CylinderShape): CylinderShape; 8 | diameter(): number; 9 | height(): number; 10 | static startCylinderShape(builder: flatbuffers.Builder): void; 11 | static addDiameter(builder: flatbuffers.Builder, diameter: number): void; 12 | static addHeight(builder: flatbuffers.Builder, height: number): void; 13 | static endCylinderShape(builder: flatbuffers.Builder): flatbuffers.Offset; 14 | static createCylinderShape(builder: flatbuffers.Builder, diameter: number, height: number): flatbuffers.Offset; 15 | unpack(): CylinderShapeT; 16 | unpackTo(_o: CylinderShapeT): void; 17 | } 18 | export declare class CylinderShapeT { 19 | diameter: number; 20 | height: number; 21 | constructor(diameter?: number, height?: number); 22 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 23 | } 24 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/demolish-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum DemolishOption { 2 | Default = 0, 3 | Disabled = 1, 4 | Friendly_Fire = 2, 5 | On_Contact = 3, 6 | On_Contact_FF = 4 7 | } 8 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/desired-ball-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { DesiredPhysics, DesiredPhysicsT } from '../../rlbot/flat/desired-physics'; 3 | export declare class DesiredBallState { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): DesiredBallState; 7 | static getRootAsDesiredBallState(bb: flatbuffers.ByteBuffer, obj?: DesiredBallState): DesiredBallState; 8 | static getSizePrefixedRootAsDesiredBallState(bb: flatbuffers.ByteBuffer, obj?: DesiredBallState): DesiredBallState; 9 | physics(obj?: DesiredPhysics): DesiredPhysics | null; 10 | static startDesiredBallState(builder: flatbuffers.Builder): void; 11 | static addPhysics(builder: flatbuffers.Builder, physicsOffset: flatbuffers.Offset): void; 12 | static endDesiredBallState(builder: flatbuffers.Builder): flatbuffers.Offset; 13 | static createDesiredBallState(builder: flatbuffers.Builder, physicsOffset: flatbuffers.Offset): flatbuffers.Offset; 14 | unpack(): DesiredBallStateT; 15 | unpackTo(_o: DesiredBallStateT): void; 16 | } 17 | export declare class DesiredBallStateT { 18 | physics: DesiredPhysicsT | null; 19 | constructor(physics?: DesiredPhysicsT | null); 20 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | } 22 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/desired-boost-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Float, FloatT } from '../../rlbot/flat/float'; 3 | export declare class DesiredBoostState { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): DesiredBoostState; 7 | static getRootAsDesiredBoostState(bb: flatbuffers.ByteBuffer, obj?: DesiredBoostState): DesiredBoostState; 8 | static getSizePrefixedRootAsDesiredBoostState(bb: flatbuffers.ByteBuffer, obj?: DesiredBoostState): DesiredBoostState; 9 | respawnTime(obj?: Float): Float | null; 10 | static startDesiredBoostState(builder: flatbuffers.Builder): void; 11 | static addRespawnTime(builder: flatbuffers.Builder, respawnTimeOffset: flatbuffers.Offset): void; 12 | static endDesiredBoostState(builder: flatbuffers.Builder): flatbuffers.Offset; 13 | static createDesiredBoostState(builder: flatbuffers.Builder, respawnTimeOffset: flatbuffers.Offset): flatbuffers.Offset; 14 | unpack(): DesiredBoostStateT; 15 | unpackTo(_o: DesiredBoostStateT): void; 16 | } 17 | export declare class DesiredBoostStateT { 18 | respawnTime: FloatT | null; 19 | constructor(respawnTime?: FloatT | null); 20 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | } 22 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/desired-car-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Bool, BoolT } from '../../rlbot/flat/bool'; 3 | import { DesiredPhysics, DesiredPhysicsT } from '../../rlbot/flat/desired-physics'; 4 | import { Float, FloatT } from '../../rlbot/flat/float'; 5 | export declare class DesiredCarState { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): DesiredCarState; 9 | static getRootAsDesiredCarState(bb: flatbuffers.ByteBuffer, obj?: DesiredCarState): DesiredCarState; 10 | static getSizePrefixedRootAsDesiredCarState(bb: flatbuffers.ByteBuffer, obj?: DesiredCarState): DesiredCarState; 11 | physics(obj?: DesiredPhysics): DesiredPhysics | null; 12 | boostAmount(obj?: Float): Float | null; 13 | jumped(obj?: Bool): Bool | null; 14 | doubleJumped(obj?: Bool): Bool | null; 15 | static startDesiredCarState(builder: flatbuffers.Builder): void; 16 | static addPhysics(builder: flatbuffers.Builder, physicsOffset: flatbuffers.Offset): void; 17 | static addBoostAmount(builder: flatbuffers.Builder, boostAmountOffset: flatbuffers.Offset): void; 18 | static addJumped(builder: flatbuffers.Builder, jumpedOffset: flatbuffers.Offset): void; 19 | static addDoubleJumped(builder: flatbuffers.Builder, doubleJumpedOffset: flatbuffers.Offset): void; 20 | static endDesiredCarState(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | unpack(): DesiredCarStateT; 22 | unpackTo(_o: DesiredCarStateT): void; 23 | } 24 | export declare class DesiredCarStateT { 25 | physics: DesiredPhysicsT | null; 26 | boostAmount: FloatT | null; 27 | jumped: BoolT | null; 28 | doubleJumped: BoolT | null; 29 | constructor(physics?: DesiredPhysicsT | null, boostAmount?: FloatT | null, jumped?: BoolT | null, doubleJumped?: BoolT | null); 30 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 31 | } 32 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/desired-game-info-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Bool, BoolT } from '../../rlbot/flat/bool'; 3 | import { Float, FloatT } from '../../rlbot/flat/float'; 4 | export declare class DesiredGameInfoState { 5 | bb: flatbuffers.ByteBuffer | null; 6 | bb_pos: number; 7 | __init(i: number, bb: flatbuffers.ByteBuffer): DesiredGameInfoState; 8 | static getRootAsDesiredGameInfoState(bb: flatbuffers.ByteBuffer, obj?: DesiredGameInfoState): DesiredGameInfoState; 9 | static getSizePrefixedRootAsDesiredGameInfoState(bb: flatbuffers.ByteBuffer, obj?: DesiredGameInfoState): DesiredGameInfoState; 10 | worldGravityZ(obj?: Float): Float | null; 11 | gameSpeed(obj?: Float): Float | null; 12 | paused(obj?: Bool): Bool | null; 13 | endMatch(obj?: Bool): Bool | null; 14 | static startDesiredGameInfoState(builder: flatbuffers.Builder): void; 15 | static addWorldGravityZ(builder: flatbuffers.Builder, worldGravityZOffset: flatbuffers.Offset): void; 16 | static addGameSpeed(builder: flatbuffers.Builder, gameSpeedOffset: flatbuffers.Offset): void; 17 | static addPaused(builder: flatbuffers.Builder, pausedOffset: flatbuffers.Offset): void; 18 | static addEndMatch(builder: flatbuffers.Builder, endMatchOffset: flatbuffers.Offset): void; 19 | static endDesiredGameInfoState(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | unpack(): DesiredGameInfoStateT; 21 | unpackTo(_o: DesiredGameInfoStateT): void; 22 | } 23 | export declare class DesiredGameInfoStateT { 24 | worldGravityZ: FloatT | null; 25 | gameSpeed: FloatT | null; 26 | paused: BoolT | null; 27 | endMatch: BoolT | null; 28 | constructor(worldGravityZ?: FloatT | null, gameSpeed?: FloatT | null, paused?: BoolT | null, endMatch?: BoolT | null); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/desired-physics.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { RotatorPartial, RotatorPartialT } from '../../rlbot/flat/rotator-partial'; 3 | import { Vector3Partial, Vector3PartialT } from '../../rlbot/flat/vector3partial'; 4 | export declare class DesiredPhysics { 5 | bb: flatbuffers.ByteBuffer | null; 6 | bb_pos: number; 7 | __init(i: number, bb: flatbuffers.ByteBuffer): DesiredPhysics; 8 | static getRootAsDesiredPhysics(bb: flatbuffers.ByteBuffer, obj?: DesiredPhysics): DesiredPhysics; 9 | static getSizePrefixedRootAsDesiredPhysics(bb: flatbuffers.ByteBuffer, obj?: DesiredPhysics): DesiredPhysics; 10 | location(obj?: Vector3Partial): Vector3Partial | null; 11 | rotation(obj?: RotatorPartial): RotatorPartial | null; 12 | velocity(obj?: Vector3Partial): Vector3Partial | null; 13 | angularVelocity(obj?: Vector3Partial): Vector3Partial | null; 14 | static startDesiredPhysics(builder: flatbuffers.Builder): void; 15 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 16 | static addRotation(builder: flatbuffers.Builder, rotationOffset: flatbuffers.Offset): void; 17 | static addVelocity(builder: flatbuffers.Builder, velocityOffset: flatbuffers.Offset): void; 18 | static addAngularVelocity(builder: flatbuffers.Builder, angularVelocityOffset: flatbuffers.Offset): void; 19 | static endDesiredPhysics(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | unpack(): DesiredPhysicsT; 21 | unpackTo(_o: DesiredPhysicsT): void; 22 | } 23 | export declare class DesiredPhysicsT { 24 | location: Vector3PartialT | null; 25 | rotation: RotatorPartialT | null; 26 | velocity: Vector3PartialT | null; 27 | angularVelocity: Vector3PartialT | null; 28 | constructor(location?: Vector3PartialT | null, rotation?: RotatorPartialT | null, velocity?: Vector3PartialT | null, angularVelocity?: Vector3PartialT | null); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/drop-shot-ball-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class DropShotBallInfo { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): DropShotBallInfo; 6 | static getRootAsDropShotBallInfo(bb: flatbuffers.ByteBuffer, obj?: DropShotBallInfo): DropShotBallInfo; 7 | static getSizePrefixedRootAsDropShotBallInfo(bb: flatbuffers.ByteBuffer, obj?: DropShotBallInfo): DropShotBallInfo; 8 | absorbedForce(): number; 9 | damageIndex(): number; 10 | forceAccumRecent(): number; 11 | static startDropShotBallInfo(builder: flatbuffers.Builder): void; 12 | static addAbsorbedForce(builder: flatbuffers.Builder, absorbedForce: number): void; 13 | static addDamageIndex(builder: flatbuffers.Builder, damageIndex: number): void; 14 | static addForceAccumRecent(builder: flatbuffers.Builder, forceAccumRecent: number): void; 15 | static endDropShotBallInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | static createDropShotBallInfo(builder: flatbuffers.Builder, absorbedForce: number, damageIndex: number, forceAccumRecent: number): flatbuffers.Offset; 17 | unpack(): DropShotBallInfoT; 18 | unpackTo(_o: DropShotBallInfoT): void; 19 | } 20 | export declare class DropShotBallInfoT { 21 | absorbedForce: number; 22 | damageIndex: number; 23 | forceAccumRecent: number; 24 | constructor(absorbedForce?: number, damageIndex?: number, forceAccumRecent?: number); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/dropshot-tile.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { TileState } from '../../rlbot/flat/tile-state'; 3 | export declare class DropshotTile { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): DropshotTile; 7 | static getRootAsDropshotTile(bb: flatbuffers.ByteBuffer, obj?: DropshotTile): DropshotTile; 8 | static getSizePrefixedRootAsDropshotTile(bb: flatbuffers.ByteBuffer, obj?: DropshotTile): DropshotTile; 9 | /** 10 | * The amount of damage the tile has sustained. 11 | */ 12 | tileState(): TileState; 13 | static startDropshotTile(builder: flatbuffers.Builder): void; 14 | static addTileState(builder: flatbuffers.Builder, tileState: TileState): void; 15 | static endDropshotTile(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | static createDropshotTile(builder: flatbuffers.Builder, tileState: TileState): flatbuffers.Offset; 17 | unpack(): DropshotTileT; 18 | unpackTo(_o: DropshotTileT): void; 19 | } 20 | export declare class DropshotTileT { 21 | tileState: TileState; 22 | constructor(tileState?: TileState); 23 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | } 25 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/existing-match-behavior.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum ExistingMatchBehavior { 2 | /** 3 | * Restart the match if any match settings differ. This is the default because old RLBot always worked this way. 4 | */ 5 | Restart_If_Different = 0, 6 | /** 7 | * Always restart the match, even if config is identical 8 | */ 9 | Restart = 1, 10 | /** 11 | * Never restart an existing match, just try to remove or spawn cars to match the configuration. 12 | * If we are not in the middle of a match, a match will be started. Handy for LAN matches. 13 | */ 14 | Continue_And_Spawn = 2 15 | } 16 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/field-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { BoostPad, BoostPadT } from '../../rlbot/flat/boost-pad'; 3 | import { GoalInfo, GoalInfoT } from '../../rlbot/flat/goal-info'; 4 | export declare class FieldInfo { 5 | bb: flatbuffers.ByteBuffer | null; 6 | bb_pos: number; 7 | __init(i: number, bb: flatbuffers.ByteBuffer): FieldInfo; 8 | static getRootAsFieldInfo(bb: flatbuffers.ByteBuffer, obj?: FieldInfo): FieldInfo; 9 | static getSizePrefixedRootAsFieldInfo(bb: flatbuffers.ByteBuffer, obj?: FieldInfo): FieldInfo; 10 | boostPads(index: number, obj?: BoostPad): BoostPad | null; 11 | boostPadsLength(): number; 12 | goals(index: number, obj?: GoalInfo): GoalInfo | null; 13 | goalsLength(): number; 14 | static startFieldInfo(builder: flatbuffers.Builder): void; 15 | static addBoostPads(builder: flatbuffers.Builder, boostPadsOffset: flatbuffers.Offset): void; 16 | static createBoostPadsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 17 | static startBoostPadsVector(builder: flatbuffers.Builder, numElems: number): void; 18 | static addGoals(builder: flatbuffers.Builder, goalsOffset: flatbuffers.Offset): void; 19 | static createGoalsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 20 | static startGoalsVector(builder: flatbuffers.Builder, numElems: number): void; 21 | static endFieldInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 22 | static createFieldInfo(builder: flatbuffers.Builder, boostPadsOffset: flatbuffers.Offset, goalsOffset: flatbuffers.Offset): flatbuffers.Offset; 23 | unpack(): FieldInfoT; 24 | unpackTo(_o: FieldInfoT): void; 25 | } 26 | export declare class FieldInfoT { 27 | boostPads: (BoostPadT)[]; 28 | goals: (GoalInfoT)[]; 29 | constructor(boostPads?: (BoostPadT)[], goals?: (GoalInfoT)[]); 30 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 31 | } 32 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/float.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class Float { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): Float; 6 | val(): number; 7 | static sizeOf(): number; 8 | static createFloat(builder: flatbuffers.Builder, val: number): flatbuffers.Offset; 9 | unpack(): FloatT; 10 | unpackTo(_o: FloatT): void; 11 | } 12 | export declare class FloatT { 13 | val: number; 14 | constructor(val?: number); 15 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | } 17 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/game-map.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum GameMap { 2 | DFHStadium = 0, 3 | Mannfield = 1, 4 | ChampionsField = 2, 5 | UrbanCentral = 3, 6 | BeckwithPark = 4, 7 | UtopiaColiseum = 5, 8 | Wasteland = 6, 9 | NeoTokyo = 7, 10 | AquaDome = 8, 11 | StarbaseArc = 9, 12 | Farmstead = 10, 13 | SaltyShores = 11, 14 | DFHStadium_Stormy = 12, 15 | DFHStadium_Day = 13, 16 | Mannfield_Stormy = 14, 17 | Mannfield_Night = 15, 18 | ChampionsField_Day = 16, 19 | BeckwithPark_Stormy = 17, 20 | BeckwithPark_Midnight = 18, 21 | UrbanCentral_Night = 19, 22 | UrbanCentral_Dawn = 20, 23 | UtopiaColiseum_Dusk = 21, 24 | DFHStadium_Snowy = 22, 25 | Mannfield_Snowy = 23, 26 | UtopiaColiseum_Snowy = 24, 27 | Badlands = 25, 28 | Badlands_Night = 26, 29 | TokyoUnderpass = 27, 30 | Arctagon = 28, 31 | Pillars = 29, 32 | Cosmic = 30, 33 | DoubleGoal = 31, 34 | Octagon = 32, 35 | Underpass = 33, 36 | UtopiaRetro = 34, 37 | Hoops_DunkHouse = 35, 38 | DropShot_Core707 = 36, 39 | ThrowbackStadium = 37, 40 | ForbiddenTemple = 38, 41 | RivalsArena = 39, 42 | Farmstead_Night = 40, 43 | SaltyShores_Night = 41 44 | } 45 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/game-message-wrapper.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { GameMessage } from '../../rlbot/flat/game-message'; 3 | import { PlayerInputChangeT } from '../../rlbot/flat/player-input-change'; 4 | import { PlayerSpectateT } from '../../rlbot/flat/player-spectate'; 5 | import { PlayerStatEventT } from '../../rlbot/flat/player-stat-event'; 6 | export declare class GameMessageWrapper { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): GameMessageWrapper; 10 | static getRootAsGameMessageWrapper(bb: flatbuffers.ByteBuffer, obj?: GameMessageWrapper): GameMessageWrapper; 11 | static getSizePrefixedRootAsGameMessageWrapper(bb: flatbuffers.ByteBuffer, obj?: GameMessageWrapper): GameMessageWrapper; 12 | MessageType(): GameMessage; 13 | Message(obj: any): any | null; 14 | static startGameMessageWrapper(builder: flatbuffers.Builder): void; 15 | static addMessageType(builder: flatbuffers.Builder, MessageType: GameMessage): void; 16 | static addMessage(builder: flatbuffers.Builder, MessageOffset: flatbuffers.Offset): void; 17 | static endGameMessageWrapper(builder: flatbuffers.Builder): flatbuffers.Offset; 18 | static createGameMessageWrapper(builder: flatbuffers.Builder, MessageType: GameMessage, MessageOffset: flatbuffers.Offset): flatbuffers.Offset; 19 | unpack(): GameMessageWrapperT; 20 | unpackTo(_o: GameMessageWrapperT): void; 21 | } 22 | export declare class GameMessageWrapperT { 23 | MessageType: GameMessage; 24 | Message: PlayerInputChangeT | PlayerSpectateT | PlayerStatEventT | null; 25 | constructor(MessageType?: GameMessage, Message?: PlayerInputChangeT | PlayerSpectateT | PlayerStatEventT | null); 26 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 27 | } 28 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/game-message.d.ts: -------------------------------------------------------------------------------- 1 | import { PlayerInputChange } from '../../rlbot/flat/player-input-change'; 2 | import { PlayerSpectate } from '../../rlbot/flat/player-spectate'; 3 | import { PlayerStatEvent } from '../../rlbot/flat/player-stat-event'; 4 | export declare enum GameMessage { 5 | NONE = 0, 6 | PlayerStatEvent = 1, 7 | PlayerSpectate = 2, 8 | PlayerInputChange = 3 9 | } 10 | export declare function unionToGameMessage(type: GameMessage, accessor: (obj: PlayerInputChange | PlayerSpectate | PlayerStatEvent) => PlayerInputChange | PlayerSpectate | PlayerStatEvent | null): PlayerInputChange | PlayerSpectate | PlayerStatEvent | null; 11 | export declare function unionListToGameMessage(type: GameMessage, accessor: (index: number, obj: PlayerInputChange | PlayerSpectate | PlayerStatEvent) => PlayerInputChange | PlayerSpectate | PlayerStatEvent | null, index: number): PlayerInputChange | PlayerSpectate | PlayerStatEvent | null; 12 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/game-mode.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum GameMode { 2 | Soccer = 0, 3 | Hoops = 1, 4 | Dropshot = 2, 5 | Hockey = 3, 6 | Rumble = 4, 7 | Heatseeker = 5 8 | } 9 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/game-speed-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum GameSpeedOption { 2 | Default = 0, 3 | Slo_Mo = 1, 4 | Time_Warp = 2 5 | } 6 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/goal-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 3 | export declare class GoalInfo { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): GoalInfo; 7 | static getRootAsGoalInfo(bb: flatbuffers.ByteBuffer, obj?: GoalInfo): GoalInfo; 8 | static getSizePrefixedRootAsGoalInfo(bb: flatbuffers.ByteBuffer, obj?: GoalInfo): GoalInfo; 9 | teamNum(): number; 10 | location(obj?: Vector3): Vector3 | null; 11 | direction(obj?: Vector3): Vector3 | null; 12 | width(): number; 13 | height(): number; 14 | static startGoalInfo(builder: flatbuffers.Builder): void; 15 | static addTeamNum(builder: flatbuffers.Builder, teamNum: number): void; 16 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 17 | static addDirection(builder: flatbuffers.Builder, directionOffset: flatbuffers.Offset): void; 18 | static addWidth(builder: flatbuffers.Builder, width: number): void; 19 | static addHeight(builder: flatbuffers.Builder, height: number): void; 20 | static endGoalInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | unpack(): GoalInfoT; 22 | unpackTo(_o: GoalInfoT): void; 23 | } 24 | export declare class GoalInfoT { 25 | teamNum: number; 26 | location: Vector3T | null; 27 | direction: Vector3T | null; 28 | width: number; 29 | height: number; 30 | constructor(teamNum?: number, location?: Vector3T | null, direction?: Vector3T | null, width?: number, height?: number); 31 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 32 | } 33 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/gravity-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum GravityOption { 2 | Default = 0, 3 | Low = 1, 4 | High = 2, 5 | Super_High = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/human-player.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * A normal human player 4 | */ 5 | export declare class HumanPlayer { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): HumanPlayer; 9 | static getRootAsHumanPlayer(bb: flatbuffers.ByteBuffer, obj?: HumanPlayer): HumanPlayer; 10 | static getSizePrefixedRootAsHumanPlayer(bb: flatbuffers.ByteBuffer, obj?: HumanPlayer): HumanPlayer; 11 | static startHumanPlayer(builder: flatbuffers.Builder): void; 12 | static endHumanPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 13 | static createHumanPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 14 | unpack(): HumanPlayerT; 15 | unpackTo(_o: HumanPlayerT): void; 16 | } 17 | export declare class HumanPlayerT { 18 | constructor(); 19 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | } 21 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/loadout-paint.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * Specification for 'painted' items. See https://github.com/RLBot/RLBot/wiki/Bot-Customization 4 | */ 5 | export declare class LoadoutPaint { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): LoadoutPaint; 9 | static getRootAsLoadoutPaint(bb: flatbuffers.ByteBuffer, obj?: LoadoutPaint): LoadoutPaint; 10 | static getSizePrefixedRootAsLoadoutPaint(bb: flatbuffers.ByteBuffer, obj?: LoadoutPaint): LoadoutPaint; 11 | carPaintId(): number; 12 | decalPaintId(): number; 13 | wheelsPaintId(): number; 14 | boostPaintId(): number; 15 | antennaPaintId(): number; 16 | hatPaintId(): number; 17 | trailsPaintId(): number; 18 | goalExplosionPaintId(): number; 19 | static startLoadoutPaint(builder: flatbuffers.Builder): void; 20 | static addCarPaintId(builder: flatbuffers.Builder, carPaintId: number): void; 21 | static addDecalPaintId(builder: flatbuffers.Builder, decalPaintId: number): void; 22 | static addWheelsPaintId(builder: flatbuffers.Builder, wheelsPaintId: number): void; 23 | static addBoostPaintId(builder: flatbuffers.Builder, boostPaintId: number): void; 24 | static addAntennaPaintId(builder: flatbuffers.Builder, antennaPaintId: number): void; 25 | static addHatPaintId(builder: flatbuffers.Builder, hatPaintId: number): void; 26 | static addTrailsPaintId(builder: flatbuffers.Builder, trailsPaintId: number): void; 27 | static addGoalExplosionPaintId(builder: flatbuffers.Builder, goalExplosionPaintId: number): void; 28 | static endLoadoutPaint(builder: flatbuffers.Builder): flatbuffers.Offset; 29 | static createLoadoutPaint(builder: flatbuffers.Builder, carPaintId: number, decalPaintId: number, wheelsPaintId: number, boostPaintId: number, antennaPaintId: number, hatPaintId: number, trailsPaintId: number, goalExplosionPaintId: number): flatbuffers.Offset; 30 | unpack(): LoadoutPaintT; 31 | unpackTo(_o: LoadoutPaintT): void; 32 | } 33 | export declare class LoadoutPaintT { 34 | carPaintId: number; 35 | decalPaintId: number; 36 | wheelsPaintId: number; 37 | boostPaintId: number; 38 | antennaPaintId: number; 39 | hatPaintId: number; 40 | trailsPaintId: number; 41 | goalExplosionPaintId: number; 42 | constructor(carPaintId?: number, decalPaintId?: number, wheelsPaintId?: number, boostPaintId?: number, antennaPaintId?: number, hatPaintId?: number, trailsPaintId?: number, goalExplosionPaintId?: number); 43 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 44 | } 45 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/match-length.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum MatchLength { 2 | Five_Minutes = 0, 3 | Ten_Minutes = 1, 4 | Twenty_Minutes = 2, 5 | Unlimited = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/max-score.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum MaxScore { 2 | Unlimited = 0, 3 | One_Goal = 1, 4 | Three_Goals = 2, 5 | Five_Goals = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/message-packet.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { GameMessageWrapper, GameMessageWrapperT } from '../../rlbot/flat/game-message-wrapper'; 3 | /** 4 | * We have some very small messages that are only a few bytes but potentially sent at high frequency. 5 | * Bundle them into a packet to reduce the overhead of sending data over TCP. 6 | */ 7 | export declare class MessagePacket { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): MessagePacket; 11 | static getRootAsMessagePacket(bb: flatbuffers.ByteBuffer, obj?: MessagePacket): MessagePacket; 12 | static getSizePrefixedRootAsMessagePacket(bb: flatbuffers.ByteBuffer, obj?: MessagePacket): MessagePacket; 13 | messages(index: number, obj?: GameMessageWrapper): GameMessageWrapper | null; 14 | messagesLength(): number; 15 | gameSeconds(): number; 16 | frameNum(): number; 17 | static startMessagePacket(builder: flatbuffers.Builder): void; 18 | static addMessages(builder: flatbuffers.Builder, messagesOffset: flatbuffers.Offset): void; 19 | static createMessagesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 20 | static startMessagesVector(builder: flatbuffers.Builder, numElems: number): void; 21 | static addGameSeconds(builder: flatbuffers.Builder, gameSeconds: number): void; 22 | static addFrameNum(builder: flatbuffers.Builder, frameNum: number): void; 23 | static endMessagePacket(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | static createMessagePacket(builder: flatbuffers.Builder, messagesOffset: flatbuffers.Offset, gameSeconds: number, frameNum: number): flatbuffers.Offset; 25 | unpack(): MessagePacketT; 26 | unpackTo(_o: MessagePacketT): void; 27 | } 28 | export declare class MessagePacketT { 29 | messages: (GameMessageWrapperT)[]; 30 | gameSeconds: number; 31 | frameNum: number; 32 | constructor(messages?: (GameMessageWrapperT)[], gameSeconds?: number, frameNum?: number); 33 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 34 | } 35 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/overtime-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum OvertimeOption { 2 | Unlimited = 0, 3 | Five_Max_First_Score = 1, 4 | Five_Max_Random_Team = 2 5 | } 6 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/party-member-bot-player.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * A player that Rocket League treats as human, e.g. has a dedicated camera and can do training mode, 4 | * but is actually controlled by a bot. 5 | */ 6 | export declare class PartyMemberBotPlayer { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): PartyMemberBotPlayer; 10 | static getRootAsPartyMemberBotPlayer(bb: flatbuffers.ByteBuffer, obj?: PartyMemberBotPlayer): PartyMemberBotPlayer; 11 | static getSizePrefixedRootAsPartyMemberBotPlayer(bb: flatbuffers.ByteBuffer, obj?: PartyMemberBotPlayer): PartyMemberBotPlayer; 12 | static startPartyMemberBotPlayer(builder: flatbuffers.Builder): void; 13 | static endPartyMemberBotPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 14 | static createPartyMemberBotPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 15 | unpack(): PartyMemberBotPlayerT; 16 | unpackTo(_o: PartyMemberBotPlayerT): void; 17 | } 18 | export declare class PartyMemberBotPlayerT { 19 | constructor(); 20 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | } 22 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/physics.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Rotator, RotatorT } from '../../rlbot/flat/rotator'; 3 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 4 | export declare class Physics { 5 | bb: flatbuffers.ByteBuffer | null; 6 | bb_pos: number; 7 | __init(i: number, bb: flatbuffers.ByteBuffer): Physics; 8 | static getRootAsPhysics(bb: flatbuffers.ByteBuffer, obj?: Physics): Physics; 9 | static getSizePrefixedRootAsPhysics(bb: flatbuffers.ByteBuffer, obj?: Physics): Physics; 10 | location(obj?: Vector3): Vector3 | null; 11 | rotation(obj?: Rotator): Rotator | null; 12 | velocity(obj?: Vector3): Vector3 | null; 13 | angularVelocity(obj?: Vector3): Vector3 | null; 14 | static startPhysics(builder: flatbuffers.Builder): void; 15 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 16 | static addRotation(builder: flatbuffers.Builder, rotationOffset: flatbuffers.Offset): void; 17 | static addVelocity(builder: flatbuffers.Builder, velocityOffset: flatbuffers.Offset): void; 18 | static addAngularVelocity(builder: flatbuffers.Builder, angularVelocityOffset: flatbuffers.Offset): void; 19 | static endPhysics(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | unpack(): PhysicsT; 21 | unpackTo(_o: PhysicsT): void; 22 | } 23 | export declare class PhysicsT { 24 | location: Vector3T | null; 25 | rotation: RotatorT | null; 26 | velocity: Vector3T | null; 27 | angularVelocity: Vector3T | null; 28 | constructor(location?: Vector3T | null, rotation?: RotatorT | null, velocity?: Vector3T | null, angularVelocity?: Vector3T | null); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-class.d.ts: -------------------------------------------------------------------------------- 1 | import { HumanPlayer } from '../../rlbot/flat/human-player'; 2 | import { PartyMemberBotPlayer } from '../../rlbot/flat/party-member-bot-player'; 3 | import { PsyonixBotPlayer } from '../../rlbot/flat/psyonix-bot-player'; 4 | import { RLBotPlayer } from '../../rlbot/flat/rlbot-player'; 5 | export declare enum PlayerClass { 6 | NONE = 0, 7 | RLBotPlayer = 1, 8 | HumanPlayer = 2, 9 | PsyonixBotPlayer = 3, 10 | PartyMemberBotPlayer = 4 11 | } 12 | export declare function unionToPlayerClass(type: PlayerClass, accessor: (obj: HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer) => HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer | null): HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer | null; 13 | export declare function unionListToPlayerClass(type: PlayerClass, accessor: (index: number, obj: HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer) => HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer | null, index: number): HumanPlayer | PartyMemberBotPlayer | PsyonixBotPlayer | RLBotPlayer | null; 14 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-configuration.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { HumanPlayerT } from '../../rlbot/flat/human-player'; 3 | import { PartyMemberBotPlayerT } from '../../rlbot/flat/party-member-bot-player'; 4 | import { PlayerClass } from '../../rlbot/flat/player-class'; 5 | import { PlayerLoadout, PlayerLoadoutT } from '../../rlbot/flat/player-loadout'; 6 | import { PsyonixBotPlayerT } from '../../rlbot/flat/psyonix-bot-player'; 7 | import { RLBotPlayerT } from '../../rlbot/flat/rlbot-player'; 8 | export declare class PlayerConfiguration { 9 | bb: flatbuffers.ByteBuffer | null; 10 | bb_pos: number; 11 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerConfiguration; 12 | static getRootAsPlayerConfiguration(bb: flatbuffers.ByteBuffer, obj?: PlayerConfiguration): PlayerConfiguration; 13 | static getSizePrefixedRootAsPlayerConfiguration(bb: flatbuffers.ByteBuffer, obj?: PlayerConfiguration): PlayerConfiguration; 14 | varietyType(): PlayerClass; 15 | variety(obj: any): any | null; 16 | name(): string | null; 17 | name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null; 18 | team(): number; 19 | loadout(obj?: PlayerLoadout): PlayerLoadout | null; 20 | /** 21 | * In the case where the requested player index is not available, spawnId will help 22 | * the framework figure out what index was actually assigned to this player instead. 23 | */ 24 | spawnId(): number; 25 | static startPlayerConfiguration(builder: flatbuffers.Builder): void; 26 | static addVarietyType(builder: flatbuffers.Builder, varietyType: PlayerClass): void; 27 | static addVariety(builder: flatbuffers.Builder, varietyOffset: flatbuffers.Offset): void; 28 | static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void; 29 | static addTeam(builder: flatbuffers.Builder, team: number): void; 30 | static addLoadout(builder: flatbuffers.Builder, loadoutOffset: flatbuffers.Offset): void; 31 | static addSpawnId(builder: flatbuffers.Builder, spawnId: number): void; 32 | static endPlayerConfiguration(builder: flatbuffers.Builder): flatbuffers.Offset; 33 | unpack(): PlayerConfigurationT; 34 | unpackTo(_o: PlayerConfigurationT): void; 35 | } 36 | export declare class PlayerConfigurationT { 37 | varietyType: PlayerClass; 38 | variety: HumanPlayerT | PartyMemberBotPlayerT | PsyonixBotPlayerT | RLBotPlayerT | null; 39 | name: string | Uint8Array | null; 40 | team: number; 41 | loadout: PlayerLoadoutT | null; 42 | spawnId: number; 43 | constructor(varietyType?: PlayerClass, variety?: HumanPlayerT | PartyMemberBotPlayerT | PsyonixBotPlayerT | RLBotPlayerT | null, name?: string | Uint8Array | null, team?: number, loadout?: PlayerLoadoutT | null, spawnId?: number); 44 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 45 | } 46 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-input-change.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { ControllerState, ControllerStateT } from '../../rlbot/flat/controller-state'; 3 | /** 4 | * Rocket League is notifying us that some player has moved their controller. This is an *output* 5 | */ 6 | export declare class PlayerInputChange { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerInputChange; 10 | static getRootAsPlayerInputChange(bb: flatbuffers.ByteBuffer, obj?: PlayerInputChange): PlayerInputChange; 11 | static getSizePrefixedRootAsPlayerInputChange(bb: flatbuffers.ByteBuffer, obj?: PlayerInputChange): PlayerInputChange; 12 | playerIndex(): number; 13 | controllerState(obj?: ControllerState): ControllerState | null; 14 | dodgeForward(): number; 15 | dodgeRight(): number; 16 | static startPlayerInputChange(builder: flatbuffers.Builder): void; 17 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 18 | static addControllerState(builder: flatbuffers.Builder, controllerStateOffset: flatbuffers.Offset): void; 19 | static addDodgeForward(builder: flatbuffers.Builder, dodgeForward: number): void; 20 | static addDodgeRight(builder: flatbuffers.Builder, dodgeRight: number): void; 21 | static endPlayerInputChange(builder: flatbuffers.Builder): flatbuffers.Offset; 22 | unpack(): PlayerInputChangeT; 23 | unpackTo(_o: PlayerInputChangeT): void; 24 | } 25 | export declare class PlayerInputChangeT { 26 | playerIndex: number; 27 | controllerState: ControllerStateT | null; 28 | dodgeForward: number; 29 | dodgeRight: number; 30 | constructor(playerIndex?: number, controllerState?: ControllerStateT | null, dodgeForward?: number, dodgeRight?: number); 31 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 32 | } 33 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-input.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { ControllerState, ControllerStateT } from '../../rlbot/flat/controller-state'; 3 | export declare class PlayerInput { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerInput; 7 | static getRootAsPlayerInput(bb: flatbuffers.ByteBuffer, obj?: PlayerInput): PlayerInput; 8 | static getSizePrefixedRootAsPlayerInput(bb: flatbuffers.ByteBuffer, obj?: PlayerInput): PlayerInput; 9 | playerIndex(): number; 10 | controllerState(obj?: ControllerState): ControllerState | null; 11 | static startPlayerInput(builder: flatbuffers.Builder): void; 12 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 13 | static addControllerState(builder: flatbuffers.Builder, controllerStateOffset: flatbuffers.Offset): void; 14 | static endPlayerInput(builder: flatbuffers.Builder): flatbuffers.Offset; 15 | unpack(): PlayerInputT; 16 | unpackTo(_o: PlayerInputT): void; 17 | } 18 | export declare class PlayerInputT { 19 | playerIndex: number; 20 | controllerState: ControllerStateT | null; 21 | constructor(playerIndex?: number, controllerState?: ControllerStateT | null); 22 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 23 | } 24 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-rigid-body-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { ControllerState, ControllerStateT } from '../../rlbot/flat/controller-state'; 3 | import { RigidBodyState, RigidBodyStateT } from '../../rlbot/flat/rigid-body-state'; 4 | /** 5 | * Rigid body state for a player / car in the game. Includes the latest 6 | * controller input, which is otherwise difficult to correlate with consequences. 7 | */ 8 | export declare class PlayerRigidBodyState { 9 | bb: flatbuffers.ByteBuffer | null; 10 | bb_pos: number; 11 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerRigidBodyState; 12 | static getRootAsPlayerRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: PlayerRigidBodyState): PlayerRigidBodyState; 13 | static getSizePrefixedRootAsPlayerRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: PlayerRigidBodyState): PlayerRigidBodyState; 14 | state(obj?: RigidBodyState): RigidBodyState | null; 15 | input(obj?: ControllerState): ControllerState | null; 16 | static startPlayerRigidBodyState(builder: flatbuffers.Builder): void; 17 | static addState(builder: flatbuffers.Builder, stateOffset: flatbuffers.Offset): void; 18 | static addInput(builder: flatbuffers.Builder, inputOffset: flatbuffers.Offset): void; 19 | static endPlayerRigidBodyState(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | unpack(): PlayerRigidBodyStateT; 21 | unpackTo(_o: PlayerRigidBodyStateT): void; 22 | } 23 | export declare class PlayerRigidBodyStateT { 24 | state: RigidBodyStateT | null; 25 | input: ControllerStateT | null; 26 | constructor(state?: RigidBodyStateT | null, input?: ControllerStateT | null); 27 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 28 | } 29 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-spectate.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * Notification when the local player is spectating another player. 4 | */ 5 | export declare class PlayerSpectate { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerSpectate; 9 | static getRootAsPlayerSpectate(bb: flatbuffers.ByteBuffer, obj?: PlayerSpectate): PlayerSpectate; 10 | static getSizePrefixedRootAsPlayerSpectate(bb: flatbuffers.ByteBuffer, obj?: PlayerSpectate): PlayerSpectate; 11 | /** 12 | * index of the player that is being spectated. Will be -1 if not spectating anyone. 13 | */ 14 | playerIndex(): number; 15 | static startPlayerSpectate(builder: flatbuffers.Builder): void; 16 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 17 | static endPlayerSpectate(builder: flatbuffers.Builder): flatbuffers.Offset; 18 | static createPlayerSpectate(builder: flatbuffers.Builder, playerIndex: number): flatbuffers.Offset; 19 | unpack(): PlayerSpectateT; 20 | unpackTo(_o: PlayerSpectateT): void; 21 | } 22 | export declare class PlayerSpectateT { 23 | playerIndex: number; 24 | constructor(playerIndex?: number); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/player-stat-event.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from "flatbuffers"; 2 | /** 3 | * Notification that a player triggers some in-game event, such as: 4 | * Win, Loss, TimePlayed; 5 | * Shot, Assist, Center, Clear, PoolShot; 6 | * Goal, AerialGoal, BicycleGoal, BulletGoal, BackwardsGoal, LongGoal, OvertimeGoal, TurtleGoal; 7 | * AerialHit, BicycleHit, BulletHit, /*BackwardsHit,* / JuggleHit, FirstTouch, BallHit; 8 | * Save, EpicSave, FreezeSave; 9 | * HatTrick, Savior, Playmaker, MVP; 10 | * FastestGoal, SlowestGoal, FurthestGoal, OwnGoal; 11 | * MostBallTouches, FewestBallTouches, MostBoostPickups, FewestBoostPickups, BoostPickups; 12 | * CarTouches, Demolition, Demolish; 13 | * LowFive, HighFive; 14 | */ 15 | export declare class PlayerStatEvent { 16 | bb: flatbuffers.ByteBuffer | null; 17 | bb_pos: number; 18 | __init(i: number, bb: flatbuffers.ByteBuffer): PlayerStatEvent; 19 | static getRootAsPlayerStatEvent(bb: flatbuffers.ByteBuffer, obj?: PlayerStatEvent): PlayerStatEvent; 20 | static getSizePrefixedRootAsPlayerStatEvent(bb: flatbuffers.ByteBuffer, obj?: PlayerStatEvent): PlayerStatEvent; 21 | /** 22 | * index of the player associated with the event 23 | */ 24 | playerIndex(): number; 25 | /** 26 | * Event type 27 | */ 28 | statType(): string | null; 29 | statType(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null; 30 | static startPlayerStatEvent(builder: flatbuffers.Builder): void; 31 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 32 | static addStatType(builder: flatbuffers.Builder, statTypeOffset: flatbuffers.Offset): void; 33 | static endPlayerStatEvent(builder: flatbuffers.Builder): flatbuffers.Offset; 34 | static createPlayerStatEvent(builder: flatbuffers.Builder, playerIndex: number, statTypeOffset: flatbuffers.Offset): flatbuffers.Offset; 35 | unpack(): PlayerStatEventT; 36 | unpackTo(_o: PlayerStatEventT): void; 37 | } 38 | export declare class PlayerStatEventT { 39 | playerIndex: number; 40 | statType: string | Uint8Array | null; 41 | constructor(playerIndex?: number, statType?: string | Uint8Array | null); 42 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 43 | } 44 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/prediction-slice.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Physics, PhysicsT } from '../../rlbot/flat/physics'; 3 | export declare class PredictionSlice { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): PredictionSlice; 7 | static getRootAsPredictionSlice(bb: flatbuffers.ByteBuffer, obj?: PredictionSlice): PredictionSlice; 8 | static getSizePrefixedRootAsPredictionSlice(bb: flatbuffers.ByteBuffer, obj?: PredictionSlice): PredictionSlice; 9 | /** 10 | * The moment in game time that this prediction corresponds to. 11 | * This corresponds to 'secondsElapsed' in the GameInfo table. 12 | */ 13 | gameSeconds(): number; 14 | /** 15 | * The predicted location and motion of the object. 16 | */ 17 | physics(obj?: Physics): Physics | null; 18 | static startPredictionSlice(builder: flatbuffers.Builder): void; 19 | static addGameSeconds(builder: flatbuffers.Builder, gameSeconds: number): void; 20 | static addPhysics(builder: flatbuffers.Builder, physicsOffset: flatbuffers.Offset): void; 21 | static endPredictionSlice(builder: flatbuffers.Builder): flatbuffers.Offset; 22 | unpack(): PredictionSliceT; 23 | unpackTo(_o: PredictionSliceT): void; 24 | } 25 | export declare class PredictionSliceT { 26 | gameSeconds: number; 27 | physics: PhysicsT | null; 28 | constructor(gameSeconds?: number, physics?: PhysicsT | null); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/psyonix-bot-player.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * A psyonix bot, e.g. All Star bot 4 | */ 5 | export declare class PsyonixBotPlayer { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): PsyonixBotPlayer; 9 | static getRootAsPsyonixBotPlayer(bb: flatbuffers.ByteBuffer, obj?: PsyonixBotPlayer): PsyonixBotPlayer; 10 | static getSizePrefixedRootAsPsyonixBotPlayer(bb: flatbuffers.ByteBuffer, obj?: PsyonixBotPlayer): PsyonixBotPlayer; 11 | botSkill(): number; 12 | static startPsyonixBotPlayer(builder: flatbuffers.Builder): void; 13 | static addBotSkill(builder: flatbuffers.Builder, botSkill: number): void; 14 | static endPsyonixBotPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 15 | static createPsyonixBotPlayer(builder: flatbuffers.Builder, botSkill: number): flatbuffers.Offset; 16 | unpack(): PsyonixBotPlayerT; 17 | unpackTo(_o: PsyonixBotPlayerT): void; 18 | } 19 | export declare class PsyonixBotPlayerT { 20 | botSkill: number; 21 | constructor(botSkill?: number); 22 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 23 | } 24 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/quaternion.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * Expresses the rotation state of an object. 4 | * Learn about quaternions here: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation 5 | * You can tinker with them here to build an intuition: https://quaternions.online/ 6 | */ 7 | export declare class Quaternion { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): Quaternion; 11 | x(): number; 12 | y(): number; 13 | z(): number; 14 | w(): number; 15 | static sizeOf(): number; 16 | static createQuaternion(builder: flatbuffers.Builder, x: number, y: number, z: number, w: number): flatbuffers.Offset; 17 | unpack(): QuaternionT; 18 | unpackTo(_o: QuaternionT): void; 19 | } 20 | export declare class QuaternionT { 21 | x: number; 22 | y: number; 23 | z: number; 24 | w: number; 25 | constructor(x?: number, y?: number, z?: number, w?: number); 26 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 27 | } 28 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/quick-chat-messages.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { QuickChat, QuickChatT } from '../../rlbot/flat/quick-chat'; 3 | export declare class QuickChatMessages { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): QuickChatMessages; 7 | static getRootAsQuickChatMessages(bb: flatbuffers.ByteBuffer, obj?: QuickChatMessages): QuickChatMessages; 8 | static getSizePrefixedRootAsQuickChatMessages(bb: flatbuffers.ByteBuffer, obj?: QuickChatMessages): QuickChatMessages; 9 | messages(index: number, obj?: QuickChat): QuickChat | null; 10 | messagesLength(): number; 11 | static startQuickChatMessages(builder: flatbuffers.Builder): void; 12 | static addMessages(builder: flatbuffers.Builder, messagesOffset: flatbuffers.Offset): void; 13 | static createMessagesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 14 | static startMessagesVector(builder: flatbuffers.Builder, numElems: number): void; 15 | static endQuickChatMessages(builder: flatbuffers.Builder): flatbuffers.Offset; 16 | static createQuickChatMessages(builder: flatbuffers.Builder, messagesOffset: flatbuffers.Offset): flatbuffers.Offset; 17 | unpack(): QuickChatMessagesT; 18 | unpackTo(_o: QuickChatMessagesT): void; 19 | } 20 | export declare class QuickChatMessagesT { 21 | messages: (QuickChatT)[]; 22 | constructor(messages?: (QuickChatT)[]); 23 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | } 25 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/quick-chat.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { QuickChatSelection } from '../../rlbot/flat/quick-chat-selection'; 3 | export declare class QuickChat { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): QuickChat; 7 | static getRootAsQuickChat(bb: flatbuffers.ByteBuffer, obj?: QuickChat): QuickChat; 8 | static getSizePrefixedRootAsQuickChat(bb: flatbuffers.ByteBuffer, obj?: QuickChat): QuickChat; 9 | quickChatSelection(): QuickChatSelection; 10 | /** 11 | * The index of the player that sent the quick chat 12 | */ 13 | playerIndex(): number; 14 | /** 15 | * True if the chat is team only false if everyone can see it. 16 | */ 17 | teamOnly(): boolean; 18 | messageIndex(): number; 19 | timeStamp(): number; 20 | static startQuickChat(builder: flatbuffers.Builder): void; 21 | static addQuickChatSelection(builder: flatbuffers.Builder, quickChatSelection: QuickChatSelection): void; 22 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 23 | static addTeamOnly(builder: flatbuffers.Builder, teamOnly: boolean): void; 24 | static addMessageIndex(builder: flatbuffers.Builder, messageIndex: number): void; 25 | static addTimeStamp(builder: flatbuffers.Builder, timeStamp: number): void; 26 | static endQuickChat(builder: flatbuffers.Builder): flatbuffers.Offset; 27 | static finishQuickChatBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void; 28 | static finishSizePrefixedQuickChatBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void; 29 | static createQuickChat(builder: flatbuffers.Builder, quickChatSelection: QuickChatSelection, playerIndex: number, teamOnly: boolean, messageIndex: number, timeStamp: number): flatbuffers.Offset; 30 | unpack(): QuickChatT; 31 | unpackTo(_o: QuickChatT): void; 32 | } 33 | export declare class QuickChatT { 34 | quickChatSelection: QuickChatSelection; 35 | playerIndex: number; 36 | teamOnly: boolean; 37 | messageIndex: number; 38 | timeStamp: number; 39 | constructor(quickChatSelection?: QuickChatSelection, playerIndex?: number, teamOnly?: boolean, messageIndex?: number, timeStamp?: number); 40 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 41 | } 42 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/ready-message.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * Sent when connecting to RLBot to indicate what type of messages are desired. 4 | * This could be sent by a bot, or a bot manager governing several bots, an 5 | * overlay, or any other utility that connects to the RLBot process. 6 | */ 7 | export declare class ReadyMessage { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): ReadyMessage; 11 | static getRootAsReadyMessage(bb: flatbuffers.ByteBuffer, obj?: ReadyMessage): ReadyMessage; 12 | static getSizePrefixedRootAsReadyMessage(bb: flatbuffers.ByteBuffer, obj?: ReadyMessage): ReadyMessage; 13 | wantsBallPredictions(): boolean; 14 | wantsQuickChat(): boolean; 15 | wantsGameMessages(): boolean; 16 | static startReadyMessage(builder: flatbuffers.Builder): void; 17 | static addWantsBallPredictions(builder: flatbuffers.Builder, wantsBallPredictions: boolean): void; 18 | static addWantsQuickChat(builder: flatbuffers.Builder, wantsQuickChat: boolean): void; 19 | static addWantsGameMessages(builder: flatbuffers.Builder, wantsGameMessages: boolean): void; 20 | static endReadyMessage(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | static createReadyMessage(builder: flatbuffers.Builder, wantsBallPredictions: boolean, wantsQuickChat: boolean, wantsGameMessages: boolean): flatbuffers.Offset; 22 | unpack(): ReadyMessageT; 23 | unpackTo(_o: ReadyMessageT): void; 24 | } 25 | export declare class ReadyMessageT { 26 | wantsBallPredictions: boolean; 27 | wantsQuickChat: boolean; 28 | wantsGameMessages: boolean; 29 | constructor(wantsBallPredictions?: boolean, wantsQuickChat?: boolean, wantsGameMessages?: boolean); 30 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 31 | } 32 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/render-group.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { RenderMessage, RenderMessageT } from '../../rlbot/flat/render-message'; 3 | export declare class RenderGroup { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): RenderGroup; 7 | static getRootAsRenderGroup(bb: flatbuffers.ByteBuffer, obj?: RenderGroup): RenderGroup; 8 | static getSizePrefixedRootAsRenderGroup(bb: flatbuffers.ByteBuffer, obj?: RenderGroup): RenderGroup; 9 | renderMessages(index: number, obj?: RenderMessage): RenderMessage | null; 10 | renderMessagesLength(): number; 11 | /** 12 | * The id of the render group 13 | */ 14 | id(): number; 15 | static startRenderGroup(builder: flatbuffers.Builder): void; 16 | static addRenderMessages(builder: flatbuffers.Builder, renderMessagesOffset: flatbuffers.Offset): void; 17 | static createRenderMessagesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 18 | static startRenderMessagesVector(builder: flatbuffers.Builder, numElems: number): void; 19 | static addId(builder: flatbuffers.Builder, id: number): void; 20 | static endRenderGroup(builder: flatbuffers.Builder): flatbuffers.Offset; 21 | static createRenderGroup(builder: flatbuffers.Builder, renderMessagesOffset: flatbuffers.Offset, id: number): flatbuffers.Offset; 22 | unpack(): RenderGroupT; 23 | unpackTo(_o: RenderGroupT): void; 24 | } 25 | export declare class RenderGroupT { 26 | renderMessages: (RenderMessageT)[]; 27 | id: number; 28 | constructor(renderMessages?: (RenderMessageT)[], id?: number); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/render-message.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Color, ColorT } from '../../rlbot/flat/color'; 3 | import { RenderType } from '../../rlbot/flat/render-type'; 4 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 5 | export declare class RenderMessage { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): RenderMessage; 9 | static getRootAsRenderMessage(bb: flatbuffers.ByteBuffer, obj?: RenderMessage): RenderMessage; 10 | static getSizePrefixedRootAsRenderMessage(bb: flatbuffers.ByteBuffer, obj?: RenderMessage): RenderMessage; 11 | renderType(): RenderType; 12 | color(obj?: Color): Color | null; 13 | /** 14 | * For 2d renders this only grabs x and y 15 | */ 16 | start(obj?: Vector3): Vector3 | null; 17 | /** 18 | * For 2d renders this only grabs x and y 19 | */ 20 | end(obj?: Vector3): Vector3 | null; 21 | /** 22 | * Scales the x size of the text/rectangle, is used for rectangles assuming an initial value of 1 23 | */ 24 | scaleX(): number; 25 | /** 26 | * Scales the y size of the text/rectangle, is used for rectangles assuming an initial value of 1 27 | */ 28 | scaleY(): number; 29 | text(): string | null; 30 | text(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null; 31 | /** 32 | * Rectangles can be filled or just outlines. 33 | */ 34 | isFilled(): boolean; 35 | static startRenderMessage(builder: flatbuffers.Builder): void; 36 | static addRenderType(builder: flatbuffers.Builder, renderType: RenderType): void; 37 | static addColor(builder: flatbuffers.Builder, colorOffset: flatbuffers.Offset): void; 38 | static addStart(builder: flatbuffers.Builder, startOffset: flatbuffers.Offset): void; 39 | static addEnd(builder: flatbuffers.Builder, endOffset: flatbuffers.Offset): void; 40 | static addScaleX(builder: flatbuffers.Builder, scaleX: number): void; 41 | static addScaleY(builder: flatbuffers.Builder, scaleY: number): void; 42 | static addText(builder: flatbuffers.Builder, textOffset: flatbuffers.Offset): void; 43 | static addIsFilled(builder: flatbuffers.Builder, isFilled: boolean): void; 44 | static endRenderMessage(builder: flatbuffers.Builder): flatbuffers.Offset; 45 | unpack(): RenderMessageT; 46 | unpackTo(_o: RenderMessageT): void; 47 | } 48 | export declare class RenderMessageT { 49 | renderType: RenderType; 50 | color: ColorT | null; 51 | start: Vector3T | null; 52 | end: Vector3T | null; 53 | scaleX: number; 54 | scaleY: number; 55 | text: string | Uint8Array | null; 56 | isFilled: boolean; 57 | constructor(renderType?: RenderType, color?: ColorT | null, start?: Vector3T | null, end?: Vector3T | null, scaleX?: number, scaleY?: number, text?: string | Uint8Array | null, isFilled?: boolean); 58 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 59 | } 60 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/render-type.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum RenderType { 2 | DrawLine2D = 1, 3 | DrawLine3D = 2, 4 | DrawLine2D_3D = 3, 5 | DrawRect2D = 4, 6 | DrawRect3D = 5, 7 | DrawString2D = 6, 8 | DrawString3D = 7, 9 | DrawCenteredRect3D = 8 10 | } 11 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/respawn-time-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum RespawnTimeOption { 2 | Three_Seconds = 0, 3 | Two_Seconds = 1, 4 | One_Seconds = 2, 5 | Disable_Goal_Reset = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rigid-body-state.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Quaternion, QuaternionT } from '../../rlbot/flat/quaternion'; 3 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 4 | /** 5 | * The state of a rigid body in Rocket League's physics engine. 6 | * This gets updated in time with the physics tick, not the rendering framerate. 7 | * The frame field will be incremented every time the physics engine ticks. 8 | */ 9 | export declare class RigidBodyState { 10 | bb: flatbuffers.ByteBuffer | null; 11 | bb_pos: number; 12 | __init(i: number, bb: flatbuffers.ByteBuffer): RigidBodyState; 13 | static getRootAsRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: RigidBodyState): RigidBodyState; 14 | static getSizePrefixedRootAsRigidBodyState(bb: flatbuffers.ByteBuffer, obj?: RigidBodyState): RigidBodyState; 15 | frame(): number; 16 | location(obj?: Vector3): Vector3 | null; 17 | rotation(obj?: Quaternion): Quaternion | null; 18 | velocity(obj?: Vector3): Vector3 | null; 19 | angularVelocity(obj?: Vector3): Vector3 | null; 20 | static startRigidBodyState(builder: flatbuffers.Builder): void; 21 | static addFrame(builder: flatbuffers.Builder, frame: number): void; 22 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 23 | static addRotation(builder: flatbuffers.Builder, rotationOffset: flatbuffers.Offset): void; 24 | static addVelocity(builder: flatbuffers.Builder, velocityOffset: flatbuffers.Offset): void; 25 | static addAngularVelocity(builder: flatbuffers.Builder, angularVelocityOffset: flatbuffers.Offset): void; 26 | static endRigidBodyState(builder: flatbuffers.Builder): flatbuffers.Offset; 27 | unpack(): RigidBodyStateT; 28 | unpackTo(_o: RigidBodyStateT): void; 29 | } 30 | export declare class RigidBodyStateT { 31 | frame: number; 32 | location: Vector3T | null; 33 | rotation: QuaternionT | null; 34 | velocity: Vector3T | null; 35 | angularVelocity: Vector3T | null; 36 | constructor(frame?: number, location?: Vector3T | null, rotation?: QuaternionT | null, velocity?: Vector3T | null, angularVelocity?: Vector3T | null); 37 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 38 | } 39 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rigid-body-tick.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { BallRigidBodyState, BallRigidBodyStateT } from '../../rlbot/flat/ball-rigid-body-state'; 3 | import { PlayerRigidBodyState, PlayerRigidBodyStateT } from '../../rlbot/flat/player-rigid-body-state'; 4 | /** 5 | * Contains all rigid body state information. 6 | */ 7 | export declare class RigidBodyTick { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): RigidBodyTick; 11 | static getRootAsRigidBodyTick(bb: flatbuffers.ByteBuffer, obj?: RigidBodyTick): RigidBodyTick; 12 | static getSizePrefixedRootAsRigidBodyTick(bb: flatbuffers.ByteBuffer, obj?: RigidBodyTick): RigidBodyTick; 13 | ball(obj?: BallRigidBodyState): BallRigidBodyState | null; 14 | players(index: number, obj?: PlayerRigidBodyState): PlayerRigidBodyState | null; 15 | playersLength(): number; 16 | static startRigidBodyTick(builder: flatbuffers.Builder): void; 17 | static addBall(builder: flatbuffers.Builder, ballOffset: flatbuffers.Offset): void; 18 | static addPlayers(builder: flatbuffers.Builder, playersOffset: flatbuffers.Offset): void; 19 | static createPlayersVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 20 | static startPlayersVector(builder: flatbuffers.Builder, numElems: number): void; 21 | static endRigidBodyTick(builder: flatbuffers.Builder): flatbuffers.Offset; 22 | static createRigidBodyTick(builder: flatbuffers.Builder, ballOffset: flatbuffers.Offset, playersOffset: flatbuffers.Offset): flatbuffers.Offset; 23 | unpack(): RigidBodyTickT; 24 | unpackTo(_o: RigidBodyTickT): void; 25 | } 26 | export declare class RigidBodyTickT { 27 | ball: BallRigidBodyStateT | null; 28 | players: (PlayerRigidBodyStateT)[]; 29 | constructor(ball?: BallRigidBodyStateT | null, players?: (PlayerRigidBodyStateT)[]); 30 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 31 | } 32 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rlbot-player.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * A bot controlled by the RLBot framework 4 | */ 5 | export declare class RLBotPlayer { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): RLBotPlayer; 9 | static getRootAsRLBotPlayer(bb: flatbuffers.ByteBuffer, obj?: RLBotPlayer): RLBotPlayer; 10 | static getSizePrefixedRootAsRLBotPlayer(bb: flatbuffers.ByteBuffer, obj?: RLBotPlayer): RLBotPlayer; 11 | static startRLBotPlayer(builder: flatbuffers.Builder): void; 12 | static endRLBotPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 13 | static createRLBotPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 14 | unpack(): RLBotPlayerT; 15 | unpackTo(_o: RLBotPlayerT): void; 16 | } 17 | export declare class RLBotPlayerT { 18 | constructor(); 19 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | } 21 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rotator-partial.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Float, FloatT } from '../../rlbot/flat/float'; 3 | export declare class RotatorPartial { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): RotatorPartial; 7 | static getRootAsRotatorPartial(bb: flatbuffers.ByteBuffer, obj?: RotatorPartial): RotatorPartial; 8 | static getSizePrefixedRootAsRotatorPartial(bb: flatbuffers.ByteBuffer, obj?: RotatorPartial): RotatorPartial; 9 | pitch(obj?: Float): Float | null; 10 | yaw(obj?: Float): Float | null; 11 | roll(obj?: Float): Float | null; 12 | static startRotatorPartial(builder: flatbuffers.Builder): void; 13 | static addPitch(builder: flatbuffers.Builder, pitchOffset: flatbuffers.Offset): void; 14 | static addYaw(builder: flatbuffers.Builder, yawOffset: flatbuffers.Offset): void; 15 | static addRoll(builder: flatbuffers.Builder, rollOffset: flatbuffers.Offset): void; 16 | static endRotatorPartial(builder: flatbuffers.Builder): flatbuffers.Offset; 17 | unpack(): RotatorPartialT; 18 | unpackTo(_o: RotatorPartialT): void; 19 | } 20 | export declare class RotatorPartialT { 21 | pitch: FloatT | null; 22 | yaw: FloatT | null; 23 | roll: FloatT | null; 24 | constructor(pitch?: FloatT | null, yaw?: FloatT | null, roll?: FloatT | null); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rotator.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | /** 3 | * Expresses the rotation state of an object in Euler angles, with values in radians. 4 | */ 5 | export declare class Rotator { 6 | bb: flatbuffers.ByteBuffer | null; 7 | bb_pos: number; 8 | __init(i: number, bb: flatbuffers.ByteBuffer): Rotator; 9 | pitch(): number; 10 | yaw(): number; 11 | roll(): number; 12 | static sizeOf(): number; 13 | static createRotator(builder: flatbuffers.Builder, pitch: number, yaw: number, roll: number): flatbuffers.Offset; 14 | unpack(): RotatorT; 15 | unpackTo(_o: RotatorT): void; 16 | } 17 | export declare class RotatorT { 18 | pitch: number; 19 | yaw: number; 20 | roll: number; 21 | constructor(pitch?: number, yaw?: number, roll?: number); 22 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 23 | } 24 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/rumble-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum RumbleOption { 2 | No_Rumble = 0, 3 | Default = 1, 4 | Slow = 2, 5 | Civilized = 3, 6 | Destruction_Derby = 4, 7 | Spring_Loaded = 5, 8 | Spikes_Only = 6, 9 | Spike_Rush = 7 10 | } 11 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/score-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class ScoreInfo { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): ScoreInfo; 6 | static getRootAsScoreInfo(bb: flatbuffers.ByteBuffer, obj?: ScoreInfo): ScoreInfo; 7 | static getSizePrefixedRootAsScoreInfo(bb: flatbuffers.ByteBuffer, obj?: ScoreInfo): ScoreInfo; 8 | score(): number; 9 | goals(): number; 10 | ownGoals(): number; 11 | assists(): number; 12 | saves(): number; 13 | shots(): number; 14 | demolitions(): number; 15 | static startScoreInfo(builder: flatbuffers.Builder): void; 16 | static addScore(builder: flatbuffers.Builder, score: number): void; 17 | static addGoals(builder: flatbuffers.Builder, goals: number): void; 18 | static addOwnGoals(builder: flatbuffers.Builder, ownGoals: number): void; 19 | static addAssists(builder: flatbuffers.Builder, assists: number): void; 20 | static addSaves(builder: flatbuffers.Builder, saves: number): void; 21 | static addShots(builder: flatbuffers.Builder, shots: number): void; 22 | static addDemolitions(builder: flatbuffers.Builder, demolitions: number): void; 23 | static endScoreInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 24 | static createScoreInfo(builder: flatbuffers.Builder, score: number, goals: number, ownGoals: number, assists: number, saves: number, shots: number, demolitions: number): flatbuffers.Offset; 25 | unpack(): ScoreInfoT; 26 | unpackTo(_o: ScoreInfoT): void; 27 | } 28 | export declare class ScoreInfoT { 29 | score: number; 30 | goals: number; 31 | ownGoals: number; 32 | assists: number; 33 | saves: number; 34 | shots: number; 35 | demolitions: number; 36 | constructor(score?: number, goals?: number, ownGoals?: number, assists?: number, saves?: number, shots?: number, demolitions?: number); 37 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 38 | } 39 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/series-length-option.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum SeriesLengthOption { 2 | Unlimited = 0, 3 | Three_Games = 1, 4 | Five_Games = 2, 5 | Seven_Games = 3 6 | } 7 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/sphere-shape.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class SphereShape { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): SphereShape; 6 | static getRootAsSphereShape(bb: flatbuffers.ByteBuffer, obj?: SphereShape): SphereShape; 7 | static getSizePrefixedRootAsSphereShape(bb: flatbuffers.ByteBuffer, obj?: SphereShape): SphereShape; 8 | diameter(): number; 9 | static startSphereShape(builder: flatbuffers.Builder): void; 10 | static addDiameter(builder: flatbuffers.Builder, diameter: number): void; 11 | static endSphereShape(builder: flatbuffers.Builder): flatbuffers.Offset; 12 | static createSphereShape(builder: flatbuffers.Builder, diameter: number): flatbuffers.Offset; 13 | unpack(): SphereShapeT; 14 | unpackTo(_o: SphereShapeT): void; 15 | } 16 | export declare class SphereShapeT { 17 | diameter: number; 18 | constructor(diameter?: number); 19 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | } 21 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/team-info.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class TeamInfo { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): TeamInfo; 6 | static getRootAsTeamInfo(bb: flatbuffers.ByteBuffer, obj?: TeamInfo): TeamInfo; 7 | static getSizePrefixedRootAsTeamInfo(bb: flatbuffers.ByteBuffer, obj?: TeamInfo): TeamInfo; 8 | teamIndex(): number; 9 | /** 10 | * number of goals scored. 11 | */ 12 | score(): number; 13 | static startTeamInfo(builder: flatbuffers.Builder): void; 14 | static addTeamIndex(builder: flatbuffers.Builder, teamIndex: number): void; 15 | static addScore(builder: flatbuffers.Builder, score: number): void; 16 | static endTeamInfo(builder: flatbuffers.Builder): flatbuffers.Offset; 17 | static createTeamInfo(builder: flatbuffers.Builder, teamIndex: number, score: number): flatbuffers.Offset; 18 | unpack(): TeamInfoT; 19 | unpackTo(_o: TeamInfoT): void; 20 | } 21 | export declare class TeamInfoT { 22 | teamIndex: number; 23 | score: number; 24 | constructor(teamIndex?: number, score?: number); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/tile-state.d.ts: -------------------------------------------------------------------------------- 1 | export declare enum TileState { 2 | Unknown = 0, 3 | /** 4 | * The default state of the tiles. 5 | */ 6 | Filled = 1, 7 | /** 8 | * The state when a tile has been damaged. 9 | */ 10 | Damaged = 2, 11 | /** 12 | * The state of a tile when it is open and a goal can be scored. 13 | */ 14 | Open = 3 15 | } 16 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/tiny-ball.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 3 | /** 4 | * A minimal version of the ball, useful when bandwidth needs to be conserved. 5 | */ 6 | export declare class TinyBall { 7 | bb: flatbuffers.ByteBuffer | null; 8 | bb_pos: number; 9 | __init(i: number, bb: flatbuffers.ByteBuffer): TinyBall; 10 | static getRootAsTinyBall(bb: flatbuffers.ByteBuffer, obj?: TinyBall): TinyBall; 11 | static getSizePrefixedRootAsTinyBall(bb: flatbuffers.ByteBuffer, obj?: TinyBall): TinyBall; 12 | location(obj?: Vector3): Vector3 | null; 13 | velocity(obj?: Vector3): Vector3 | null; 14 | static startTinyBall(builder: flatbuffers.Builder): void; 15 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 16 | static addVelocity(builder: flatbuffers.Builder, velocityOffset: flatbuffers.Offset): void; 17 | static endTinyBall(builder: flatbuffers.Builder): flatbuffers.Offset; 18 | unpack(): TinyBallT; 19 | unpackTo(_o: TinyBallT): void; 20 | } 21 | export declare class TinyBallT { 22 | location: Vector3T | null; 23 | velocity: Vector3T | null; 24 | constructor(location?: Vector3T | null, velocity?: Vector3T | null); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/tiny-packet.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { TinyBall, TinyBallT } from '../../rlbot/flat/tiny-ball'; 3 | import { TinyPlayer, TinyPlayerT } from '../../rlbot/flat/tiny-player'; 4 | /** 5 | * A minimal version of the game tick packet, useful when bandwidth needs to be conserved. 6 | */ 7 | export declare class TinyPacket { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): TinyPacket; 11 | static getRootAsTinyPacket(bb: flatbuffers.ByteBuffer, obj?: TinyPacket): TinyPacket; 12 | static getSizePrefixedRootAsTinyPacket(bb: flatbuffers.ByteBuffer, obj?: TinyPacket): TinyPacket; 13 | players(index: number, obj?: TinyPlayer): TinyPlayer | null; 14 | playersLength(): number; 15 | ball(obj?: TinyBall): TinyBall | null; 16 | static startTinyPacket(builder: flatbuffers.Builder): void; 17 | static addPlayers(builder: flatbuffers.Builder, playersOffset: flatbuffers.Offset): void; 18 | static createPlayersVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset; 19 | static startPlayersVector(builder: flatbuffers.Builder, numElems: number): void; 20 | static addBall(builder: flatbuffers.Builder, ballOffset: flatbuffers.Offset): void; 21 | static endTinyPacket(builder: flatbuffers.Builder): flatbuffers.Offset; 22 | unpack(): TinyPacketT; 23 | unpackTo(_o: TinyPacketT): void; 24 | } 25 | export declare class TinyPacketT { 26 | players: (TinyPlayerT)[]; 27 | ball: TinyBallT | null; 28 | constructor(players?: (TinyPlayerT)[], ball?: TinyBallT | null); 29 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 30 | } 31 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/tiny-player.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Rotator, RotatorT } from '../../rlbot/flat/rotator'; 3 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 4 | /** 5 | * A minimal version of player data, useful when bandwidth needs to be conserved. 6 | */ 7 | export declare class TinyPlayer { 8 | bb: flatbuffers.ByteBuffer | null; 9 | bb_pos: number; 10 | __init(i: number, bb: flatbuffers.ByteBuffer): TinyPlayer; 11 | static getRootAsTinyPlayer(bb: flatbuffers.ByteBuffer, obj?: TinyPlayer): TinyPlayer; 12 | static getSizePrefixedRootAsTinyPlayer(bb: flatbuffers.ByteBuffer, obj?: TinyPlayer): TinyPlayer; 13 | location(obj?: Vector3): Vector3 | null; 14 | rotation(obj?: Rotator): Rotator | null; 15 | velocity(obj?: Vector3): Vector3 | null; 16 | hasWheelContact(): boolean; 17 | isSupersonic(): boolean; 18 | team(): number; 19 | boost(): number; 20 | static startTinyPlayer(builder: flatbuffers.Builder): void; 21 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 22 | static addRotation(builder: flatbuffers.Builder, rotationOffset: flatbuffers.Offset): void; 23 | static addVelocity(builder: flatbuffers.Builder, velocityOffset: flatbuffers.Offset): void; 24 | static addHasWheelContact(builder: flatbuffers.Builder, hasWheelContact: boolean): void; 25 | static addIsSupersonic(builder: flatbuffers.Builder, isSupersonic: boolean): void; 26 | static addTeam(builder: flatbuffers.Builder, team: number): void; 27 | static addBoost(builder: flatbuffers.Builder, boost: number): void; 28 | static endTinyPlayer(builder: flatbuffers.Builder): flatbuffers.Offset; 29 | unpack(): TinyPlayerT; 30 | unpackTo(_o: TinyPlayerT): void; 31 | } 32 | export declare class TinyPlayerT { 33 | location: Vector3T | null; 34 | rotation: RotatorT | null; 35 | velocity: Vector3T | null; 36 | hasWheelContact: boolean; 37 | isSupersonic: boolean; 38 | team: number; 39 | boost: number; 40 | constructor(location?: Vector3T | null, rotation?: RotatorT | null, velocity?: Vector3T | null, hasWheelContact?: boolean, isSupersonic?: boolean, team?: number, boost?: number); 41 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 42 | } 43 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/touch.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 3 | export declare class Touch { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): Touch; 7 | static getRootAsTouch(bb: flatbuffers.ByteBuffer, obj?: Touch): Touch; 8 | static getSizePrefixedRootAsTouch(bb: flatbuffers.ByteBuffer, obj?: Touch): Touch; 9 | /** 10 | * The name of the player involved with the touch. 11 | */ 12 | playerName(): string | null; 13 | playerName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null; 14 | /** 15 | * Seconds that had elapsed in the game when the touch occurred. 16 | */ 17 | gameSeconds(): number; 18 | /** 19 | * The point of contact for the touch. 20 | */ 21 | location(obj?: Vector3): Vector3 | null; 22 | /** 23 | * The direction of the touch. 24 | */ 25 | normal(obj?: Vector3): Vector3 | null; 26 | /** 27 | * The Team which the touch belongs to, 0 for blue 1 for orange. 28 | */ 29 | team(): number; 30 | /** 31 | * The index of the player involved with the touch. 32 | */ 33 | playerIndex(): number; 34 | static startTouch(builder: flatbuffers.Builder): void; 35 | static addPlayerName(builder: flatbuffers.Builder, playerNameOffset: flatbuffers.Offset): void; 36 | static addGameSeconds(builder: flatbuffers.Builder, gameSeconds: number): void; 37 | static addLocation(builder: flatbuffers.Builder, locationOffset: flatbuffers.Offset): void; 38 | static addNormal(builder: flatbuffers.Builder, normalOffset: flatbuffers.Offset): void; 39 | static addTeam(builder: flatbuffers.Builder, team: number): void; 40 | static addPlayerIndex(builder: flatbuffers.Builder, playerIndex: number): void; 41 | static endTouch(builder: flatbuffers.Builder): flatbuffers.Offset; 42 | unpack(): TouchT; 43 | unpackTo(_o: TouchT): void; 44 | } 45 | export declare class TouchT { 46 | playerName: string | Uint8Array | null; 47 | gameSeconds: number; 48 | location: Vector3T | null; 49 | normal: Vector3T | null; 50 | team: number; 51 | playerIndex: number; 52 | constructor(playerName?: string | Uint8Array | null, gameSeconds?: number, location?: Vector3T | null, normal?: Vector3T | null, team?: number, playerIndex?: number); 53 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 54 | } 55 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/vector3.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | export declare class Vector3 { 3 | bb: flatbuffers.ByteBuffer | null; 4 | bb_pos: number; 5 | __init(i: number, bb: flatbuffers.ByteBuffer): Vector3; 6 | x(): number; 7 | y(): number; 8 | z(): number; 9 | static sizeOf(): number; 10 | static createVector3(builder: flatbuffers.Builder, x: number, y: number, z: number): flatbuffers.Offset; 11 | unpack(): Vector3T; 12 | unpackTo(_o: Vector3T): void; 13 | } 14 | export declare class Vector3T { 15 | x: number; 16 | y: number; 17 | z: number; 18 | constructor(x?: number, y?: number, z?: number); 19 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 20 | } 21 | -------------------------------------------------------------------------------- /dist/flat/rlbot/flat/vector3partial.d.ts: -------------------------------------------------------------------------------- 1 | import * as flatbuffers from 'flatbuffers'; 2 | import { Float, FloatT } from '../../rlbot/flat/float'; 3 | export declare class Vector3Partial { 4 | bb: flatbuffers.ByteBuffer | null; 5 | bb_pos: number; 6 | __init(i: number, bb: flatbuffers.ByteBuffer): Vector3Partial; 7 | static getRootAsVector3Partial(bb: flatbuffers.ByteBuffer, obj?: Vector3Partial): Vector3Partial; 8 | static getSizePrefixedRootAsVector3Partial(bb: flatbuffers.ByteBuffer, obj?: Vector3Partial): Vector3Partial; 9 | x(obj?: Float): Float | null; 10 | y(obj?: Float): Float | null; 11 | z(obj?: Float): Float | null; 12 | static startVector3Partial(builder: flatbuffers.Builder): void; 13 | static addX(builder: flatbuffers.Builder, xOffset: flatbuffers.Offset): void; 14 | static addY(builder: flatbuffers.Builder, yOffset: flatbuffers.Offset): void; 15 | static addZ(builder: flatbuffers.Builder, zOffset: flatbuffers.Offset): void; 16 | static endVector3Partial(builder: flatbuffers.Builder): flatbuffers.Offset; 17 | unpack(): Vector3PartialT; 18 | unpackTo(_o: Vector3PartialT): void; 19 | } 20 | export declare class Vector3PartialT { 21 | x: FloatT | null; 22 | y: FloatT | null; 23 | z: FloatT | null; 24 | constructor(x?: FloatT | null, y?: FloatT | null, z?: FloatT | null); 25 | pack(builder: flatbuffers.Builder): flatbuffers.Offset; 26 | } 27 | -------------------------------------------------------------------------------- /dist/index.d.ts: -------------------------------------------------------------------------------- 1 | import { BotClient as Client } from "./BotClient"; 2 | import { BotManager as Manager } from "./BotManager"; 3 | import quickChats from "./QuickChats"; 4 | export { Client, Manager, quickChats }; 5 | export * from "./ControllerManager"; 6 | export * from "./RenderManager"; 7 | export * from "./GameState"; 8 | export { BallInfoT, BallPredictionT, BallRigidBodyStateT, BoolT, BoostPadT, BoostPadStateT, BoxShapeT, ColorT, ConsoleCommandT, ControllerStateT, CylinderShapeT, DesiredBallStateT, DesiredBoostStateT, DesiredCarStateT, DesiredGameInfoStateT, DesiredGameStateT, DesiredPhysicsT, DropShotBallInfoT, DropshotTileT, FieldInfoT, FloatT, GameInfoT, GameMessageWrapperT, GameTickPacketT, GoalInfoT, HumanPlayerT, LoadoutPaintT, MatchSettingsT, MessagePacketT, MutatorSettingsT, PartyMemberBotPlayerT, PhysicsT, PlayerConfigurationT, PlayerInfoT, PlayerInputT, PlayerInputChangeT, PlayerLoadoutT, PlayerRigidBodyStateT, PlayerSpectateT, PlayerStatEventT, PredictionSliceT, PsyonixBotPlayerT, QuaternionT, QuickChatT, QuickChatMessagesT, RLBotPlayerT, ReadyMessageT, RenderGroupT, RenderMessageT, RigidBodyStateT, RigidBodyTickT, RotatorT, RotatorPartialT, ScoreInfoT, SphereShapeT, TeamInfoT, TinyBallT, TinyPacketT, TinyPlayerT, TouchT, } from "./flat/rlbot_generated"; 9 | -------------------------------------------------------------------------------- /dist/utils.d.ts: -------------------------------------------------------------------------------- 1 | import "colors"; 2 | import * as flat from "./flat/rlbot_generated"; 3 | declare class Logger { 4 | name: string; 5 | enabled: boolean; 6 | constructor(name: string); 7 | log(...args: string[]): void; 8 | } 9 | declare function Uint8ArrayToString(bytes: Uint8Array): string; 10 | declare function Uint16to8Array(array16: Uint16Array): Uint8Array; 11 | declare function encodeFlat(messageTypeInt: number, flatArray: Uint8Array): Uint8Array; 12 | declare function decodeFlat(bytes: Uint8Array): { 13 | root: flat.BallPrediction | flat.FieldInfo | flat.GameTickPacket | flat.MatchSettings | flat.MessagePacket | flat.QuickChat; 14 | type: 1 | 2 | 3 | 12 | 10 | 9; 15 | }; 16 | declare function chunkSplitter(bigChunk: Uint8Array): Uint8Array[]; 17 | export { Uint16to8Array, Uint8ArrayToString, Logger, encodeFlat, decodeFlat, chunkSplitter, }; 18 | -------------------------------------------------------------------------------- /esbuild.js: -------------------------------------------------------------------------------- 1 | const esbuild = require("esbuild"); 2 | 3 | esbuild 4 | .build({ 5 | entryPoints: ["./src/index.ts"], 6 | outdir: "./dist", 7 | bundle: true, 8 | minify: true, 9 | platform: "node", 10 | sourcemap: true, 11 | target: "node16", 12 | external: ["flatbuffers"], 13 | }) 14 | .catch(() => process.exit(1)); 15 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "easyrlbot", 3 | "version": "1.0.3", 4 | "description": "A RLBot implementation in javascript with Sockets.", 5 | "main": "dist/index", 6 | "scripts": { 7 | "watch": "npx tsc --watch", 8 | "build": "npm run build:typedefs && npm run build:js", 9 | "build:js": "node esbuild.js", 10 | "build:typedefs": "tsc", 11 | "flatc": "cd src/flat && flatc --gen-object-api --ts rlbot.fbs && echo Remember to update index.ts with all of the classes ending in 'T'" 12 | }, 13 | "keywords": [ 14 | "rl", 15 | "bot", 16 | "rlbot", 17 | "rocket", 18 | "league", 19 | "rocketleague", 20 | "easy", 21 | "typescript", 22 | "ts" 23 | ], 24 | "author": "Simon Lindgren", 25 | "license": "MIT", 26 | "dependencies": { 27 | "colors": "^1.4.0", 28 | "flatbuffers": "^2.0.7" 29 | }, 30 | "devDependencies": { 31 | "@types/flatbuffers": "^1.10.0", 32 | "@types/node": "^20.4.0", 33 | "esbuild": "^0.15.5", 34 | "typescript": "^5.1.6" 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/BotManager.ts: -------------------------------------------------------------------------------- 1 | import "colors"; 2 | import * as Net from "net"; 3 | import { BotClient } from "./BotClient"; 4 | import * as utils from "./utils"; 5 | 6 | interface BotContainer { 7 | [botIndex: string]: any; 8 | } 9 | 10 | class BotManager { 11 | ws: Net.Socket; 12 | bots: BotContainer; 13 | Bot: any; 14 | agentPort: number; 15 | agentIP: string; 16 | logger: utils.Logger = new utils.Logger("Manager"); 17 | 18 | constructor(BotClass: any, agentPort: number, rlbotPort: number = 23234) { 19 | this.Bot = BotClass; 20 | this.bots = {}; 21 | 22 | this.agentPort = agentPort; 23 | this.agentIP = "127.0.0.1"; 24 | 25 | const port = rlbotPort; 26 | const host = "127.0.0.1"; 27 | 28 | this.ws = new Net.Socket(); 29 | 30 | this.logger.log("Socket", "Connecting...".yellow); 31 | this.ws.connect({ port, host }, () => { 32 | this.logger.log("Socket", "Connected".green); 33 | this.start(); 34 | }); 35 | this.ws.on("error", (e) => { 36 | this.logger.log( 37 | "Socket", 38 | "Error when connecting to RLBot, make sure RLBot is running.".red 39 | ); 40 | console.error(e); 41 | process.exit(0); 42 | }); 43 | } 44 | 45 | private async start() { 46 | let server = Net.createServer((socket) => { 47 | socket.setEncoding("ascii"); 48 | socket.on("data", (data) => { 49 | let message = data.toString().split("\n"); 50 | let type = message[0]; 51 | let index: string = message[1]; 52 | switch (type) { 53 | case "add": 54 | if (this.bots[index] != undefined) return; 55 | this.bots[index] = new this.Bot(Number(index), this.ws); 56 | this.bots[index].logger.enabled = false; 57 | 58 | this.logger.log( 59 | "AgentConnection", 60 | ("Added bot with index " + index).green 61 | ); 62 | break; 63 | 64 | case "remove": 65 | if (!this.bots[index]) return; 66 | this.bots[index].kill(); 67 | delete this.bots[index]; 68 | this.logger.log( 69 | "AgentConnection", 70 | ("Removed bot with index " + index).red 71 | ); 72 | break; 73 | 74 | default: 75 | break; 76 | } 77 | }); 78 | }); 79 | 80 | let logger = this.logger; 81 | 82 | server.listen(this.agentPort, this.agentIP, function () { 83 | logger.log("AgentConnection", "Listening to data from Agent"); 84 | 85 | server.on("close", function () { 86 | logger.log("AgentConnection", "Connection closed"); 87 | }); 88 | 89 | server.on("error", function (error) { 90 | logger.log("AgentConnection", "Error: " + error); 91 | }); 92 | }); 93 | 94 | server.on("error", (e: any) => { 95 | if (e.code == "EADDRINUSE") { 96 | this.logger.log( 97 | "AgentConnection", 98 | "Connection closed, port already in use" 99 | ); 100 | throw new Error(`Port is already in use: ${this.agentIP}`); 101 | } 102 | }); 103 | } 104 | } 105 | export { BotManager }; 106 | -------------------------------------------------------------------------------- /src/Controller.ts: -------------------------------------------------------------------------------- 1 | // Credit to SuperVK for big parts of this file 2 | 3 | class Controller { 4 | throttle: number; 5 | steer: number; 6 | pitch: number; 7 | roll: number; 8 | yaw: number; 9 | boost: boolean; 10 | jump: boolean; 11 | handbrake: boolean; 12 | useItem: boolean; 13 | constructor() { 14 | this.throttle = 0; 15 | this.steer = 0; 16 | this.pitch = 0; 17 | this.roll = 0; 18 | this.yaw = 0; 19 | this.boost = false; 20 | this.jump = false; 21 | this.handbrake = false; 22 | this.useItem = false; 23 | } 24 | } 25 | 26 | export default Controller; 27 | -------------------------------------------------------------------------------- /src/ControllerManager.ts: -------------------------------------------------------------------------------- 1 | import { BotClient } from "./BotClient"; 2 | import * as flat from "./flat/rlbot_generated"; 3 | import * as flatbuffers from "flatbuffers"; 4 | import * as utils from "./utils"; 5 | 6 | class Controller { 7 | throttle: number; 8 | steer: number; 9 | pitch: number; 10 | roll: number; 11 | yaw: number; 12 | boost: boolean; 13 | jump: boolean; 14 | handbrake: boolean; 15 | useItem: boolean; 16 | constructor() { 17 | this.throttle = 0; 18 | this.steer = 0; 19 | this.pitch = 0; 20 | this.roll = 0; 21 | this.yaw = 0; 22 | this.boost = false; 23 | this.jump = false; 24 | this.handbrake = false; 25 | this.useItem = false; 26 | } 27 | } 28 | 29 | class ControllerManager { 30 | client: BotClient; 31 | constructor(client: BotClient) { 32 | this.client = client; 33 | } 34 | sendInput(controller: Controller) { 35 | let controllerState = flat.ControllerState; 36 | let playerInput = flat.PlayerInput; 37 | 38 | let builder = new flatbuffers.Builder(1024); 39 | 40 | controllerState.startControllerState(builder); 41 | controllerState.addThrottle(builder, controller.throttle); 42 | controllerState.addSteer(builder, controller.steer); 43 | controllerState.addPitch(builder, controller.pitch); 44 | controllerState.addYaw(builder, controller.yaw); 45 | controllerState.addRoll(builder, controller.roll); 46 | controllerState.addBoost(builder, controller.boost); 47 | controllerState.addJump(builder, controller.jump); 48 | controllerState.addHandbrake(builder, controller.handbrake); 49 | controllerState.addUseItem(builder, controller.useItem); 50 | 51 | let finishedControllerState = controllerState.endControllerState(builder); 52 | 53 | playerInput.startPlayerInput(builder); 54 | playerInput.addPlayerIndex(builder, this.client.botIndex); 55 | playerInput.addControllerState(builder, finishedControllerState); 56 | 57 | let finishedPlayerInput = controllerState.endControllerState(builder); 58 | 59 | builder.finish(finishedPlayerInput); 60 | 61 | let buf = builder.asUint8Array(); 62 | 63 | if (this.client.ws == null) return; 64 | this.client.ws.write(utils.encodeFlat(4, buf)); 65 | } 66 | } 67 | 68 | export { Controller, ControllerManager }; 69 | -------------------------------------------------------------------------------- /src/QuickChats.ts: -------------------------------------------------------------------------------- 1 | // Credit to SuperVK for big parts of this file 2 | 3 | export default { 4 | information: { 5 | IGotIt: 0, 6 | NeedBoost: 1, 7 | TakeTheShot: 2, 8 | Defending: 3, 9 | GoForIt: 4, 10 | Centering: 5, 11 | AllYours: 6, 12 | InPosition: 7, 13 | Incoming: 8, 14 | NiceShot: 9, 15 | GreatPass: 10, 16 | Thanks: 11, 17 | WhatASave: 12, 18 | NiceOne: 13, 19 | WhatAPlay: 14, 20 | GreatClear: 15, 21 | NiceBlock: 16, 22 | }, 23 | compliments: { 24 | NiceShot: 9, 25 | GreatPass: 10, 26 | Thanks: 11, 27 | WhatASave: 12, 28 | NiceOne: 13, 29 | WhatAPlay: 14, 30 | GreatClear: 15, 31 | NiceBlock: 16, 32 | }, 33 | reactions: { 34 | OMG: 17, 35 | Noooo: 18, 36 | Wow: 19, 37 | CloseOne: 20, 38 | NoWay: 21, 39 | HolyCow: 22, 40 | Whew: 23, 41 | Siiiick: 24, 42 | Calculated: 25, 43 | Savage: 26, 44 | Okay: 27, 45 | }, 46 | apologies: { 47 | Cursing: 28, 48 | NoProblem: 29, 49 | Whoops: 30, 50 | Sorry: 31, 51 | MyBad: 32, 52 | Oops: 33, 53 | MyFault: 34, 54 | }, 55 | postGame: { 56 | Gg: 35, 57 | WellPlayed: 36, 58 | ThatWasFun: 37, 59 | Rematch: 38, 60 | OneMoreGame: 39, 61 | WhatAGame: 40, 62 | NiceMoves: 41, 63 | EverybodyDance: 42, 64 | }, 65 | custom: { 66 | /// Waste of CPU cycles 67 | Toxic_WasteCPU: 44, 68 | /// Git gud* 69 | Toxic_GitGut: 45, 70 | /// De-Allocate Yourself 71 | Toxic_DeAlloc: 46, 72 | /// 404: Your skill not found 73 | Toxic_404NoSkill: 47, 74 | /// Get a virus 75 | Toxic_CatchVirus: 48, 76 | /// Passing! 77 | Useful_Passing: 49, 78 | /// Faking! 79 | Useful_Faking: 50, 80 | /// Demoing! 81 | Useful_Demoing: 51, 82 | /// BOOPING 83 | Useful_Bumping: 52, 84 | /// The chances of that was 47525 to 1* 85 | Compliments_TinyChances: 53, 86 | /// Who upped your skill level? 87 | Compliments_SkillLevel: 54, 88 | /// Your programmer should be proud 89 | Compliments_proud: 55, 90 | /// You're the GC of Bots 91 | Compliments_GC: 56, 92 | /// Are you Bot? * 93 | Compliments_Pro: 57, 94 | /// Lag 95 | Custom_Excuses_Lag: 58, 96 | /// Ghost inputs 97 | Custom_Excuses_GhostInputs: 59, 98 | /// RIGGED 99 | Custom_Excuses_Rigged: 60, 100 | /// Mafia plays! 101 | Custom_Toxic_MafiaPlays: 61, 102 | /// Yeet! 103 | Custom_Exclamation_Yeet: 62, 104 | }, 105 | }; 106 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-bounciness-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BallBouncinessOption { 4 | Default = 0, 5 | Low = 1, 6 | High = 2, 7 | Super_High = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-max-speed-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BallMaxSpeedOption { 4 | Default = 0, 5 | Slow = 1, 6 | Fast = 2, 7 | Super_Fast = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-rigid-body-state.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { RigidBodyState, RigidBodyStateT } from '../../rlbot/flat/rigid-body-state'; 6 | 7 | 8 | /** 9 | * Rigid body state for the ball. 10 | */ 11 | export class BallRigidBodyState { 12 | bb: flatbuffers.ByteBuffer|null = null; 13 | bb_pos = 0; 14 | __init(i:number, bb:flatbuffers.ByteBuffer):BallRigidBodyState { 15 | this.bb_pos = i; 16 | this.bb = bb; 17 | return this; 18 | } 19 | 20 | static getRootAsBallRigidBodyState(bb:flatbuffers.ByteBuffer, obj?:BallRigidBodyState):BallRigidBodyState { 21 | return (obj || new BallRigidBodyState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 22 | } 23 | 24 | static getSizePrefixedRootAsBallRigidBodyState(bb:flatbuffers.ByteBuffer, obj?:BallRigidBodyState):BallRigidBodyState { 25 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 26 | return (obj || new BallRigidBodyState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 27 | } 28 | 29 | state(obj?:RigidBodyState):RigidBodyState|null { 30 | const offset = this.bb!.__offset(this.bb_pos, 4); 31 | return offset ? (obj || new RigidBodyState()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; 32 | } 33 | 34 | static startBallRigidBodyState(builder:flatbuffers.Builder) { 35 | builder.startObject(1); 36 | } 37 | 38 | static addState(builder:flatbuffers.Builder, stateOffset:flatbuffers.Offset) { 39 | builder.addFieldOffset(0, stateOffset, 0); 40 | } 41 | 42 | static endBallRigidBodyState(builder:flatbuffers.Builder):flatbuffers.Offset { 43 | const offset = builder.endObject(); 44 | return offset; 45 | } 46 | 47 | static createBallRigidBodyState(builder:flatbuffers.Builder, stateOffset:flatbuffers.Offset):flatbuffers.Offset { 48 | BallRigidBodyState.startBallRigidBodyState(builder); 49 | BallRigidBodyState.addState(builder, stateOffset); 50 | return BallRigidBodyState.endBallRigidBodyState(builder); 51 | } 52 | 53 | unpack(): BallRigidBodyStateT { 54 | return new BallRigidBodyStateT( 55 | (this.state() !== null ? this.state()!.unpack() : null) 56 | ); 57 | } 58 | 59 | 60 | unpackTo(_o: BallRigidBodyStateT): void { 61 | _o.state = (this.state() !== null ? this.state()!.unpack() : null); 62 | } 63 | } 64 | 65 | export class BallRigidBodyStateT { 66 | constructor( 67 | public state: RigidBodyStateT|null = null 68 | ){} 69 | 70 | 71 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 72 | const state = (this.state !== null ? this.state!.pack(builder) : 0); 73 | 74 | return BallRigidBodyState.createBallRigidBodyState(builder, 75 | state 76 | ); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-size-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BallSizeOption { 4 | Default = 0, 5 | Small = 1, 6 | Large = 2, 7 | Gigantic = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-type-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BallTypeOption { 4 | Default = 0, 5 | Cube = 1, 6 | Puck = 2, 7 | Basketball = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/ball-weight-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BallWeightOption { 4 | Default = 0, 5 | Light = 1, 6 | Heavy = 2, 7 | Super_Light = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/bool.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class Bool { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):Bool { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | val():boolean { 17 | return !!this.bb!.readInt8(this.bb_pos); 18 | } 19 | 20 | static sizeOf():number { 21 | return 1; 22 | } 23 | 24 | static createBool(builder:flatbuffers.Builder, val: boolean):flatbuffers.Offset { 25 | builder.prep(1, 1); 26 | builder.writeInt8(+val); 27 | return builder.offset(); 28 | } 29 | 30 | 31 | unpack(): BoolT { 32 | return new BoolT( 33 | this.val() 34 | ); 35 | } 36 | 37 | 38 | unpackTo(_o: BoolT): void { 39 | _o.val = this.val(); 40 | } 41 | } 42 | 43 | export class BoolT { 44 | constructor( 45 | public val: boolean = false 46 | ){} 47 | 48 | 49 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 50 | return Bool.createBool(builder, 51 | this.val 52 | ); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/boost-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BoostOption { 4 | Normal_Boost = 0, 5 | Unlimited_Boost = 1, 6 | Slow_Recharge = 2, 7 | Rapid_Recharge = 3, 8 | No_Boost = 4 9 | } 10 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/boost-pad-state.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class BoostPadState { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):BoostPadState { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsBoostPadState(bb:flatbuffers.ByteBuffer, obj?:BoostPadState):BoostPadState { 17 | return (obj || new BoostPadState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsBoostPadState(bb:flatbuffers.ByteBuffer, obj?:BoostPadState):BoostPadState { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new BoostPadState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | /** 26 | * True if the boost can be picked up 27 | */ 28 | isActive():boolean { 29 | const offset = this.bb!.__offset(this.bb_pos, 4); 30 | return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; 31 | } 32 | 33 | /** 34 | * The number of seconds since the boost has been picked up, or 0.0 if the boost is active. 35 | */ 36 | timer():number { 37 | const offset = this.bb!.__offset(this.bb_pos, 6); 38 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 39 | } 40 | 41 | static startBoostPadState(builder:flatbuffers.Builder) { 42 | builder.startObject(2); 43 | } 44 | 45 | static addIsActive(builder:flatbuffers.Builder, isActive:boolean) { 46 | builder.addFieldInt8(0, +isActive, +false); 47 | } 48 | 49 | static addTimer(builder:flatbuffers.Builder, timer:number) { 50 | builder.addFieldFloat32(1, timer, 0.0); 51 | } 52 | 53 | static endBoostPadState(builder:flatbuffers.Builder):flatbuffers.Offset { 54 | const offset = builder.endObject(); 55 | return offset; 56 | } 57 | 58 | static createBoostPadState(builder:flatbuffers.Builder, isActive:boolean, timer:number):flatbuffers.Offset { 59 | BoostPadState.startBoostPadState(builder); 60 | BoostPadState.addIsActive(builder, isActive); 61 | BoostPadState.addTimer(builder, timer); 62 | return BoostPadState.endBoostPadState(builder); 63 | } 64 | 65 | unpack(): BoostPadStateT { 66 | return new BoostPadStateT( 67 | this.isActive(), 68 | this.timer() 69 | ); 70 | } 71 | 72 | 73 | unpackTo(_o: BoostPadStateT): void { 74 | _o.isActive = this.isActive(); 75 | _o.timer = this.timer(); 76 | } 77 | } 78 | 79 | export class BoostPadStateT { 80 | constructor( 81 | public isActive: boolean = false, 82 | public timer: number = 0.0 83 | ){} 84 | 85 | 86 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 87 | return BoostPadState.createBoostPadState(builder, 88 | this.isActive, 89 | this.timer 90 | ); 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/boost-pad.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 6 | 7 | 8 | export class BoostPad { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):BoostPad { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsBoostPad(bb:flatbuffers.ByteBuffer, obj?:BoostPad):BoostPad { 18 | return (obj || new BoostPad()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsBoostPad(bb:flatbuffers.ByteBuffer, obj?:BoostPad):BoostPad { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new BoostPad()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | location(obj?:Vector3):Vector3|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new Vector3()).__init(this.bb_pos + offset, this.bb!) : null; 29 | } 30 | 31 | isFullBoost():boolean { 32 | const offset = this.bb!.__offset(this.bb_pos, 6); 33 | return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; 34 | } 35 | 36 | static startBoostPad(builder:flatbuffers.Builder) { 37 | builder.startObject(2); 38 | } 39 | 40 | static addLocation(builder:flatbuffers.Builder, locationOffset:flatbuffers.Offset) { 41 | builder.addFieldStruct(0, locationOffset, 0); 42 | } 43 | 44 | static addIsFullBoost(builder:flatbuffers.Builder, isFullBoost:boolean) { 45 | builder.addFieldInt8(1, +isFullBoost, +false); 46 | } 47 | 48 | static endBoostPad(builder:flatbuffers.Builder):flatbuffers.Offset { 49 | const offset = builder.endObject(); 50 | return offset; 51 | } 52 | 53 | static createBoostPad(builder:flatbuffers.Builder, locationOffset:flatbuffers.Offset, isFullBoost:boolean):flatbuffers.Offset { 54 | BoostPad.startBoostPad(builder); 55 | BoostPad.addLocation(builder, locationOffset); 56 | BoostPad.addIsFullBoost(builder, isFullBoost); 57 | return BoostPad.endBoostPad(builder); 58 | } 59 | 60 | unpack(): BoostPadT { 61 | return new BoostPadT( 62 | (this.location() !== null ? this.location()!.unpack() : null), 63 | this.isFullBoost() 64 | ); 65 | } 66 | 67 | 68 | unpackTo(_o: BoostPadT): void { 69 | _o.location = (this.location() !== null ? this.location()!.unpack() : null); 70 | _o.isFullBoost = this.isFullBoost(); 71 | } 72 | } 73 | 74 | export class BoostPadT { 75 | constructor( 76 | public location: Vector3T|null = null, 77 | public isFullBoost: boolean = false 78 | ){} 79 | 80 | 81 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 82 | return BoostPad.createBoostPad(builder, 83 | (this.location !== null ? this.location!.pack(builder) : 0), 84 | this.isFullBoost 85 | ); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/boost-strength-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum BoostStrengthOption { 4 | One = 0, 5 | OneAndAHalf = 1, 6 | Two = 2, 7 | Ten = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/box-shape.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class BoxShape { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):BoxShape { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsBoxShape(bb:flatbuffers.ByteBuffer, obj?:BoxShape):BoxShape { 17 | return (obj || new BoxShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsBoxShape(bb:flatbuffers.ByteBuffer, obj?:BoxShape):BoxShape { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new BoxShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | length():number { 26 | const offset = this.bb!.__offset(this.bb_pos, 4); 27 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 28 | } 29 | 30 | width():number { 31 | const offset = this.bb!.__offset(this.bb_pos, 6); 32 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 33 | } 34 | 35 | height():number { 36 | const offset = this.bb!.__offset(this.bb_pos, 8); 37 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 38 | } 39 | 40 | static startBoxShape(builder:flatbuffers.Builder) { 41 | builder.startObject(3); 42 | } 43 | 44 | static addLength(builder:flatbuffers.Builder, length:number) { 45 | builder.addFieldFloat32(0, length, 0.0); 46 | } 47 | 48 | static addWidth(builder:flatbuffers.Builder, width:number) { 49 | builder.addFieldFloat32(1, width, 0.0); 50 | } 51 | 52 | static addHeight(builder:flatbuffers.Builder, height:number) { 53 | builder.addFieldFloat32(2, height, 0.0); 54 | } 55 | 56 | static endBoxShape(builder:flatbuffers.Builder):flatbuffers.Offset { 57 | const offset = builder.endObject(); 58 | return offset; 59 | } 60 | 61 | static createBoxShape(builder:flatbuffers.Builder, length:number, width:number, height:number):flatbuffers.Offset { 62 | BoxShape.startBoxShape(builder); 63 | BoxShape.addLength(builder, length); 64 | BoxShape.addWidth(builder, width); 65 | BoxShape.addHeight(builder, height); 66 | return BoxShape.endBoxShape(builder); 67 | } 68 | 69 | unpack(): BoxShapeT { 70 | return new BoxShapeT( 71 | this.length(), 72 | this.width(), 73 | this.height() 74 | ); 75 | } 76 | 77 | 78 | unpackTo(_o: BoxShapeT): void { 79 | _o.length = this.length(); 80 | _o.width = this.width(); 81 | _o.height = this.height(); 82 | } 83 | } 84 | 85 | export class BoxShapeT { 86 | constructor( 87 | public length: number = 0.0, 88 | public width: number = 0.0, 89 | public height: number = 0.0 90 | ){} 91 | 92 | 93 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 94 | return BoxShape.createBoxShape(builder, 95 | this.length, 96 | this.width, 97 | this.height 98 | ); 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/collision-shape.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import { BoxShape, BoxShapeT } from '../../rlbot/flat/box-shape'; 4 | import { CylinderShape, CylinderShapeT } from '../../rlbot/flat/cylinder-shape'; 5 | import { SphereShape, SphereShapeT } from '../../rlbot/flat/sphere-shape'; 6 | 7 | 8 | export enum CollisionShape { 9 | NONE = 0, 10 | BoxShape = 1, 11 | SphereShape = 2, 12 | CylinderShape = 3 13 | } 14 | 15 | export function unionToCollisionShape( 16 | type: CollisionShape, 17 | accessor: (obj:BoxShape|CylinderShape|SphereShape) => BoxShape|CylinderShape|SphereShape|null 18 | ): BoxShape|CylinderShape|SphereShape|null { 19 | switch(CollisionShape[type]) { 20 | case 'NONE': return null; 21 | case 'BoxShape': return accessor(new BoxShape())! as BoxShape; 22 | case 'SphereShape': return accessor(new SphereShape())! as SphereShape; 23 | case 'CylinderShape': return accessor(new CylinderShape())! as CylinderShape; 24 | default: return null; 25 | } 26 | } 27 | 28 | export function unionListToCollisionShape( 29 | type: CollisionShape, 30 | accessor: (index: number, obj:BoxShape|CylinderShape|SphereShape) => BoxShape|CylinderShape|SphereShape|null, 31 | index: number 32 | ): BoxShape|CylinderShape|SphereShape|null { 33 | switch(CollisionShape[type]) { 34 | case 'NONE': return null; 35 | case 'BoxShape': return accessor(index, new BoxShape())! as BoxShape; 36 | case 'SphereShape': return accessor(index, new SphereShape())! as SphereShape; 37 | case 'CylinderShape': return accessor(index, new CylinderShape())! as CylinderShape; 38 | default: return null; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/color.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class Color { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):Color { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsColor(bb:flatbuffers.ByteBuffer, obj?:Color):Color { 17 | return (obj || new Color()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsColor(bb:flatbuffers.ByteBuffer, obj?:Color):Color { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new Color()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | a():number { 26 | const offset = this.bb!.__offset(this.bb_pos, 4); 27 | return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; 28 | } 29 | 30 | r():number { 31 | const offset = this.bb!.__offset(this.bb_pos, 6); 32 | return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; 33 | } 34 | 35 | g():number { 36 | const offset = this.bb!.__offset(this.bb_pos, 8); 37 | return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; 38 | } 39 | 40 | b():number { 41 | const offset = this.bb!.__offset(this.bb_pos, 10); 42 | return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; 43 | } 44 | 45 | static startColor(builder:flatbuffers.Builder) { 46 | builder.startObject(4); 47 | } 48 | 49 | static addA(builder:flatbuffers.Builder, a:number) { 50 | builder.addFieldInt8(0, a, 0); 51 | } 52 | 53 | static addR(builder:flatbuffers.Builder, r:number) { 54 | builder.addFieldInt8(1, r, 0); 55 | } 56 | 57 | static addG(builder:flatbuffers.Builder, g:number) { 58 | builder.addFieldInt8(2, g, 0); 59 | } 60 | 61 | static addB(builder:flatbuffers.Builder, b:number) { 62 | builder.addFieldInt8(3, b, 0); 63 | } 64 | 65 | static endColor(builder:flatbuffers.Builder):flatbuffers.Offset { 66 | const offset = builder.endObject(); 67 | return offset; 68 | } 69 | 70 | static createColor(builder:flatbuffers.Builder, a:number, r:number, g:number, b:number):flatbuffers.Offset { 71 | Color.startColor(builder); 72 | Color.addA(builder, a); 73 | Color.addR(builder, r); 74 | Color.addG(builder, g); 75 | Color.addB(builder, b); 76 | return Color.endColor(builder); 77 | } 78 | 79 | unpack(): ColorT { 80 | return new ColorT( 81 | this.a(), 82 | this.r(), 83 | this.g(), 84 | this.b() 85 | ); 86 | } 87 | 88 | 89 | unpackTo(_o: ColorT): void { 90 | _o.a = this.a(); 91 | _o.r = this.r(); 92 | _o.g = this.g(); 93 | _o.b = this.b(); 94 | } 95 | } 96 | 97 | export class ColorT { 98 | constructor( 99 | public a: number = 0, 100 | public r: number = 0, 101 | public g: number = 0, 102 | public b: number = 0 103 | ){} 104 | 105 | 106 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 107 | return Color.createColor(builder, 108 | this.a, 109 | this.r, 110 | this.g, 111 | this.b 112 | ); 113 | } 114 | } 115 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/console-command.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * A console command which we will try to execute inside Rocket League. 9 | * See https://github.com/RLBot/RLBot/wiki/Console-Commands for a list of known commands. 10 | */ 11 | export class ConsoleCommand { 12 | bb: flatbuffers.ByteBuffer|null = null; 13 | bb_pos = 0; 14 | __init(i:number, bb:flatbuffers.ByteBuffer):ConsoleCommand { 15 | this.bb_pos = i; 16 | this.bb = bb; 17 | return this; 18 | } 19 | 20 | static getRootAsConsoleCommand(bb:flatbuffers.ByteBuffer, obj?:ConsoleCommand):ConsoleCommand { 21 | return (obj || new ConsoleCommand()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 22 | } 23 | 24 | static getSizePrefixedRootAsConsoleCommand(bb:flatbuffers.ByteBuffer, obj?:ConsoleCommand):ConsoleCommand { 25 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 26 | return (obj || new ConsoleCommand()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 27 | } 28 | 29 | command():string|null 30 | command(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null 31 | command(optionalEncoding?:any):string|Uint8Array|null { 32 | const offset = this.bb!.__offset(this.bb_pos, 4); 33 | return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; 34 | } 35 | 36 | static startConsoleCommand(builder:flatbuffers.Builder) { 37 | builder.startObject(1); 38 | } 39 | 40 | static addCommand(builder:flatbuffers.Builder, commandOffset:flatbuffers.Offset) { 41 | builder.addFieldOffset(0, commandOffset, 0); 42 | } 43 | 44 | static endConsoleCommand(builder:flatbuffers.Builder):flatbuffers.Offset { 45 | const offset = builder.endObject(); 46 | return offset; 47 | } 48 | 49 | static createConsoleCommand(builder:flatbuffers.Builder, commandOffset:flatbuffers.Offset):flatbuffers.Offset { 50 | ConsoleCommand.startConsoleCommand(builder); 51 | ConsoleCommand.addCommand(builder, commandOffset); 52 | return ConsoleCommand.endConsoleCommand(builder); 53 | } 54 | 55 | unpack(): ConsoleCommandT { 56 | return new ConsoleCommandT( 57 | this.command() 58 | ); 59 | } 60 | 61 | 62 | unpackTo(_o: ConsoleCommandT): void { 63 | _o.command = this.command(); 64 | } 65 | } 66 | 67 | export class ConsoleCommandT { 68 | constructor( 69 | public command: string|Uint8Array|null = null 70 | ){} 71 | 72 | 73 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 74 | const command = (this.command !== null ? builder.createString(this.command!) : 0); 75 | 76 | return ConsoleCommand.createConsoleCommand(builder, 77 | command 78 | ); 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/cylinder-shape.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class CylinderShape { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):CylinderShape { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsCylinderShape(bb:flatbuffers.ByteBuffer, obj?:CylinderShape):CylinderShape { 17 | return (obj || new CylinderShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsCylinderShape(bb:flatbuffers.ByteBuffer, obj?:CylinderShape):CylinderShape { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new CylinderShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | diameter():number { 26 | const offset = this.bb!.__offset(this.bb_pos, 4); 27 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 28 | } 29 | 30 | height():number { 31 | const offset = this.bb!.__offset(this.bb_pos, 6); 32 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 33 | } 34 | 35 | static startCylinderShape(builder:flatbuffers.Builder) { 36 | builder.startObject(2); 37 | } 38 | 39 | static addDiameter(builder:flatbuffers.Builder, diameter:number) { 40 | builder.addFieldFloat32(0, diameter, 0.0); 41 | } 42 | 43 | static addHeight(builder:flatbuffers.Builder, height:number) { 44 | builder.addFieldFloat32(1, height, 0.0); 45 | } 46 | 47 | static endCylinderShape(builder:flatbuffers.Builder):flatbuffers.Offset { 48 | const offset = builder.endObject(); 49 | return offset; 50 | } 51 | 52 | static createCylinderShape(builder:flatbuffers.Builder, diameter:number, height:number):flatbuffers.Offset { 53 | CylinderShape.startCylinderShape(builder); 54 | CylinderShape.addDiameter(builder, diameter); 55 | CylinderShape.addHeight(builder, height); 56 | return CylinderShape.endCylinderShape(builder); 57 | } 58 | 59 | unpack(): CylinderShapeT { 60 | return new CylinderShapeT( 61 | this.diameter(), 62 | this.height() 63 | ); 64 | } 65 | 66 | 67 | unpackTo(_o: CylinderShapeT): void { 68 | _o.diameter = this.diameter(); 69 | _o.height = this.height(); 70 | } 71 | } 72 | 73 | export class CylinderShapeT { 74 | constructor( 75 | public diameter: number = 0.0, 76 | public height: number = 0.0 77 | ){} 78 | 79 | 80 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 81 | return CylinderShape.createCylinderShape(builder, 82 | this.diameter, 83 | this.height 84 | ); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/demolish-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum DemolishOption { 4 | Default = 0, 5 | Disabled = 1, 6 | Friendly_Fire = 2, 7 | On_Contact = 3, 8 | On_Contact_FF = 4 9 | } 10 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/desired-ball-state.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { DesiredPhysics, DesiredPhysicsT } from '../../rlbot/flat/desired-physics'; 6 | 7 | 8 | export class DesiredBallState { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):DesiredBallState { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsDesiredBallState(bb:flatbuffers.ByteBuffer, obj?:DesiredBallState):DesiredBallState { 18 | return (obj || new DesiredBallState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsDesiredBallState(bb:flatbuffers.ByteBuffer, obj?:DesiredBallState):DesiredBallState { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new DesiredBallState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | physics(obj?:DesiredPhysics):DesiredPhysics|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new DesiredPhysics()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; 29 | } 30 | 31 | static startDesiredBallState(builder:flatbuffers.Builder) { 32 | builder.startObject(1); 33 | } 34 | 35 | static addPhysics(builder:flatbuffers.Builder, physicsOffset:flatbuffers.Offset) { 36 | builder.addFieldOffset(0, physicsOffset, 0); 37 | } 38 | 39 | static endDesiredBallState(builder:flatbuffers.Builder):flatbuffers.Offset { 40 | const offset = builder.endObject(); 41 | return offset; 42 | } 43 | 44 | static createDesiredBallState(builder:flatbuffers.Builder, physicsOffset:flatbuffers.Offset):flatbuffers.Offset { 45 | DesiredBallState.startDesiredBallState(builder); 46 | DesiredBallState.addPhysics(builder, physicsOffset); 47 | return DesiredBallState.endDesiredBallState(builder); 48 | } 49 | 50 | unpack(): DesiredBallStateT { 51 | return new DesiredBallStateT( 52 | (this.physics() !== null ? this.physics()!.unpack() : null) 53 | ); 54 | } 55 | 56 | 57 | unpackTo(_o: DesiredBallStateT): void { 58 | _o.physics = (this.physics() !== null ? this.physics()!.unpack() : null); 59 | } 60 | } 61 | 62 | export class DesiredBallStateT { 63 | constructor( 64 | public physics: DesiredPhysicsT|null = null 65 | ){} 66 | 67 | 68 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 69 | const physics = (this.physics !== null ? this.physics!.pack(builder) : 0); 70 | 71 | return DesiredBallState.createDesiredBallState(builder, 72 | physics 73 | ); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/desired-boost-state.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Float, FloatT } from '../../rlbot/flat/float'; 6 | 7 | 8 | export class DesiredBoostState { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):DesiredBoostState { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsDesiredBoostState(bb:flatbuffers.ByteBuffer, obj?:DesiredBoostState):DesiredBoostState { 18 | return (obj || new DesiredBoostState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsDesiredBoostState(bb:flatbuffers.ByteBuffer, obj?:DesiredBoostState):DesiredBoostState { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new DesiredBoostState()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | respawnTime(obj?:Float):Float|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 29 | } 30 | 31 | static startDesiredBoostState(builder:flatbuffers.Builder) { 32 | builder.startObject(1); 33 | } 34 | 35 | static addRespawnTime(builder:flatbuffers.Builder, respawnTimeOffset:flatbuffers.Offset) { 36 | builder.addFieldStruct(0, respawnTimeOffset, 0); 37 | } 38 | 39 | static endDesiredBoostState(builder:flatbuffers.Builder):flatbuffers.Offset { 40 | const offset = builder.endObject(); 41 | return offset; 42 | } 43 | 44 | static createDesiredBoostState(builder:flatbuffers.Builder, respawnTimeOffset:flatbuffers.Offset):flatbuffers.Offset { 45 | DesiredBoostState.startDesiredBoostState(builder); 46 | DesiredBoostState.addRespawnTime(builder, respawnTimeOffset); 47 | return DesiredBoostState.endDesiredBoostState(builder); 48 | } 49 | 50 | unpack(): DesiredBoostStateT { 51 | return new DesiredBoostStateT( 52 | (this.respawnTime() !== null ? this.respawnTime()!.unpack() : null) 53 | ); 54 | } 55 | 56 | 57 | unpackTo(_o: DesiredBoostStateT): void { 58 | _o.respawnTime = (this.respawnTime() !== null ? this.respawnTime()!.unpack() : null); 59 | } 60 | } 61 | 62 | export class DesiredBoostStateT { 63 | constructor( 64 | public respawnTime: FloatT|null = null 65 | ){} 66 | 67 | 68 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 69 | return DesiredBoostState.createDesiredBoostState(builder, 70 | (this.respawnTime !== null ? this.respawnTime!.pack(builder) : 0) 71 | ); 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/dropshot-tile.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { TileState } from '../../rlbot/flat/tile-state'; 6 | 7 | 8 | export class DropshotTile { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):DropshotTile { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsDropshotTile(bb:flatbuffers.ByteBuffer, obj?:DropshotTile):DropshotTile { 18 | return (obj || new DropshotTile()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsDropshotTile(bb:flatbuffers.ByteBuffer, obj?:DropshotTile):DropshotTile { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new DropshotTile()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | /** 27 | * The amount of damage the tile has sustained. 28 | */ 29 | tileState():TileState { 30 | const offset = this.bb!.__offset(this.bb_pos, 4); 31 | return offset ? this.bb!.readInt8(this.bb_pos + offset) : TileState.Unknown; 32 | } 33 | 34 | static startDropshotTile(builder:flatbuffers.Builder) { 35 | builder.startObject(1); 36 | } 37 | 38 | static addTileState(builder:flatbuffers.Builder, tileState:TileState) { 39 | builder.addFieldInt8(0, tileState, TileState.Unknown); 40 | } 41 | 42 | static endDropshotTile(builder:flatbuffers.Builder):flatbuffers.Offset { 43 | const offset = builder.endObject(); 44 | return offset; 45 | } 46 | 47 | static createDropshotTile(builder:flatbuffers.Builder, tileState:TileState):flatbuffers.Offset { 48 | DropshotTile.startDropshotTile(builder); 49 | DropshotTile.addTileState(builder, tileState); 50 | return DropshotTile.endDropshotTile(builder); 51 | } 52 | 53 | unpack(): DropshotTileT { 54 | return new DropshotTileT( 55 | this.tileState() 56 | ); 57 | } 58 | 59 | 60 | unpackTo(_o: DropshotTileT): void { 61 | _o.tileState = this.tileState(); 62 | } 63 | } 64 | 65 | export class DropshotTileT { 66 | constructor( 67 | public tileState: TileState = TileState.Unknown 68 | ){} 69 | 70 | 71 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 72 | return DropshotTile.createDropshotTile(builder, 73 | this.tileState 74 | ); 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/existing-match-behavior.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum ExistingMatchBehavior { 4 | /** 5 | * Restart the match if any match settings differ. This is the default because old RLBot always worked this way. 6 | */ 7 | Restart_If_Different = 0, 8 | 9 | /** 10 | * Always restart the match, even if config is identical 11 | */ 12 | Restart = 1, 13 | 14 | /** 15 | * Never restart an existing match, just try to remove or spawn cars to match the configuration. 16 | * If we are not in the middle of a match, a match will be started. Handy for LAN matches. 17 | */ 18 | Continue_And_Spawn = 2 19 | } 20 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/float.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class Float { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):Float { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | val():number { 17 | return this.bb!.readFloat32(this.bb_pos); 18 | } 19 | 20 | static sizeOf():number { 21 | return 4; 22 | } 23 | 24 | static createFloat(builder:flatbuffers.Builder, val: number):flatbuffers.Offset { 25 | builder.prep(4, 4); 26 | builder.writeFloat32(val); 27 | return builder.offset(); 28 | } 29 | 30 | 31 | unpack(): FloatT { 32 | return new FloatT( 33 | this.val() 34 | ); 35 | } 36 | 37 | 38 | unpackTo(_o: FloatT): void { 39 | _o.val = this.val(); 40 | } 41 | } 42 | 43 | export class FloatT { 44 | constructor( 45 | public val: number = 0.0 46 | ){} 47 | 48 | 49 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 50 | return Float.createFloat(builder, 51 | this.val 52 | ); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/game-map.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum GameMap { 4 | DFHStadium = 0, 5 | Mannfield = 1, 6 | ChampionsField = 2, 7 | UrbanCentral = 3, 8 | BeckwithPark = 4, 9 | UtopiaColiseum = 5, 10 | Wasteland = 6, 11 | NeoTokyo = 7, 12 | AquaDome = 8, 13 | StarbaseArc = 9, 14 | Farmstead = 10, 15 | SaltyShores = 11, 16 | DFHStadium_Stormy = 12, 17 | DFHStadium_Day = 13, 18 | Mannfield_Stormy = 14, 19 | Mannfield_Night = 15, 20 | ChampionsField_Day = 16, 21 | BeckwithPark_Stormy = 17, 22 | BeckwithPark_Midnight = 18, 23 | UrbanCentral_Night = 19, 24 | UrbanCentral_Dawn = 20, 25 | UtopiaColiseum_Dusk = 21, 26 | DFHStadium_Snowy = 22, 27 | Mannfield_Snowy = 23, 28 | UtopiaColiseum_Snowy = 24, 29 | Badlands = 25, 30 | Badlands_Night = 26, 31 | TokyoUnderpass = 27, 32 | Arctagon = 28, 33 | Pillars = 29, 34 | Cosmic = 30, 35 | DoubleGoal = 31, 36 | Octagon = 32, 37 | Underpass = 33, 38 | UtopiaRetro = 34, 39 | Hoops_DunkHouse = 35, 40 | DropShot_Core707 = 36, 41 | ThrowbackStadium = 37, 42 | ForbiddenTemple = 38, 43 | RivalsArena = 39, 44 | Farmstead_Night = 40, 45 | SaltyShores_Night = 41 46 | } 47 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/game-message.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import { PlayerInputChange, PlayerInputChangeT } from '../../rlbot/flat/player-input-change'; 4 | import { PlayerSpectate, PlayerSpectateT } from '../../rlbot/flat/player-spectate'; 5 | import { PlayerStatEvent, PlayerStatEventT } from '../../rlbot/flat/player-stat-event'; 6 | 7 | 8 | export enum GameMessage { 9 | NONE = 0, 10 | PlayerStatEvent = 1, 11 | PlayerSpectate = 2, 12 | PlayerInputChange = 3 13 | } 14 | 15 | export function unionToGameMessage( 16 | type: GameMessage, 17 | accessor: (obj:PlayerInputChange|PlayerSpectate|PlayerStatEvent) => PlayerInputChange|PlayerSpectate|PlayerStatEvent|null 18 | ): PlayerInputChange|PlayerSpectate|PlayerStatEvent|null { 19 | switch(GameMessage[type]) { 20 | case 'NONE': return null; 21 | case 'PlayerStatEvent': return accessor(new PlayerStatEvent())! as PlayerStatEvent; 22 | case 'PlayerSpectate': return accessor(new PlayerSpectate())! as PlayerSpectate; 23 | case 'PlayerInputChange': return accessor(new PlayerInputChange())! as PlayerInputChange; 24 | default: return null; 25 | } 26 | } 27 | 28 | export function unionListToGameMessage( 29 | type: GameMessage, 30 | accessor: (index: number, obj:PlayerInputChange|PlayerSpectate|PlayerStatEvent) => PlayerInputChange|PlayerSpectate|PlayerStatEvent|null, 31 | index: number 32 | ): PlayerInputChange|PlayerSpectate|PlayerStatEvent|null { 33 | switch(GameMessage[type]) { 34 | case 'NONE': return null; 35 | case 'PlayerStatEvent': return accessor(index, new PlayerStatEvent())! as PlayerStatEvent; 36 | case 'PlayerSpectate': return accessor(index, new PlayerSpectate())! as PlayerSpectate; 37 | case 'PlayerInputChange': return accessor(index, new PlayerInputChange())! as PlayerInputChange; 38 | default: return null; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/game-mode.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum GameMode { 4 | Soccer = 0, 5 | Hoops = 1, 6 | Dropshot = 2, 7 | Hockey = 3, 8 | Rumble = 4, 9 | Heatseeker = 5 10 | } 11 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/game-speed-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum GameSpeedOption { 4 | Default = 0, 5 | Slo_Mo = 1, 6 | Time_Warp = 2 7 | } 8 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/gravity-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum GravityOption { 4 | Default = 0, 5 | Low = 1, 6 | High = 2, 7 | Super_High = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/human-player.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * A normal human player 9 | */ 10 | export class HumanPlayer { 11 | bb: flatbuffers.ByteBuffer|null = null; 12 | bb_pos = 0; 13 | __init(i:number, bb:flatbuffers.ByteBuffer):HumanPlayer { 14 | this.bb_pos = i; 15 | this.bb = bb; 16 | return this; 17 | } 18 | 19 | static getRootAsHumanPlayer(bb:flatbuffers.ByteBuffer, obj?:HumanPlayer):HumanPlayer { 20 | return (obj || new HumanPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 21 | } 22 | 23 | static getSizePrefixedRootAsHumanPlayer(bb:flatbuffers.ByteBuffer, obj?:HumanPlayer):HumanPlayer { 24 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 25 | return (obj || new HumanPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 26 | } 27 | 28 | static startHumanPlayer(builder:flatbuffers.Builder) { 29 | builder.startObject(0); 30 | } 31 | 32 | static endHumanPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 33 | const offset = builder.endObject(); 34 | return offset; 35 | } 36 | 37 | static createHumanPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 38 | HumanPlayer.startHumanPlayer(builder); 39 | return HumanPlayer.endHumanPlayer(builder); 40 | } 41 | 42 | unpack(): HumanPlayerT { 43 | return new HumanPlayerT(); 44 | } 45 | 46 | 47 | unpackTo(_o: HumanPlayerT): void {} 48 | } 49 | 50 | export class HumanPlayerT { 51 | constructor(){} 52 | 53 | 54 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 55 | return HumanPlayer.createHumanPlayer(builder); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/match-length.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum MatchLength { 4 | Five_Minutes = 0, 5 | Ten_Minutes = 1, 6 | Twenty_Minutes = 2, 7 | Unlimited = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/max-score.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum MaxScore { 4 | Unlimited = 0, 5 | One_Goal = 1, 6 | Three_Goals = 2, 7 | Five_Goals = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/overtime-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum OvertimeOption { 4 | Unlimited = 0, 5 | Five_Max_First_Score = 1, 6 | Five_Max_Random_Team = 2 7 | } 8 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/party-member-bot-player.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * A player that Rocket League treats as human, e.g. has a dedicated camera and can do training mode, 9 | * but is actually controlled by a bot. 10 | */ 11 | export class PartyMemberBotPlayer { 12 | bb: flatbuffers.ByteBuffer|null = null; 13 | bb_pos = 0; 14 | __init(i:number, bb:flatbuffers.ByteBuffer):PartyMemberBotPlayer { 15 | this.bb_pos = i; 16 | this.bb = bb; 17 | return this; 18 | } 19 | 20 | static getRootAsPartyMemberBotPlayer(bb:flatbuffers.ByteBuffer, obj?:PartyMemberBotPlayer):PartyMemberBotPlayer { 21 | return (obj || new PartyMemberBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 22 | } 23 | 24 | static getSizePrefixedRootAsPartyMemberBotPlayer(bb:flatbuffers.ByteBuffer, obj?:PartyMemberBotPlayer):PartyMemberBotPlayer { 25 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 26 | return (obj || new PartyMemberBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 27 | } 28 | 29 | static startPartyMemberBotPlayer(builder:flatbuffers.Builder) { 30 | builder.startObject(0); 31 | } 32 | 33 | static endPartyMemberBotPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 34 | const offset = builder.endObject(); 35 | return offset; 36 | } 37 | 38 | static createPartyMemberBotPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 39 | PartyMemberBotPlayer.startPartyMemberBotPlayer(builder); 40 | return PartyMemberBotPlayer.endPartyMemberBotPlayer(builder); 41 | } 42 | 43 | unpack(): PartyMemberBotPlayerT { 44 | return new PartyMemberBotPlayerT(); 45 | } 46 | 47 | 48 | unpackTo(_o: PartyMemberBotPlayerT): void {} 49 | } 50 | 51 | export class PartyMemberBotPlayerT { 52 | constructor(){} 53 | 54 | 55 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 56 | return PartyMemberBotPlayer.createPartyMemberBotPlayer(builder); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/player-class.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import { HumanPlayer, HumanPlayerT } from '../../rlbot/flat/human-player'; 4 | import { PartyMemberBotPlayer, PartyMemberBotPlayerT } from '../../rlbot/flat/party-member-bot-player'; 5 | import { PsyonixBotPlayer, PsyonixBotPlayerT } from '../../rlbot/flat/psyonix-bot-player'; 6 | import { RLBotPlayer, RLBotPlayerT } from '../../rlbot/flat/rlbot-player'; 7 | 8 | 9 | export enum PlayerClass { 10 | NONE = 0, 11 | RLBotPlayer = 1, 12 | HumanPlayer = 2, 13 | PsyonixBotPlayer = 3, 14 | PartyMemberBotPlayer = 4 15 | } 16 | 17 | export function unionToPlayerClass( 18 | type: PlayerClass, 19 | accessor: (obj:HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer) => HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer|null 20 | ): HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer|null { 21 | switch(PlayerClass[type]) { 22 | case 'NONE': return null; 23 | case 'RLBotPlayer': return accessor(new RLBotPlayer())! as RLBotPlayer; 24 | case 'HumanPlayer': return accessor(new HumanPlayer())! as HumanPlayer; 25 | case 'PsyonixBotPlayer': return accessor(new PsyonixBotPlayer())! as PsyonixBotPlayer; 26 | case 'PartyMemberBotPlayer': return accessor(new PartyMemberBotPlayer())! as PartyMemberBotPlayer; 27 | default: return null; 28 | } 29 | } 30 | 31 | export function unionListToPlayerClass( 32 | type: PlayerClass, 33 | accessor: (index: number, obj:HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer) => HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer|null, 34 | index: number 35 | ): HumanPlayer|PartyMemberBotPlayer|PsyonixBotPlayer|RLBotPlayer|null { 36 | switch(PlayerClass[type]) { 37 | case 'NONE': return null; 38 | case 'RLBotPlayer': return accessor(index, new RLBotPlayer())! as RLBotPlayer; 39 | case 'HumanPlayer': return accessor(index, new HumanPlayer())! as HumanPlayer; 40 | case 'PsyonixBotPlayer': return accessor(index, new PsyonixBotPlayer())! as PsyonixBotPlayer; 41 | case 'PartyMemberBotPlayer': return accessor(index, new PartyMemberBotPlayer())! as PartyMemberBotPlayer; 42 | default: return null; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/player-input.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { ControllerState, ControllerStateT } from '../../rlbot/flat/controller-state'; 6 | 7 | 8 | export class PlayerInput { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):PlayerInput { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsPlayerInput(bb:flatbuffers.ByteBuffer, obj?:PlayerInput):PlayerInput { 18 | return (obj || new PlayerInput()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsPlayerInput(bb:flatbuffers.ByteBuffer, obj?:PlayerInput):PlayerInput { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new PlayerInput()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | playerIndex():number { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; 29 | } 30 | 31 | controllerState(obj?:ControllerState):ControllerState|null { 32 | const offset = this.bb!.__offset(this.bb_pos, 6); 33 | return offset ? (obj || new ControllerState()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; 34 | } 35 | 36 | static startPlayerInput(builder:flatbuffers.Builder) { 37 | builder.startObject(2); 38 | } 39 | 40 | static addPlayerIndex(builder:flatbuffers.Builder, playerIndex:number) { 41 | builder.addFieldInt32(0, playerIndex, 0); 42 | } 43 | 44 | static addControllerState(builder:flatbuffers.Builder, controllerStateOffset:flatbuffers.Offset) { 45 | builder.addFieldOffset(1, controllerStateOffset, 0); 46 | } 47 | 48 | static endPlayerInput(builder:flatbuffers.Builder):flatbuffers.Offset { 49 | const offset = builder.endObject(); 50 | return offset; 51 | } 52 | 53 | 54 | unpack(): PlayerInputT { 55 | return new PlayerInputT( 56 | this.playerIndex(), 57 | (this.controllerState() !== null ? this.controllerState()!.unpack() : null) 58 | ); 59 | } 60 | 61 | 62 | unpackTo(_o: PlayerInputT): void { 63 | _o.playerIndex = this.playerIndex(); 64 | _o.controllerState = (this.controllerState() !== null ? this.controllerState()!.unpack() : null); 65 | } 66 | } 67 | 68 | export class PlayerInputT { 69 | constructor( 70 | public playerIndex: number = 0, 71 | public controllerState: ControllerStateT|null = null 72 | ){} 73 | 74 | 75 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 76 | const controllerState = (this.controllerState !== null ? this.controllerState!.pack(builder) : 0); 77 | 78 | PlayerInput.startPlayerInput(builder); 79 | PlayerInput.addPlayerIndex(builder, this.playerIndex); 80 | PlayerInput.addControllerState(builder, controllerState); 81 | 82 | return PlayerInput.endPlayerInput(builder); 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/player-spectate.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * Notification when the local player is spectating another player. 9 | */ 10 | export class PlayerSpectate { 11 | bb: flatbuffers.ByteBuffer|null = null; 12 | bb_pos = 0; 13 | __init(i:number, bb:flatbuffers.ByteBuffer):PlayerSpectate { 14 | this.bb_pos = i; 15 | this.bb = bb; 16 | return this; 17 | } 18 | 19 | static getRootAsPlayerSpectate(bb:flatbuffers.ByteBuffer, obj?:PlayerSpectate):PlayerSpectate { 20 | return (obj || new PlayerSpectate()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 21 | } 22 | 23 | static getSizePrefixedRootAsPlayerSpectate(bb:flatbuffers.ByteBuffer, obj?:PlayerSpectate):PlayerSpectate { 24 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 25 | return (obj || new PlayerSpectate()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 26 | } 27 | 28 | /** 29 | * index of the player that is being spectated. Will be -1 if not spectating anyone. 30 | */ 31 | playerIndex():number { 32 | const offset = this.bb!.__offset(this.bb_pos, 4); 33 | return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; 34 | } 35 | 36 | static startPlayerSpectate(builder:flatbuffers.Builder) { 37 | builder.startObject(1); 38 | } 39 | 40 | static addPlayerIndex(builder:flatbuffers.Builder, playerIndex:number) { 41 | builder.addFieldInt32(0, playerIndex, 0); 42 | } 43 | 44 | static endPlayerSpectate(builder:flatbuffers.Builder):flatbuffers.Offset { 45 | const offset = builder.endObject(); 46 | return offset; 47 | } 48 | 49 | static createPlayerSpectate(builder:flatbuffers.Builder, playerIndex:number):flatbuffers.Offset { 50 | PlayerSpectate.startPlayerSpectate(builder); 51 | PlayerSpectate.addPlayerIndex(builder, playerIndex); 52 | return PlayerSpectate.endPlayerSpectate(builder); 53 | } 54 | 55 | unpack(): PlayerSpectateT { 56 | return new PlayerSpectateT( 57 | this.playerIndex() 58 | ); 59 | } 60 | 61 | 62 | unpackTo(_o: PlayerSpectateT): void { 63 | _o.playerIndex = this.playerIndex(); 64 | } 65 | } 66 | 67 | export class PlayerSpectateT { 68 | constructor( 69 | public playerIndex: number = 0 70 | ){} 71 | 72 | 73 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 74 | return PlayerSpectate.createPlayerSpectate(builder, 75 | this.playerIndex 76 | ); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/prediction-slice.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Physics, PhysicsT } from '../../rlbot/flat/physics'; 6 | 7 | 8 | export class PredictionSlice { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):PredictionSlice { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsPredictionSlice(bb:flatbuffers.ByteBuffer, obj?:PredictionSlice):PredictionSlice { 18 | return (obj || new PredictionSlice()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsPredictionSlice(bb:flatbuffers.ByteBuffer, obj?:PredictionSlice):PredictionSlice { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new PredictionSlice()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | /** 27 | * The moment in game time that this prediction corresponds to. 28 | * This corresponds to 'secondsElapsed' in the GameInfo table. 29 | */ 30 | gameSeconds():number { 31 | const offset = this.bb!.__offset(this.bb_pos, 4); 32 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 33 | } 34 | 35 | /** 36 | * The predicted location and motion of the object. 37 | */ 38 | physics(obj?:Physics):Physics|null { 39 | const offset = this.bb!.__offset(this.bb_pos, 6); 40 | return offset ? (obj || new Physics()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; 41 | } 42 | 43 | static startPredictionSlice(builder:flatbuffers.Builder) { 44 | builder.startObject(2); 45 | } 46 | 47 | static addGameSeconds(builder:flatbuffers.Builder, gameSeconds:number) { 48 | builder.addFieldFloat32(0, gameSeconds, 0.0); 49 | } 50 | 51 | static addPhysics(builder:flatbuffers.Builder, physicsOffset:flatbuffers.Offset) { 52 | builder.addFieldOffset(1, physicsOffset, 0); 53 | } 54 | 55 | static endPredictionSlice(builder:flatbuffers.Builder):flatbuffers.Offset { 56 | const offset = builder.endObject(); 57 | return offset; 58 | } 59 | 60 | 61 | unpack(): PredictionSliceT { 62 | return new PredictionSliceT( 63 | this.gameSeconds(), 64 | (this.physics() !== null ? this.physics()!.unpack() : null) 65 | ); 66 | } 67 | 68 | 69 | unpackTo(_o: PredictionSliceT): void { 70 | _o.gameSeconds = this.gameSeconds(); 71 | _o.physics = (this.physics() !== null ? this.physics()!.unpack() : null); 72 | } 73 | } 74 | 75 | export class PredictionSliceT { 76 | constructor( 77 | public gameSeconds: number = 0.0, 78 | public physics: PhysicsT|null = null 79 | ){} 80 | 81 | 82 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 83 | const physics = (this.physics !== null ? this.physics!.pack(builder) : 0); 84 | 85 | PredictionSlice.startPredictionSlice(builder); 86 | PredictionSlice.addGameSeconds(builder, this.gameSeconds); 87 | PredictionSlice.addPhysics(builder, physics); 88 | 89 | return PredictionSlice.endPredictionSlice(builder); 90 | } 91 | } 92 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/psyonix-bot-player.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * A psyonix bot, e.g. All Star bot 9 | */ 10 | export class PsyonixBotPlayer { 11 | bb: flatbuffers.ByteBuffer|null = null; 12 | bb_pos = 0; 13 | __init(i:number, bb:flatbuffers.ByteBuffer):PsyonixBotPlayer { 14 | this.bb_pos = i; 15 | this.bb = bb; 16 | return this; 17 | } 18 | 19 | static getRootAsPsyonixBotPlayer(bb:flatbuffers.ByteBuffer, obj?:PsyonixBotPlayer):PsyonixBotPlayer { 20 | return (obj || new PsyonixBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 21 | } 22 | 23 | static getSizePrefixedRootAsPsyonixBotPlayer(bb:flatbuffers.ByteBuffer, obj?:PsyonixBotPlayer):PsyonixBotPlayer { 24 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 25 | return (obj || new PsyonixBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 26 | } 27 | 28 | botSkill():number { 29 | const offset = this.bb!.__offset(this.bb_pos, 4); 30 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 31 | } 32 | 33 | static startPsyonixBotPlayer(builder:flatbuffers.Builder) { 34 | builder.startObject(1); 35 | } 36 | 37 | static addBotSkill(builder:flatbuffers.Builder, botSkill:number) { 38 | builder.addFieldFloat32(0, botSkill, 0.0); 39 | } 40 | 41 | static endPsyonixBotPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 42 | const offset = builder.endObject(); 43 | return offset; 44 | } 45 | 46 | static createPsyonixBotPlayer(builder:flatbuffers.Builder, botSkill:number):flatbuffers.Offset { 47 | PsyonixBotPlayer.startPsyonixBotPlayer(builder); 48 | PsyonixBotPlayer.addBotSkill(builder, botSkill); 49 | return PsyonixBotPlayer.endPsyonixBotPlayer(builder); 50 | } 51 | 52 | unpack(): PsyonixBotPlayerT { 53 | return new PsyonixBotPlayerT( 54 | this.botSkill() 55 | ); 56 | } 57 | 58 | 59 | unpackTo(_o: PsyonixBotPlayerT): void { 60 | _o.botSkill = this.botSkill(); 61 | } 62 | } 63 | 64 | export class PsyonixBotPlayerT { 65 | constructor( 66 | public botSkill: number = 0.0 67 | ){} 68 | 69 | 70 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 71 | return PsyonixBotPlayer.createPsyonixBotPlayer(builder, 72 | this.botSkill 73 | ); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/quaternion.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * Expresses the rotation state of an object. 9 | * Learn about quaternions here: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation 10 | * You can tinker with them here to build an intuition: https://quaternions.online/ 11 | */ 12 | export class Quaternion { 13 | bb: flatbuffers.ByteBuffer|null = null; 14 | bb_pos = 0; 15 | __init(i:number, bb:flatbuffers.ByteBuffer):Quaternion { 16 | this.bb_pos = i; 17 | this.bb = bb; 18 | return this; 19 | } 20 | 21 | x():number { 22 | return this.bb!.readFloat32(this.bb_pos); 23 | } 24 | 25 | y():number { 26 | return this.bb!.readFloat32(this.bb_pos + 4); 27 | } 28 | 29 | z():number { 30 | return this.bb!.readFloat32(this.bb_pos + 8); 31 | } 32 | 33 | w():number { 34 | return this.bb!.readFloat32(this.bb_pos + 12); 35 | } 36 | 37 | static sizeOf():number { 38 | return 16; 39 | } 40 | 41 | static createQuaternion(builder:flatbuffers.Builder, x: number, y: number, z: number, w: number):flatbuffers.Offset { 42 | builder.prep(4, 16); 43 | builder.writeFloat32(w); 44 | builder.writeFloat32(z); 45 | builder.writeFloat32(y); 46 | builder.writeFloat32(x); 47 | return builder.offset(); 48 | } 49 | 50 | 51 | unpack(): QuaternionT { 52 | return new QuaternionT( 53 | this.x(), 54 | this.y(), 55 | this.z(), 56 | this.w() 57 | ); 58 | } 59 | 60 | 61 | unpackTo(_o: QuaternionT): void { 62 | _o.x = this.x(); 63 | _o.y = this.y(); 64 | _o.z = this.z(); 65 | _o.w = this.w(); 66 | } 67 | } 68 | 69 | export class QuaternionT { 70 | constructor( 71 | public x: number = 0.0, 72 | public y: number = 0.0, 73 | public z: number = 0.0, 74 | public w: number = 0.0 75 | ){} 76 | 77 | 78 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 79 | return Quaternion.createQuaternion(builder, 80 | this.x, 81 | this.y, 82 | this.z, 83 | this.w 84 | ); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/quick-chat-messages.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { QuickChat, QuickChatT } from '../../rlbot/flat/quick-chat'; 6 | 7 | 8 | export class QuickChatMessages { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):QuickChatMessages { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsQuickChatMessages(bb:flatbuffers.ByteBuffer, obj?:QuickChatMessages):QuickChatMessages { 18 | return (obj || new QuickChatMessages()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsQuickChatMessages(bb:flatbuffers.ByteBuffer, obj?:QuickChatMessages):QuickChatMessages { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new QuickChatMessages()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | messages(index: number, obj?:QuickChat):QuickChat|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new QuickChat()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; 29 | } 30 | 31 | messagesLength():number { 32 | const offset = this.bb!.__offset(this.bb_pos, 4); 33 | return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; 34 | } 35 | 36 | static startQuickChatMessages(builder:flatbuffers.Builder) { 37 | builder.startObject(1); 38 | } 39 | 40 | static addMessages(builder:flatbuffers.Builder, messagesOffset:flatbuffers.Offset) { 41 | builder.addFieldOffset(0, messagesOffset, 0); 42 | } 43 | 44 | static createMessagesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { 45 | builder.startVector(4, data.length, 4); 46 | for (let i = data.length - 1; i >= 0; i--) { 47 | builder.addOffset(data[i]!); 48 | } 49 | return builder.endVector(); 50 | } 51 | 52 | static startMessagesVector(builder:flatbuffers.Builder, numElems:number) { 53 | builder.startVector(4, numElems, 4); 54 | } 55 | 56 | static endQuickChatMessages(builder:flatbuffers.Builder):flatbuffers.Offset { 57 | const offset = builder.endObject(); 58 | return offset; 59 | } 60 | 61 | static createQuickChatMessages(builder:flatbuffers.Builder, messagesOffset:flatbuffers.Offset):flatbuffers.Offset { 62 | QuickChatMessages.startQuickChatMessages(builder); 63 | QuickChatMessages.addMessages(builder, messagesOffset); 64 | return QuickChatMessages.endQuickChatMessages(builder); 65 | } 66 | 67 | unpack(): QuickChatMessagesT { 68 | return new QuickChatMessagesT( 69 | this.bb!.createObjList(this.messages.bind(this), this.messagesLength()) 70 | ); 71 | } 72 | 73 | 74 | unpackTo(_o: QuickChatMessagesT): void { 75 | _o.messages = this.bb!.createObjList(this.messages.bind(this), this.messagesLength()); 76 | } 77 | } 78 | 79 | export class QuickChatMessagesT { 80 | constructor( 81 | public messages: (QuickChatT)[] = [] 82 | ){} 83 | 84 | 85 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 86 | const messages = QuickChatMessages.createMessagesVector(builder, builder.createObjectOffsetList(this.messages)); 87 | 88 | return QuickChatMessages.createQuickChatMessages(builder, 89 | messages 90 | ); 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/quick-chat-selection.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum QuickChatSelection { 4 | Information_IGotIt = 0, 5 | Information_NeedBoost = 1, 6 | Information_TakeTheShot = 2, 7 | Information_Defending = 3, 8 | Information_GoForIt = 4, 9 | Information_Centering = 5, 10 | Information_AllYours = 6, 11 | Information_InPosition = 7, 12 | Information_Incoming = 8, 13 | Compliments_NiceShot = 9, 14 | Compliments_GreatPass = 10, 15 | Compliments_Thanks = 11, 16 | Compliments_WhatASave = 12, 17 | Compliments_NiceOne = 13, 18 | Compliments_WhatAPlay = 14, 19 | Compliments_GreatClear = 15, 20 | Compliments_NiceBlock = 16, 21 | Reactions_OMG = 17, 22 | Reactions_Noooo = 18, 23 | Reactions_Wow = 19, 24 | Reactions_CloseOne = 20, 25 | Reactions_NoWay = 21, 26 | Reactions_HolyCow = 22, 27 | Reactions_Whew = 23, 28 | Reactions_Siiiick = 24, 29 | Reactions_Calculated = 25, 30 | Reactions_Savage = 26, 31 | Reactions_Okay = 27, 32 | Apologies_Cursing = 28, 33 | Apologies_NoProblem = 29, 34 | Apologies_Whoops = 30, 35 | Apologies_Sorry = 31, 36 | Apologies_MyBad = 32, 37 | Apologies_Oops = 33, 38 | Apologies_MyFault = 34, 39 | PostGame_Gg = 35, 40 | PostGame_WellPlayed = 36, 41 | PostGame_ThatWasFun = 37, 42 | PostGame_Rematch = 38, 43 | PostGame_OneMoreGame = 39, 44 | PostGame_WhatAGame = 40, 45 | PostGame_NiceMoves = 41, 46 | PostGame_EverybodyDance = 42, 47 | 48 | /** 49 | * Custom text chats made by bot makers 50 | */ 51 | MaxPysonixQuickChatPresets = 43, 52 | 53 | /** 54 | * Waste of CPU cycles 55 | */ 56 | Custom_Toxic_WasteCPU = 44, 57 | 58 | /** 59 | * Git gud* 60 | */ 61 | Custom_Toxic_GitGut = 45, 62 | 63 | /** 64 | * De-Allocate Yourself 65 | */ 66 | Custom_Toxic_DeAlloc = 46, 67 | 68 | /** 69 | * 404: Your skill not found 70 | */ 71 | Custom_Toxic_404NoSkill = 47, 72 | 73 | /** 74 | * Get a virus 75 | */ 76 | Custom_Toxic_CatchVirus = 48, 77 | 78 | /** 79 | * Passing! 80 | */ 81 | Custom_Useful_Passing = 49, 82 | 83 | /** 84 | * Faking! 85 | */ 86 | Custom_Useful_Faking = 50, 87 | 88 | /** 89 | * Demoing! 90 | */ 91 | Custom_Useful_Demoing = 51, 92 | 93 | /** 94 | * BOOPING 95 | */ 96 | Custom_Useful_Bumping = 52, 97 | 98 | /** 99 | * The chances of that was 47525 to 1* 100 | */ 101 | Custom_Compliments_TinyChances = 53, 102 | 103 | /** 104 | * Who upped your skill level? 105 | */ 106 | Custom_Compliments_SkillLevel = 54, 107 | 108 | /** 109 | * Your programmer should be proud 110 | */ 111 | Custom_Compliments_proud = 55, 112 | 113 | /** 114 | * You're the GC of Bots 115 | */ 116 | Custom_Compliments_GC = 56, 117 | 118 | /** 119 | * Are you Bot? * 120 | */ 121 | Custom_Compliments_Pro = 57, 122 | 123 | /** 124 | * Lag 125 | */ 126 | Custom_Excuses_Lag = 58, 127 | 128 | /** 129 | * Ghost inputs 130 | */ 131 | Custom_Excuses_GhostInputs = 59, 132 | 133 | /** 134 | * RIGGED 135 | */ 136 | Custom_Excuses_Rigged = 60, 137 | 138 | /** 139 | * Mafia plays! 140 | */ 141 | Custom_Toxic_MafiaPlays = 61, 142 | 143 | /** 144 | * Yeet! 145 | */ 146 | Custom_Exclamation_Yeet = 62 147 | } 148 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/render-type.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum RenderType { 4 | DrawLine2D = 1, 5 | DrawLine3D = 2, 6 | DrawLine2D_3D = 3, 7 | DrawRect2D = 4, 8 | DrawRect3D = 5, 9 | DrawString2D = 6, 10 | DrawString3D = 7, 11 | DrawCenteredRect3D = 8 12 | } 13 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/respawn-time-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum RespawnTimeOption { 4 | Three_Seconds = 0, 5 | Two_Seconds = 1, 6 | One_Seconds = 2, 7 | Disable_Goal_Reset = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/rlbot-player.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * A bot controlled by the RLBot framework 9 | */ 10 | export class RLBotPlayer { 11 | bb: flatbuffers.ByteBuffer|null = null; 12 | bb_pos = 0; 13 | __init(i:number, bb:flatbuffers.ByteBuffer):RLBotPlayer { 14 | this.bb_pos = i; 15 | this.bb = bb; 16 | return this; 17 | } 18 | 19 | static getRootAsRLBotPlayer(bb:flatbuffers.ByteBuffer, obj?:RLBotPlayer):RLBotPlayer { 20 | return (obj || new RLBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 21 | } 22 | 23 | static getSizePrefixedRootAsRLBotPlayer(bb:flatbuffers.ByteBuffer, obj?:RLBotPlayer):RLBotPlayer { 24 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 25 | return (obj || new RLBotPlayer()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 26 | } 27 | 28 | static startRLBotPlayer(builder:flatbuffers.Builder) { 29 | builder.startObject(0); 30 | } 31 | 32 | static endRLBotPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 33 | const offset = builder.endObject(); 34 | return offset; 35 | } 36 | 37 | static createRLBotPlayer(builder:flatbuffers.Builder):flatbuffers.Offset { 38 | RLBotPlayer.startRLBotPlayer(builder); 39 | return RLBotPlayer.endRLBotPlayer(builder); 40 | } 41 | 42 | unpack(): RLBotPlayerT { 43 | return new RLBotPlayerT(); 44 | } 45 | 46 | 47 | unpackTo(_o: RLBotPlayerT): void {} 48 | } 49 | 50 | export class RLBotPlayerT { 51 | constructor(){} 52 | 53 | 54 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 55 | return RLBotPlayer.createRLBotPlayer(builder); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/rotator-partial.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Float, FloatT } from '../../rlbot/flat/float'; 6 | 7 | 8 | export class RotatorPartial { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):RotatorPartial { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsRotatorPartial(bb:flatbuffers.ByteBuffer, obj?:RotatorPartial):RotatorPartial { 18 | return (obj || new RotatorPartial()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsRotatorPartial(bb:flatbuffers.ByteBuffer, obj?:RotatorPartial):RotatorPartial { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new RotatorPartial()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | pitch(obj?:Float):Float|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 29 | } 30 | 31 | yaw(obj?:Float):Float|null { 32 | const offset = this.bb!.__offset(this.bb_pos, 6); 33 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 34 | } 35 | 36 | roll(obj?:Float):Float|null { 37 | const offset = this.bb!.__offset(this.bb_pos, 8); 38 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 39 | } 40 | 41 | static startRotatorPartial(builder:flatbuffers.Builder) { 42 | builder.startObject(3); 43 | } 44 | 45 | static addPitch(builder:flatbuffers.Builder, pitchOffset:flatbuffers.Offset) { 46 | builder.addFieldStruct(0, pitchOffset, 0); 47 | } 48 | 49 | static addYaw(builder:flatbuffers.Builder, yawOffset:flatbuffers.Offset) { 50 | builder.addFieldStruct(1, yawOffset, 0); 51 | } 52 | 53 | static addRoll(builder:flatbuffers.Builder, rollOffset:flatbuffers.Offset) { 54 | builder.addFieldStruct(2, rollOffset, 0); 55 | } 56 | 57 | static endRotatorPartial(builder:flatbuffers.Builder):flatbuffers.Offset { 58 | const offset = builder.endObject(); 59 | return offset; 60 | } 61 | 62 | 63 | unpack(): RotatorPartialT { 64 | return new RotatorPartialT( 65 | (this.pitch() !== null ? this.pitch()!.unpack() : null), 66 | (this.yaw() !== null ? this.yaw()!.unpack() : null), 67 | (this.roll() !== null ? this.roll()!.unpack() : null) 68 | ); 69 | } 70 | 71 | 72 | unpackTo(_o: RotatorPartialT): void { 73 | _o.pitch = (this.pitch() !== null ? this.pitch()!.unpack() : null); 74 | _o.yaw = (this.yaw() !== null ? this.yaw()!.unpack() : null); 75 | _o.roll = (this.roll() !== null ? this.roll()!.unpack() : null); 76 | } 77 | } 78 | 79 | export class RotatorPartialT { 80 | constructor( 81 | public pitch: FloatT|null = null, 82 | public yaw: FloatT|null = null, 83 | public roll: FloatT|null = null 84 | ){} 85 | 86 | 87 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 88 | RotatorPartial.startRotatorPartial(builder); 89 | RotatorPartial.addPitch(builder, (this.pitch !== null ? this.pitch!.pack(builder) : 0)); 90 | RotatorPartial.addYaw(builder, (this.yaw !== null ? this.yaw!.pack(builder) : 0)); 91 | RotatorPartial.addRoll(builder, (this.roll !== null ? this.roll!.pack(builder) : 0)); 92 | 93 | return RotatorPartial.endRotatorPartial(builder); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/rotator.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | /** 8 | * Expresses the rotation state of an object in Euler angles, with values in radians. 9 | */ 10 | export class Rotator { 11 | bb: flatbuffers.ByteBuffer|null = null; 12 | bb_pos = 0; 13 | __init(i:number, bb:flatbuffers.ByteBuffer):Rotator { 14 | this.bb_pos = i; 15 | this.bb = bb; 16 | return this; 17 | } 18 | 19 | pitch():number { 20 | return this.bb!.readFloat32(this.bb_pos); 21 | } 22 | 23 | yaw():number { 24 | return this.bb!.readFloat32(this.bb_pos + 4); 25 | } 26 | 27 | roll():number { 28 | return this.bb!.readFloat32(this.bb_pos + 8); 29 | } 30 | 31 | static sizeOf():number { 32 | return 12; 33 | } 34 | 35 | static createRotator(builder:flatbuffers.Builder, pitch: number, yaw: number, roll: number):flatbuffers.Offset { 36 | builder.prep(4, 12); 37 | builder.writeFloat32(roll); 38 | builder.writeFloat32(yaw); 39 | builder.writeFloat32(pitch); 40 | return builder.offset(); 41 | } 42 | 43 | 44 | unpack(): RotatorT { 45 | return new RotatorT( 46 | this.pitch(), 47 | this.yaw(), 48 | this.roll() 49 | ); 50 | } 51 | 52 | 53 | unpackTo(_o: RotatorT): void { 54 | _o.pitch = this.pitch(); 55 | _o.yaw = this.yaw(); 56 | _o.roll = this.roll(); 57 | } 58 | } 59 | 60 | export class RotatorT { 61 | constructor( 62 | public pitch: number = 0.0, 63 | public yaw: number = 0.0, 64 | public roll: number = 0.0 65 | ){} 66 | 67 | 68 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 69 | return Rotator.createRotator(builder, 70 | this.pitch, 71 | this.yaw, 72 | this.roll 73 | ); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/rumble-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum RumbleOption { 4 | No_Rumble = 0, 5 | Default = 1, 6 | Slow = 2, 7 | Civilized = 3, 8 | Destruction_Derby = 4, 9 | Spring_Loaded = 5, 10 | Spikes_Only = 6, 11 | Spike_Rush = 7 12 | } 13 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/series-length-option.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum SeriesLengthOption { 4 | Unlimited = 0, 5 | Three_Games = 1, 6 | Five_Games = 2, 7 | Seven_Games = 3 8 | } 9 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/sphere-shape.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class SphereShape { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):SphereShape { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsSphereShape(bb:flatbuffers.ByteBuffer, obj?:SphereShape):SphereShape { 17 | return (obj || new SphereShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsSphereShape(bb:flatbuffers.ByteBuffer, obj?:SphereShape):SphereShape { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new SphereShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | diameter():number { 26 | const offset = this.bb!.__offset(this.bb_pos, 4); 27 | return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; 28 | } 29 | 30 | static startSphereShape(builder:flatbuffers.Builder) { 31 | builder.startObject(1); 32 | } 33 | 34 | static addDiameter(builder:flatbuffers.Builder, diameter:number) { 35 | builder.addFieldFloat32(0, diameter, 0.0); 36 | } 37 | 38 | static endSphereShape(builder:flatbuffers.Builder):flatbuffers.Offset { 39 | const offset = builder.endObject(); 40 | return offset; 41 | } 42 | 43 | static createSphereShape(builder:flatbuffers.Builder, diameter:number):flatbuffers.Offset { 44 | SphereShape.startSphereShape(builder); 45 | SphereShape.addDiameter(builder, diameter); 46 | return SphereShape.endSphereShape(builder); 47 | } 48 | 49 | unpack(): SphereShapeT { 50 | return new SphereShapeT( 51 | this.diameter() 52 | ); 53 | } 54 | 55 | 56 | unpackTo(_o: SphereShapeT): void { 57 | _o.diameter = this.diameter(); 58 | } 59 | } 60 | 61 | export class SphereShapeT { 62 | constructor( 63 | public diameter: number = 0.0 64 | ){} 65 | 66 | 67 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 68 | return SphereShape.createSphereShape(builder, 69 | this.diameter 70 | ); 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/team-info.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class TeamInfo { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):TeamInfo { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | static getRootAsTeamInfo(bb:flatbuffers.ByteBuffer, obj?:TeamInfo):TeamInfo { 17 | return (obj || new TeamInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 18 | } 19 | 20 | static getSizePrefixedRootAsTeamInfo(bb:flatbuffers.ByteBuffer, obj?:TeamInfo):TeamInfo { 21 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 22 | return (obj || new TeamInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 23 | } 24 | 25 | teamIndex():number { 26 | const offset = this.bb!.__offset(this.bb_pos, 4); 27 | return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; 28 | } 29 | 30 | /** 31 | * number of goals scored. 32 | */ 33 | score():number { 34 | const offset = this.bb!.__offset(this.bb_pos, 6); 35 | return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; 36 | } 37 | 38 | static startTeamInfo(builder:flatbuffers.Builder) { 39 | builder.startObject(2); 40 | } 41 | 42 | static addTeamIndex(builder:flatbuffers.Builder, teamIndex:number) { 43 | builder.addFieldInt32(0, teamIndex, 0); 44 | } 45 | 46 | static addScore(builder:flatbuffers.Builder, score:number) { 47 | builder.addFieldInt32(1, score, 0); 48 | } 49 | 50 | static endTeamInfo(builder:flatbuffers.Builder):flatbuffers.Offset { 51 | const offset = builder.endObject(); 52 | return offset; 53 | } 54 | 55 | static createTeamInfo(builder:flatbuffers.Builder, teamIndex:number, score:number):flatbuffers.Offset { 56 | TeamInfo.startTeamInfo(builder); 57 | TeamInfo.addTeamIndex(builder, teamIndex); 58 | TeamInfo.addScore(builder, score); 59 | return TeamInfo.endTeamInfo(builder); 60 | } 61 | 62 | unpack(): TeamInfoT { 63 | return new TeamInfoT( 64 | this.teamIndex(), 65 | this.score() 66 | ); 67 | } 68 | 69 | 70 | unpackTo(_o: TeamInfoT): void { 71 | _o.teamIndex = this.teamIndex(); 72 | _o.score = this.score(); 73 | } 74 | } 75 | 76 | export class TeamInfoT { 77 | constructor( 78 | public teamIndex: number = 0, 79 | public score: number = 0 80 | ){} 81 | 82 | 83 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 84 | return TeamInfo.createTeamInfo(builder, 85 | this.teamIndex, 86 | this.score 87 | ); 88 | } 89 | } 90 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/tile-state.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | export enum TileState { 4 | Unknown = 0, 5 | 6 | /** 7 | * The default state of the tiles. 8 | */ 9 | Filled = 1, 10 | 11 | /** 12 | * The state when a tile has been damaged. 13 | */ 14 | Damaged = 2, 15 | 16 | /** 17 | * The state of a tile when it is open and a goal can be scored. 18 | */ 19 | Open = 3 20 | } 21 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/tiny-ball.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Vector3, Vector3T } from '../../rlbot/flat/vector3'; 6 | 7 | 8 | /** 9 | * A minimal version of the ball, useful when bandwidth needs to be conserved. 10 | */ 11 | export class TinyBall { 12 | bb: flatbuffers.ByteBuffer|null = null; 13 | bb_pos = 0; 14 | __init(i:number, bb:flatbuffers.ByteBuffer):TinyBall { 15 | this.bb_pos = i; 16 | this.bb = bb; 17 | return this; 18 | } 19 | 20 | static getRootAsTinyBall(bb:flatbuffers.ByteBuffer, obj?:TinyBall):TinyBall { 21 | return (obj || new TinyBall()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 22 | } 23 | 24 | static getSizePrefixedRootAsTinyBall(bb:flatbuffers.ByteBuffer, obj?:TinyBall):TinyBall { 25 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 26 | return (obj || new TinyBall()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 27 | } 28 | 29 | location(obj?:Vector3):Vector3|null { 30 | const offset = this.bb!.__offset(this.bb_pos, 4); 31 | return offset ? (obj || new Vector3()).__init(this.bb_pos + offset, this.bb!) : null; 32 | } 33 | 34 | velocity(obj?:Vector3):Vector3|null { 35 | const offset = this.bb!.__offset(this.bb_pos, 6); 36 | return offset ? (obj || new Vector3()).__init(this.bb_pos + offset, this.bb!) : null; 37 | } 38 | 39 | static startTinyBall(builder:flatbuffers.Builder) { 40 | builder.startObject(2); 41 | } 42 | 43 | static addLocation(builder:flatbuffers.Builder, locationOffset:flatbuffers.Offset) { 44 | builder.addFieldStruct(0, locationOffset, 0); 45 | } 46 | 47 | static addVelocity(builder:flatbuffers.Builder, velocityOffset:flatbuffers.Offset) { 48 | builder.addFieldStruct(1, velocityOffset, 0); 49 | } 50 | 51 | static endTinyBall(builder:flatbuffers.Builder):flatbuffers.Offset { 52 | const offset = builder.endObject(); 53 | return offset; 54 | } 55 | 56 | 57 | unpack(): TinyBallT { 58 | return new TinyBallT( 59 | (this.location() !== null ? this.location()!.unpack() : null), 60 | (this.velocity() !== null ? this.velocity()!.unpack() : null) 61 | ); 62 | } 63 | 64 | 65 | unpackTo(_o: TinyBallT): void { 66 | _o.location = (this.location() !== null ? this.location()!.unpack() : null); 67 | _o.velocity = (this.velocity() !== null ? this.velocity()!.unpack() : null); 68 | } 69 | } 70 | 71 | export class TinyBallT { 72 | constructor( 73 | public location: Vector3T|null = null, 74 | public velocity: Vector3T|null = null 75 | ){} 76 | 77 | 78 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 79 | TinyBall.startTinyBall(builder); 80 | TinyBall.addLocation(builder, (this.location !== null ? this.location!.pack(builder) : 0)); 81 | TinyBall.addVelocity(builder, (this.velocity !== null ? this.velocity!.pack(builder) : 0)); 82 | 83 | return TinyBall.endTinyBall(builder); 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/vector3.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | 6 | 7 | export class Vector3 { 8 | bb: flatbuffers.ByteBuffer|null = null; 9 | bb_pos = 0; 10 | __init(i:number, bb:flatbuffers.ByteBuffer):Vector3 { 11 | this.bb_pos = i; 12 | this.bb = bb; 13 | return this; 14 | } 15 | 16 | x():number { 17 | return this.bb!.readFloat32(this.bb_pos); 18 | } 19 | 20 | y():number { 21 | return this.bb!.readFloat32(this.bb_pos + 4); 22 | } 23 | 24 | z():number { 25 | return this.bb!.readFloat32(this.bb_pos + 8); 26 | } 27 | 28 | static sizeOf():number { 29 | return 12; 30 | } 31 | 32 | static createVector3(builder:flatbuffers.Builder, x: number, y: number, z: number):flatbuffers.Offset { 33 | builder.prep(4, 12); 34 | builder.writeFloat32(z); 35 | builder.writeFloat32(y); 36 | builder.writeFloat32(x); 37 | return builder.offset(); 38 | } 39 | 40 | 41 | unpack(): Vector3T { 42 | return new Vector3T( 43 | this.x(), 44 | this.y(), 45 | this.z() 46 | ); 47 | } 48 | 49 | 50 | unpackTo(_o: Vector3T): void { 51 | _o.x = this.x(); 52 | _o.y = this.y(); 53 | _o.z = this.z(); 54 | } 55 | } 56 | 57 | export class Vector3T { 58 | constructor( 59 | public x: number = 0.0, 60 | public y: number = 0.0, 61 | public z: number = 0.0 62 | ){} 63 | 64 | 65 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 66 | return Vector3.createVector3(builder, 67 | this.x, 68 | this.y, 69 | this.z 70 | ); 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/flat/rlbot/flat/vector3partial.ts: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | import * as flatbuffers from 'flatbuffers'; 4 | 5 | import { Float, FloatT } from '../../rlbot/flat/float'; 6 | 7 | 8 | export class Vector3Partial { 9 | bb: flatbuffers.ByteBuffer|null = null; 10 | bb_pos = 0; 11 | __init(i:number, bb:flatbuffers.ByteBuffer):Vector3Partial { 12 | this.bb_pos = i; 13 | this.bb = bb; 14 | return this; 15 | } 16 | 17 | static getRootAsVector3Partial(bb:flatbuffers.ByteBuffer, obj?:Vector3Partial):Vector3Partial { 18 | return (obj || new Vector3Partial()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 19 | } 20 | 21 | static getSizePrefixedRootAsVector3Partial(bb:flatbuffers.ByteBuffer, obj?:Vector3Partial):Vector3Partial { 22 | bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); 23 | return (obj || new Vector3Partial()).__init(bb.readInt32(bb.position()) + bb.position(), bb); 24 | } 25 | 26 | x(obj?:Float):Float|null { 27 | const offset = this.bb!.__offset(this.bb_pos, 4); 28 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 29 | } 30 | 31 | y(obj?:Float):Float|null { 32 | const offset = this.bb!.__offset(this.bb_pos, 6); 33 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 34 | } 35 | 36 | z(obj?:Float):Float|null { 37 | const offset = this.bb!.__offset(this.bb_pos, 8); 38 | return offset ? (obj || new Float()).__init(this.bb_pos + offset, this.bb!) : null; 39 | } 40 | 41 | static startVector3Partial(builder:flatbuffers.Builder) { 42 | builder.startObject(3); 43 | } 44 | 45 | static addX(builder:flatbuffers.Builder, xOffset:flatbuffers.Offset) { 46 | builder.addFieldStruct(0, xOffset, 0); 47 | } 48 | 49 | static addY(builder:flatbuffers.Builder, yOffset:flatbuffers.Offset) { 50 | builder.addFieldStruct(1, yOffset, 0); 51 | } 52 | 53 | static addZ(builder:flatbuffers.Builder, zOffset:flatbuffers.Offset) { 54 | builder.addFieldStruct(2, zOffset, 0); 55 | } 56 | 57 | static endVector3Partial(builder:flatbuffers.Builder):flatbuffers.Offset { 58 | const offset = builder.endObject(); 59 | return offset; 60 | } 61 | 62 | 63 | unpack(): Vector3PartialT { 64 | return new Vector3PartialT( 65 | (this.x() !== null ? this.x()!.unpack() : null), 66 | (this.y() !== null ? this.y()!.unpack() : null), 67 | (this.z() !== null ? this.z()!.unpack() : null) 68 | ); 69 | } 70 | 71 | 72 | unpackTo(_o: Vector3PartialT): void { 73 | _o.x = (this.x() !== null ? this.x()!.unpack() : null); 74 | _o.y = (this.y() !== null ? this.y()!.unpack() : null); 75 | _o.z = (this.z() !== null ? this.z()!.unpack() : null); 76 | } 77 | } 78 | 79 | export class Vector3PartialT { 80 | constructor( 81 | public x: FloatT|null = null, 82 | public y: FloatT|null = null, 83 | public z: FloatT|null = null 84 | ){} 85 | 86 | 87 | pack(builder:flatbuffers.Builder): flatbuffers.Offset { 88 | Vector3Partial.startVector3Partial(builder); 89 | Vector3Partial.addX(builder, (this.x !== null ? this.x!.pack(builder) : 0)); 90 | Vector3Partial.addY(builder, (this.y !== null ? this.y!.pack(builder) : 0)); 91 | Vector3Partial.addZ(builder, (this.z !== null ? this.z!.pack(builder) : 0)); 92 | 93 | return Vector3Partial.endVector3Partial(builder); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /src/index.ts: -------------------------------------------------------------------------------- 1 | import { BotClient as Client } from "./BotClient"; 2 | import { BotManager as Manager } from "./BotManager"; 3 | import quickChats from "./QuickChats"; 4 | 5 | export { Client, Manager, quickChats }; 6 | export * from "./ControllerManager"; 7 | export * from "./RenderManager"; 8 | export * from "./GameState"; 9 | export { 10 | BallInfoT, 11 | BallPredictionT, 12 | BallRigidBodyStateT, 13 | BoolT, 14 | BoostPadT, 15 | BoostPadStateT, 16 | BoxShapeT, 17 | ColorT, 18 | ConsoleCommandT, 19 | ControllerStateT, 20 | CylinderShapeT, 21 | DesiredBallStateT, 22 | DesiredBoostStateT, 23 | DesiredCarStateT, 24 | DesiredGameInfoStateT, 25 | DesiredGameStateT, 26 | DesiredPhysicsT, 27 | DropShotBallInfoT, 28 | DropshotTileT, 29 | FieldInfoT, 30 | FloatT, 31 | GameInfoT, 32 | GameMessageWrapperT, 33 | GameTickPacketT, 34 | GoalInfoT, 35 | HumanPlayerT, 36 | LoadoutPaintT, 37 | MatchSettingsT, 38 | MessagePacketT, 39 | MutatorSettingsT, 40 | PartyMemberBotPlayerT, 41 | PhysicsT, 42 | PlayerConfigurationT, 43 | PlayerInfoT, 44 | PlayerInputT, 45 | PlayerInputChangeT, 46 | PlayerLoadoutT, 47 | PlayerRigidBodyStateT, 48 | PlayerSpectateT, 49 | PlayerStatEventT, 50 | PredictionSliceT, 51 | PsyonixBotPlayerT, 52 | QuaternionT, 53 | QuickChatT, 54 | QuickChatMessagesT, 55 | RLBotPlayerT, 56 | ReadyMessageT, 57 | RenderGroupT, 58 | RenderMessageT, 59 | RigidBodyStateT, 60 | RigidBodyTickT, 61 | RotatorT, 62 | RotatorPartialT, 63 | ScoreInfoT, 64 | SphereShapeT, 65 | TeamInfoT, 66 | TinyBallT, 67 | TinyPacketT, 68 | TinyPlayerT, 69 | TouchT, 70 | } from "./flat/rlbot_generated"; 71 | --------------------------------------------------------------------------------