Portable Open Game Protocol 0.0.19

Making games should feel like playing games.

Introducing the POG protocol

The POG Protocol defines language-neutral binary representations of Inputs and State.

This allows us to create a portable game loop that can be run in browser or any major game engine.

$3

* browser - use wasm to prototype and playtest with hot reloading

* standalone / mobile / console - use ffi to bring your game loop into any game engine

* online multiplayer - run your game loop on any web server or exchange pogp binary input peer to peer

$3

* input representations are based on web standards

* state representations use open standards (WIP)

* games that adopt the protocol can benefit from shared solutions for common functionality

$3

* immersion during the development process is sacrosanct. making games feels like playing games.

* the POG protocol is designed to be zero-copy, zero-alloc per frame

* you can continue to use and benefit from all the great game making tools and rendering you use today for mobile, browser, standalone and console targets

Goals

The goal of the POG protocol is to help create better games for players, to make game development more accessible, and to reduce crunch.

The goal is for anyone familiar with basic software development to create a game using the protocol today, using the languages and tools they're already familiar with.

Web and app developers benefit from industry-wide adoption of open technology like the HTTP protocol and Linux.

Game developers have typically suffered from a more closed source mindset, with many shared solutions for crucial low-level problems locked behind paywalls or other privileged access.

I love games, and I believe that by embracing open standards and shared solutions across languages and game engines, there can be a better world for developers and players of games.

Code Example (typescript/browser)

``ts import { GameLoop, MarshalInput, KeyboardSnapshot } from 'pogp';

const keyboard = new KeyboardSnapshot(); const heroElement = document.body.appendChild('div') as HTMLElement;

let state = { hero: { x: 0, y: 0 } };

new GameLoop((frame, now, inputs) => { // read inputs from binary buffer keyboard.addInput(MarshalInput.decodeKeyboard(inputs));

// run update loop if (keyboard.isKeyDown(Key.KeyD)) { state.hero.x += 10; } else if (keyboard.isKeyDown(Key.KeyA)) { state.hero.x -= 10; }

// render to screen heroElement.style.transform =translateX(${state.hero.x}px); })`

`Interactive Examples`


---
Pong
https://pogprotocol.com
Project Status
The Pog Protocol is in a pre-alpha state. The protocol itself is still being defined, and client libraries currently only exist for rust.
We are looking for domain experts to contribute to libraries for each major game engine and runtime environment.

If you are interested in contributing or adding an environment to the list, please open a github issue or drop me a line on discord nu11#1111 or neil at nullent.com

`Path to 1.0`


---
* Define state protocol
* Define rendering protocol
* Flesh out existing libraries
	* rust
	* typescript
	* unity c#
* Add client libraries
	* c++
	* modern c#
* Add online multiplayer demo
	* in browser
	* in a game engine
* Add engine demos beyond unity
	* unreal engine
	* godot
	* bevy
Client Libraries

---
__Game Logic Client Libraries__

__Rendering Client Libraries__

Contributors:

@ns - @neilsarkar

`Reference`


---
Inputs
Inputs contain the state of the input at the current frame.
Whenever possible, representations are based on open standards.
Gamepad (a.k.a. Controller) Input
Touch Input
Mouse Input
Keyboard Input
$3
Gamepad input represents what's commonly called a "Controller".
We extend the open standard https://developer.mozilla.org/en-US/docs/Web/API/Gamepad with a standard for generic positional identifiers.
JSON Schema | JSON Example
Binary Schema | Binary Example
#### Gamepad JSON Schema
type

* This will be an Input Type set to gamepad

id

* The Gamepad.id of the gamepad

vendorId

* The vendor id of the gamepad.

productId

* The product id of the gamepad.

vendorName

* A human readable name for the vendor, e.g. Nintendo, Microsoft, Sony etc

productName

* A human readable name for the product, e.g. Left joy-con, Xbox Series S, Dualshock 5

buttons

* An array of Button states label* * the text printed on the button, e.g.Triangle, A, ZRvalue* * int representing the percentage depressed with four digits of precision touched* * boolean representing whether button is touched position* * string enum representing button position , e.g.left-face-top, right-shoulder-front

axes

* An array of Axesstates hand* * string enum representing hand intended to be used with joystick:left | right | unknownvalue* * an array of two signed longs representing thex and y position of the thumbstick

#### Gamepad JSON Example

`js { type: 'Gamepad', id: 'Stadia Controller rev. A (STANDARD GAMEPAD Vendor: 18d1 Product: 9400)' vendorName: "Google", productName: "Stadia",

buttons: [ { label: 'A', position: 'right-face-bottom', value: 100000 // 100% }, { label: 'B', position: 'right-face-right', value: 500600 // 50.06% }, { label: 'X', position: 'right-face-left', touched: true, value: 0 }, { label: 'Y', position: 'right-face-top', value: 0 }, { label: 'L1', position: 'left-shoulder-front', value: 0 }, { label: 'L2', position: 'left-shoulder-back', value: 0 }, // ... ], axes: [ { hand: 'left', value: [ 0n, // x-axis idle 2147483647n // y-axis max up ] }, { hand: 'right', value: [ -2147483647, // x-axis full left -2147483647 // y-axis full down ] } ], }`

#### Gamepad Binary Schema

#### Gamepad Button Binary Schema

data | example | type | index | length (bytes) |-|-|-|-|-|position | 2 | byte([ButtonPosition]()) | 0 | 1value | 100000 | uint32| 1 | 4label | "A" | string | 5 | 64

#### Gamepad Axes Binary Schema

data | example | type | index | length (bytes) |-|-|-|-|-|hand | 1 | byte(Hand) | 0 | 1x | 100000 | int64| 1 | 64y | 100000 | int64 | 65 | 64

`$3`

Keyboard keys are represented using the w3 standard, supporting standard 101, Korean, Brazilian and Japanese keyboards.

https://www.toptal.com/developers/keycode

https://www.w3.org/TR/uievents-code/#keyboard-mac

`js { type: "keyboard", keys: [ 27, 65 ] }`

`$3`

`js { type: "touch", resolution: [0,0], fingers: [ // there will always be at least one element { position: [0,0], pressure: 0 } ] }`

`$3`

`js { type: "mouse", resolution: [1920, 1080], position: [100, 100], buttons: [ { id: 'left', down: true }, { id :'right', down: false }, ], wheels: [ { id: 'scroll', delta: [0,20,0] } ] }`

Custom (WIP)

`js { type: "custom", id: 'my-flightstick', fields: [ { id: 'whammybar', values: [420,69] }, { id: 'something', values: [0] } ] }`

`State (WIP)`

Game state represents the state of the game. This is going to be custom for each game.

int is short for int32

`js { // this is the pog protocol major version pog: 0, // this is the pog protocol minor version pogMinorVersion: 1

// these are the members of the state. fields: { // primitives timeLeft: 'int',

// objects defined below player: 'player', level: 'level',

// arrays of primitives or objects enemy: ['enemy'],

// dictionaries of primitives or objects levelClearTimes: { int: 'int' }, levelsById: { int: 'level' } },

// these are objects defined by the game objects: [ player: { position: 'vector2', score: 'int', jump: 'bool', myIntList: ['int'], } enemy: { position: 'vector2', health: 'int', }, level: { id: 'int', tiles: ['tile'] }, tile: { position: 'vector2', type: 'int' } ], }`

The json state will exist in both the logic and the renderer, so object structures are not shared, only the values

data | example | type | index | length (bytes) |-|-|-|-|-|pog major version | 0 | int| 0 | 4pog minor version | 1 | int | 4 | 4

`* fields are done alphabetically

* vectors and fixed length structs are inline

* arrays, lists and dictionaries are represented as an integer of their total length

* array, list and dictionary reading happens after reading the primitives in the state

* strings are utf32 encoded`

tic tac toe example:

`json { // 0 is not taken, 1 is X 2 is O board: [ 0, 0, 0, 0, 2, 0 1, 0, 0 ] }`

`// fields uint 9 // length of array

// arrays, lists and dictionaries ubyte 0 // top left ubyte 0 // top middle ubyte 0 // top right ubyte 0 // middle left ubyte 2 // middle middle ubyte 1 // bottom left ubyte 0 // bottom middle ubyte 0 // bottom right`

pong example:`{ isGameOver: false, player1: { position: [0, 100], score: 1 } player2: { position: [100,-100], score: 0 }, ball: { position: [50, 50] } }`

Client libraries:

`(json schema) => file of native object

(binary data, json schema) => native object

(native object, json schema) => binary data`

e.g. csharp

`public static string StateFile(string json, string path) { // outputs a .cs file to path that has the structure of the json file }

#### Button Position Enum

#### Input Type Enum

#### Hand Enum

#### Key Enum

Portable Open Game Protocol 0.0.19

Making games should feel like playing games.

Introducing the POG protocol

The POG Protocol defines language-neutral binary representations of Inputs and State.

This allows us to create a portable game loop that can be run in browser or any major game engine.

$3

* browser - use wasm to prototype and playtest with hot reloading

* standalone / mobile / console - use ffi to bring your game loop into any game engine

* online multiplayer - run your game loop on any web server or exchange pogp binary input peer to peer

$3

* input representations are based on web standards

* state representations use open standards (WIP)

* games that adopt the protocol can benefit from shared solutions for common functionality

$3

* immersion during the development process is sacrosanct. making games feels like playing games.

* the POG protocol is designed to be zero-copy, zero-alloc per frame

* you can continue to use and benefit from all the great game making tools and rendering you use today for mobile, browser, standalone and console targets

Goals

The goal of the POG protocol is to help create better games for players, to make game development more accessible, and to reduce crunch.

The goal is for anyone familiar with basic software development to create a game using the protocol today, using the languages and tools they're already familiar with.

Web and app developers benefit from industry-wide adoption of open technology like the HTTP protocol and Linux.

Game developers have typically suffered from a more closed source mindset, with many shared solutions for crucial low-level problems locked behind paywalls or other privileged access.

I love games, and I believe that by embracing open standards and shared solutions across languages and game engines, there can be a better world for developers and players of games.

Code Example (typescript/browser)

``ts import { GameLoop, MarshalInput, KeyboardSnapshot } from 'pogp';

const keyboard = new KeyboardSnapshot(); const heroElement = document.body.appendChild('div') as HTMLElement;

let state = { hero: { x: 0, y: 0 } };

new GameLoop((frame, now, inputs) => { // read inputs from binary buffer keyboard.addInput(MarshalInput.decodeKeyboard(inputs));

// run update loop if (keyboard.isKeyDown(Key.KeyD)) { state.hero.x += 10; } else if (keyboard.isKeyDown(Key.KeyA)) { state.hero.x -= 10; }

// render to screen heroElement.style.transform =translateX(${state.hero.x}px); })`

`Interactive Examples`


---
Pong
https://pogprotocol.com
Project Status
The Pog Protocol is in a pre-alpha state. The protocol itself is still being defined, and client libraries currently only exist for rust.
We are looking for domain experts to contribute to libraries for each major game engine and runtime environment.

If you are interested in contributing or adding an environment to the list, please open a github issue or drop me a line on discord nu11#1111 or neil at nullent.com

`Path to 1.0`


---
* Define state protocol
* Define rendering protocol
* Flesh out existing libraries
	* rust
	* typescript
	* unity c#
* Add client libraries
	* c++
	* modern c#
* Add online multiplayer demo
	* in browser
	* in a game engine
* Add engine demos beyond unity
	* unreal engine
	* godot
	* bevy
Client Libraries

---
__Game Logic Client Libraries__

__Rendering Client Libraries__

Contributors:

@ns - @neilsarkar

`Reference`


---
Inputs
Inputs contain the state of the input at the current frame.
Whenever possible, representations are based on open standards.
Gamepad (a.k.a. Controller) Input
Touch Input
Mouse Input
Keyboard Input
$3
Gamepad input represents what's commonly called a "Controller".
We extend the open standard https://developer.mozilla.org/en-US/docs/Web/API/Gamepad with a standard for generic positional identifiers.
JSON Schema | JSON Example
Binary Schema | Binary Example
#### Gamepad JSON Schema
type

* This will be an Input Type set to gamepad

id

* The Gamepad.id of the gamepad

vendorId

* The vendor id of the gamepad.

productId

* The product id of the gamepad.

vendorName

* A human readable name for the vendor, e.g. Nintendo, Microsoft, Sony etc

productName

* A human readable name for the product, e.g. Left joy-con, Xbox Series S, Dualshock 5

buttons

axes

#### Gamepad JSON Example

`js { type: 'Gamepad', id: 'Stadia Controller rev. A (STANDARD GAMEPAD Vendor: 18d1 Product: 9400)' vendorName: "Google", productName: "Stadia",

#### Gamepad Binary Schema

#### Gamepad Button Binary Schema

data | example | type | index | length (bytes) |-|-|-|-|-|position | 2 | byte([ButtonPosition]()) | 0 | 1value | 100000 | uint32| 1 | 4label | "A" | string | 5 | 64

#### Gamepad Axes Binary Schema

data | example | type | index | length (bytes) |-|-|-|-|-|hand | 1 | byte(Hand) | 0 | 1x | 100000 | int64| 1 | 64y | 100000 | int64 | 65 | 64

`$3`

Keyboard keys are represented using the w3 standard, supporting standard 101, Korean, Brazilian and Japanese keyboards.

https://www.toptal.com/developers/keycode

https://www.w3.org/TR/uievents-code/#keyboard-mac

`js { type: "keyboard", keys: [ 27, 65 ] }`

`$3`

`js { type: "touch", resolution: [0,0], fingers: [ // there will always be at least one element { position: [0,0], pressure: 0 } ] }`

`$3`

`js { type: "mouse", resolution: [1920, 1080], position: [100, 100], buttons: [ { id: 'left', down: true }, { id :'right', down: false }, ], wheels: [ { id: 'scroll', delta: [0,20,0] } ] }`

Custom (WIP)

`js { type: "custom", id: 'my-flightstick', fields: [ { id: 'whammybar', values: [420,69] }, { id: 'something', values: [0] } ] }`

`State (WIP)`

Game state represents the state of the game. This is going to be custom for each game.

int is short for int32

`js { // this is the pog protocol major version pog: 0, // this is the pog protocol minor version pogMinorVersion: 1

// these are the members of the state. fields: { // primitives timeLeft: 'int',

// objects defined below player: 'player', level: 'level',

// arrays of primitives or objects enemy: ['enemy'],

// dictionaries of primitives or objects levelClearTimes: { int: 'int' }, levelsById: { int: 'level' } },

The json state will exist in both the logic and the renderer, so object structures are not shared, only the values

data | example | type | index | length (bytes) |-|-|-|-|-|pog major version | 0 | int| 0 | 4pog minor version | 1 | int | 4 | 4

`* fields are done alphabetically

* vectors and fixed length structs are inline

* arrays, lists and dictionaries are represented as an integer of their total length

* array, list and dictionary reading happens after reading the primitives in the state

* strings are utf32 encoded`

tic tac toe example:

`json { // 0 is not taken, 1 is X 2 is O board: [ 0, 0, 0, 0, 2, 0 1, 0, 0 ] }`

`// fields uint 9 // length of array

pong example:`{ isGameOver: false, player1: { position: [0, 100], score: 1 } player2: { position: [100,-100], score: 0 }, ball: { position: [50, 50] } }`

Client libraries:

`(json schema) => file of native object

(binary data, json schema) => native object

(native object, json schema) => binary data`

e.g. csharp

`public static string StateFile(string json, string path) { // outputs a .cs file to path that has the structure of the json file }

#### Button Position Enum

#### Input Type Enum

#### Hand Enum

#### Key Enum