@hytopia.com/server-protocol 1.0.71 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hytopia.com/server-protocol",
-  "version": "1.0.71",
+  "version": "1.1.0",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/packets/PacketCore.ts

@@ -20,24 +20,25 @@ import type { JSONSchemaType, ValidateFunction } from 'ajv';
 export enum PacketId {
   // Standard Inbound Packet Types: 0 - 31 range
   SYNC_REQUEST = 0,
-  DEBUG_CONFIG = 1,
-  INPUT = 2,
-  STATE_REQUEST = 3,
-  CHAT_MESSAGE_SEND = 4,
+  INPUT = 1,
+  STATE_REQUEST = 2,
+  CHAT_MESSAGE_SEND = 3,
 
   // Standard Outbound Packet Types: 32 - 127 range
   SYNC_RESPONSE = 32,
   BLOCK = 33,
-  BLOCK_TYPE_REGISTRY = 34,
+  BLOCK_BATCH = 34,
   BLOCK_TYPE = 35,
-  CHUNK = 36,
-  ENTITY = 37,
-  SIMULATION = 38,
-  WORLD = 39,
-  CHAT_MESSAGE = 40,
+  BLOCK_TYPE_BATCH = 36,
+  CHUNK = 37,
+  CHUNK_BATCH = 38,
+  ENTITY = 39,
+  ENTITY_BATCH = 40,
+  WORLD = 41,
+  CHAT_MESSAGE = 42,
 
   // Debug Inbound Packet Types: 128 - 191 range
-  // NONE atm, start at 128
+  DEBUG_CONFIG = 128,
 
   // Debug Outbound Packet Types: 192 - 255 range
   PHYSICS_DEBUG_RENDER = 192

package/packets/inbound/index.ts

@@ -1,6 +1,5 @@
 export * from './ChatMessageSend';
 export * from './DebugConfig';
-export * from './SyncRequest';
 export * from './Input';
 export * from './StateRequest';
 export * from './SyncRequest';

package/packets/outbound/BlockBatch.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { blockBatchSchema } from '../../schemas/BlockBatch';
+import type { BlockBatchSchema } from '../../schemas/BlockBatch';
+import type { WorldTick } from '../PacketCore';
+
+export type BlockBatchPacket = IPacket<typeof PacketId.BLOCK_BATCH, BlockBatchSchema> & [WorldTick];
+
+export const blockBatchPacketDefinition = definePacket(
+  PacketId.BLOCK_BATCH,
+  blockBatchSchema,
+);

package/packets/outbound/BlockTypeBatch.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { blockTypeBatchSchema } from '../../schemas/BlockTypeBatch';
+import type { BlockTypeBatchSchema } from '../../schemas/BlockTypeBatch';
+import type { WorldTick } from '../PacketCore';
+
+export type BlockTypeBatchPacket = IPacket<typeof PacketId.BLOCK_TYPE_BATCH, BlockTypeBatchSchema> & [WorldTick];
+
+export const blockTypeBatchPacketDefinition = definePacket(
+  PacketId.BLOCK_TYPE_BATCH,
+  blockTypeBatchSchema,
+);

package/packets/outbound/ChunkBatch.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { chunkBatchSchema } from '../../schemas/ChunkBatch';
+import type { ChunkBatchSchema } from '../../schemas/ChunkBatch';
+import type { WorldTick } from '../PacketCore';
+
+export type ChunkBatchPacket = IPacket<typeof PacketId.CHUNK_BATCH, ChunkBatchSchema> & [WorldTick];
+
+export const chunkBatchPacketDefinition = definePacket(
+  PacketId.CHUNK_BATCH,
+  chunkBatchSchema,
+);

package/packets/outbound/EntityBatch.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { entityBatchSchema } from '../../schemas/EntityBatch';
+import type { EntityBatchSchema } from '../../schemas/EntityBatch';
+import type { WorldTick } from '../PacketCore';
+
+export type EntityBatchPacket = IPacket<typeof PacketId.ENTITY_BATCH, EntityBatchSchema> & [WorldTick];
+
+export const entityBatchPacketDefinition = definePacket(
+  PacketId.ENTITY_BATCH,
+  entityBatchSchema,
+);

package/packets/outbound/index.ts

@@ -1,10 +1,12 @@
 export * from './Block';
-export * from './BlockTypeRegistry';
+export * from './BlockBatch';
 export * from './BlockType';
+export * from './BlockTypeBatch';
 export * from './ChatMessage';
 export * from './Chunk';
+export * from './ChunkBatch';
 export * from './Entity';
+export * from './EntityBatch';
 export * from './PhysicsDebugRender';
-export * from './Simulation';
 export * from './SyncResponse';
-export * from './World';
+export * from './World';

package/schemas/Block.ts

@@ -3,7 +3,6 @@ import type { JSONSchemaType } from 'ajv';
 import type { VectorSchema } from './Vector';
 
 export type BlockSchema = {
-  wi: number;       // world id
   i: number;        // block id
   c: VectorSchema;  // coordinate
 };
@@ -11,10 +10,9 @@ export type BlockSchema = {
 export const blockSchema: JSONSchemaType<BlockSchema> = {
   type: 'object',
   properties: {
-    wi: { type: 'number' },
     i: { type: 'number' },
     c: vectorSchema,
   },
-  required: [ 'wi', 'i', 'c' ],
+  required: [ 'i', 'c' ],
   additionalProperties: false,
 }

package/schemas/BlockBatch.ts

@@ -0,0 +1,10 @@
+import { blockSchema } from './Block';
+import type { JSONSchemaType } from 'ajv';
+import type { BlockSchema } from './Block';
+
+export type BlockBatchSchema = BlockSchema[];
+
+export const blockBatchSchema: JSONSchemaType<BlockBatchSchema> = {
+  type: 'array',
+  items: { ...blockSchema },
+}

package/schemas/BlockType.ts

@@ -1,26 +1,20 @@
-import { colliderDescSchema } from './ColliderDesc';
 import type { JSONSchemaType } from 'ajv';
-import type { ColliderDescSchema } from './ColliderDesc';
 
 export type BlockTypeSchema = {
-  wi: number;             // world id
   i: number;              // block type id
   t?: string;             // textureUri
   n?: string;             // name
-  c?: ColliderDescSchema; // collider desc
   s?: boolean;            // is solid
 }
 
 export const blockTypeSchema: JSONSchemaType<BlockTypeSchema> = {
   type: 'object',
   properties: {
-    wi: { type: 'number' },
     i: { type: 'number' },
     t: { type: 'string', nullable: true },
     n: { type: 'string', nullable: true },
-    c: { ...colliderDescSchema, nullable: true },
     s: { type: 'boolean', nullable: true },
   },
-  required: [ 'wi', 'i' ],
+  required: [ 'i' ],
   additionalProperties: false,
 }

package/schemas/BlockTypeBatch.ts

@@ -0,0 +1,10 @@
+import { blockTypeSchema } from './BlockType';
+import type { JSONSchemaType } from 'ajv';
+import type { BlockTypeSchema } from './BlockType';
+
+export type BlockTypeBatchSchema = BlockTypeSchema[];
+
+export const blockTypeBatchSchema: JSONSchemaType<BlockTypeBatchSchema> = {
+  type: 'array',
+  items: { ...blockTypeSchema },
+}

package/schemas/Chunk.ts

@@ -3,7 +3,6 @@ import type { JSONSchemaType } from 'ajv';
 import type { VectorSchema } from './Vector';
 
 export type ChunkSchema = {
-  wi: number;               // world id
   c: VectorSchema;          // chunk coordinate [ 16n, 16n, 16n ]
   b: Uint8Array | number[]; // block ids in chunk, 16^3 entries, registry block ids 1-255, 0 = none
 };
@@ -11,7 +10,6 @@ export type ChunkSchema = {
 export const chunkSchema: JSONSchemaType<ChunkSchema> = {
   type: 'object',
   properties: {
-    wi: { type: 'number' },
     c: vectorSchema,
     b: {
       type: 'array',
@@ -24,6 +22,6 @@ export const chunkSchema: JSONSchemaType<ChunkSchema> = {
       maxItems: 4096
     }
   },
-  required: [ 'wi', 'c', 'b' ],
+  required: [ 'c', 'b' ],
   additionalProperties: false,
 }

package/schemas/ChunkBatch.ts

@@ -0,0 +1,10 @@
+import { chunkSchema } from './Chunk';
+import type { JSONSchemaType } from 'ajv';
+import type { ChunkSchema } from './Chunk';
+
+export type ChunkBatchSchema = ChunkSchema[];
+
+export const chunkBatchSchema: JSONSchemaType<ChunkBatchSchema> = {
+  type: 'array',
+  items: { ...chunkSchema },
+}

package/schemas/DebugConfig.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type DebugConfigSchema = {
   // physics debug render enabled,

package/schemas/Entity.ts

@@ -1,38 +1,39 @@
-import { rigidBodySchema } from './RigidBody';
+import { quaternionSchema } from './Quaternion';
+import { vectorSchema } from './Vector';
 import type { JSONSchemaType } from 'ajv';
-import type { RigidBodySchema } from './RigidBody';
+import type { QuaternionSchema } from './Quaternion';
+import type { VectorSchema } from './Vector';
+
 
 export type EntitySchema = {
-  wi: number;          // world id
-  i: number;           // entity id
-  f?: boolean;         // focused
-  fs?: boolean;        // full state
-  m?: string;          // model uri
-  a?: string[];        // animations looped
-  o?: string[];        // animations one shot
-  s?: string[];        // animations stop
-  n?: string;          // name
-  r?: RigidBodySchema; // rigid body
-  rm?: boolean;        // removed/remove
-  t?: string;          // texture uri
+  i: number;            // entity id
+  f?: boolean;          // focused
+  m?: string;           // model uri
+  al?: string[];        // animations looped
+  ao?: string[];        // animations one shot
+  as?: string[];        // animations stop
+  n?: string;           // name
+  p?: VectorSchema;     // position
+  r?: QuaternionSchema; // rotation
+  rm?: boolean;         // removed/remove
+  s?: VectorSchema;     // scale
 }
 
 export const entitySchema: JSONSchemaType<EntitySchema> = {
   type: 'object',
   properties: {
-    wi: { type: 'number' },
     i: { type: 'number' },
     f: { type: 'boolean', nullable: true },
-    fs: { type: 'boolean', nullable: true },
     m: { type: 'string', nullable: true },
-    a: { type: 'array', items: { type: 'string' }, nullable: true },
-    o: { type: 'array', items: { type: 'string' }, nullable: true },
-    s: { type: 'array', items: { type: 'string' }, nullable: true },
+    al: { type: 'array', items: { type: 'string' }, nullable: true },
+    ao: { type: 'array', items: { type: 'string' }, nullable: true },
+    as: { type: 'array', items: { type: 'string' }, nullable: true },
     n: { type: 'string', nullable: true },
-    r: { ...rigidBodySchema, nullable: true },
+    p: { ...vectorSchema, nullable: true },
+    r: { ...quaternionSchema, nullable: true },
     rm: { type: 'boolean', nullable: true },
-    t: { type: 'string', nullable: true },
+    s: { ...vectorSchema, nullable: true },
   },
-  required: [ 'wi', 'i' ],
+  required: [ 'i' ],
   additionalProperties: false,
 }

package/schemas/EntityBatch.ts

@@ -0,0 +1,10 @@
+import { entitySchema } from './Entity';
+import type { JSONSchemaType } from 'ajv';
+import type { EntitySchema } from './Entity';
+
+export type EntityBatchSchema = EntitySchema[];
+
+export const entityBatchSchema: JSONSchemaType<EntityBatchSchema> = {
+  type: 'array',
+  items: { ...entitySchema },
+}

package/schemas/HexColor.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type HexColorSchema = string;
 

package/schemas/Input.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type InputSchema = {
   w?: boolean;  // w key pressed

package/schemas/PhysicsDebugRender.ts

@@ -1,7 +1,6 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type PhysicsDebugRenderSchema = {
-  wi: number;  // world id
   v: number[]; // rapier debug render vertices
   c: number[]; // rapier debug render colors
 }
@@ -9,10 +8,9 @@ export type PhysicsDebugRenderSchema = {
 export const physicsDebugRenderSchema: JSONSchemaType<PhysicsDebugRenderSchema> = {
   type: 'object',
   properties: {
-    wi: { type: 'number' },
     v: { type: 'array', items: { type: 'number' } },
     c: { type: 'array', items: { type: 'number' } },
   },
-  required: [ 'wi', 'v', 'c' ],
+  required: [ 'v', 'c' ],
   additionalProperties: false,
 }

package/schemas/StateRequest.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type StateRequestSchema = {
   

package/schemas/VectorBoolean.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type VectorBooleanSchema = [
   boolean, // x

package/schemas/World.ts

@@ -1,4 +1,4 @@
-import { JSONSchemaType } from 'ajv';
+import type { JSONSchemaType } from 'ajv';
 
 export type WorldSchema = {
   i: number;   // id

package/schemas/index.ts

@@ -1,17 +1,16 @@
 export * from './Block';
-export * from './BlockTypeRegistry';
 export * from './BlockType';
+export * from './BlockTypeBatch';
 export * from './ChatMessage';
 export * from './Chunk';
-export * from './Collider';
-export * from './ColliderDesc';
+export * from './ChunkBatch';
+export * from './DebugConfig';
 export * from './Entity';
+export * from './EntityBatch';
+export * from './HexColor';
 export * from './Input';
 export * from './PhysicsDebugRender';
 export * from './Quaternion';
-export * from './RigidBody';
-export * from './Shape';
-export * from './Simulation';
 export * from './StateRequest';
 export * from './SyncRequest';
 export * from './SyncResponse';

package/packets/outbound/BlockTypeRegistry.ts

@@ -1,12 +0,0 @@
-import { definePacket, PacketId } from '../PacketCore';
-import type { IPacket } from '../PacketCore';
-import { blockTypeRegistrySchema } from '../../schemas/BlockTypeRegistry';
-import type { BlockTypeRegistrySchema } from '../../schemas/BlockTypeRegistry';
-import type { WorldTick } from '../PacketCore';
-
-export type BlockTypeRegistryPacket = IPacket<typeof PacketId.BLOCK_TYPE_REGISTRY, BlockTypeRegistrySchema> & [WorldTick];
-
-export const blockTypeRegistryPacketDefinition = definePacket(
-  PacketId.BLOCK_TYPE_REGISTRY,
-  blockTypeRegistrySchema,
-);

package/packets/outbound/Simulation.ts

@@ -1,12 +0,0 @@
-import { definePacket, PacketId } from '../PacketCore';
-import type { IPacket } from '../PacketCore';
-import { simulationSchema } from '../../schemas/Simulation';
-import type { SimulationSchema } from '../../schemas/Simulation';
-import type { WorldTick } from '../PacketCore';
-
-export type SimulationPacket = IPacket<typeof PacketId.SIMULATION, SimulationSchema> & [WorldTick];
-
-export const simulationPacketDefinition = definePacket(
-  PacketId.SIMULATION,
-  simulationSchema,
-);

package/schemas/BlockTypeRegistry.ts

@@ -1,21 +0,0 @@
-import { blockTypeSchema } from './BlockType';
-import type { JSONSchemaType } from 'ajv';
-import type { BlockTypeSchema } from './BlockType';
-
-export type BlockTypeRegistrySchema = {
-  wi: number;           // world id
-  b: BlockTypeSchema[]; // block types
-}
-
-export const blockTypeRegistrySchema: JSONSchemaType<BlockTypeRegistrySchema> = {
-  type: 'object',
-  properties: {
-    wi: { type: 'number' },
-    b: {
-      type: 'array',
-      items: blockTypeSchema,
-    }
-  },
-  required: [ 'wi', 'b' ],
-  additionalProperties: false,
-}

package/schemas/Collider.ts

@@ -1,21 +0,0 @@
-import { colliderDescSchema } from './ColliderDesc';
-import type { JSONSchemaType } from 'ajv';
-import type { ColliderDescSchema } from './ColliderDesc';
-
-export type ColliderSchema = {
-  i: number;    // id
-  fs?: boolean; // full state
-  rm?: boolean; // removed/remove
-} & ColliderDescSchema;
-
-export const colliderSchema: JSONSchemaType<ColliderSchema> = {
-  type: 'object',
-  properties: {
-    i: { type: 'number', nullable: true },
-    fs: { type: 'boolean', nullable: true },
-    rm: { type: 'boolean', nullable: true },
-    ...colliderDescSchema.properties
-  },
-  required: [ 'i' ],
-  additionalProperties: false,
-}

package/schemas/ColliderDesc.ts

@@ -1,47 +0,0 @@
-import { shapeSchema } from './Shape';
-import { quaternionSchema } from './Quaternion';
-import { vectorSchema } from './Vector';
-import type { JSONSchemaType } from 'ajv';
-import type { ShapeSchema } from './Shape';
-import type { QuaternionSchema } from './Quaternion';
-import type { VectorSchema } from './Vector';
-
-export type ColliderDescSchema = {
-  at?: number;          // active collision types
-  cg?: number;          // collision groups
-  cs?: number;          // contact skin
-  d?: number;           // density
-  f?: number;           // friction
-  fr?: number;          // friction combine rule
-  en?: boolean;         // enabled
-  m?: number;           // mass
-  re?: number;          // restitution
-  rer?: number;         // restitution combine rule
-  r?: QuaternionSchema; // rotation
-  s?: ShapeSchema;      // shape
-  sg?: number;          // solver groups
-  sn?: boolean;         // sensor
-  t?: VectorSchema;     // translation
-}
-
-export const colliderDescSchema: JSONSchemaType<ColliderDescSchema> = {
-  type: 'object',
-  properties: {
-    at: { type: 'number', nullable: true },
-    cg: { type: 'number', nullable: true },
-    cs: { type: 'number', nullable: true },
-    d: { type: 'number', nullable: true },
-    f: { type: 'number', nullable: true },
-    fr: { type: 'number', nullable: true },
-    en: { type: 'boolean', nullable: true },
-    m: { type: 'number', nullable: true },
-    re: { type: 'number', nullable: true },
-    rer: { type: 'number', nullable: true },
-    r: { ...quaternionSchema, nullable: true },
-    s: { ...shapeSchema, nullable: true },
-    sg: { type: 'number', nullable: true },
-    sn: { type: 'boolean', nullable: true },
-    t: { ...vectorSchema, nullable: true },
-  },
-  additionalProperties: false,
-}

package/schemas/RigidBody.ts

@@ -1,74 +0,0 @@
-import { colliderSchema } from './Collider';
-import { quaternionSchema } from './Quaternion';
-import { vectorSchema } from './Vector';
-import { vectorBooleanSchema } from './VectorBoolean'
-import type { JSONSchemaType } from 'ajv';
-import type { ColliderSchema } from './Collider';
-import type { VectorSchema } from './Vector';
-import type { VectorBooleanSchema } from './VectorBoolean';
-import type { QuaternionSchema } from './Quaternion';
-
-export type RigidBodySchema = {
-  ad?: number;              // angular dampening  
-  ap?: {                    // additional mass properties
-    am: number;            // additional mass
-    cm: VectorSchema;      // center of mass
-    pf: QuaternionSchema;  // principal angular inertia local frame
-    pi: VectorSchema;      // principal angular inertia
-  },
-  as?: number;              // additional solver iterations
-  av?: VectorSchema;        // angular velocity
-  b?: number;               // body type
-  c?: ColliderSchema[];     // collider desc
-  d?: number;               // dominance group
-  ce?: boolean;             // ccd enabled
-  en?: boolean;             // enabled
-  er?: VectorBooleanSchema; // enabled rotations
-  et?: VectorBooleanSchema; // enabled translations
-  fs?: boolean;             // full state
-  g?: number;               // gravity scaling
-  ld?: number;              // linear damping
-  lv?: VectorSchema;        // linear velocity
-  r?: QuaternionSchema;     // rotation
-  rm?: boolean;             // removed
-  sl?: boolean;             // sleeping
-  scp?: number;             // soft ccd prediction
-  t?: VectorSchema;         // translation
-};
-
-export const rigidBodySchema: JSONSchemaType<RigidBodySchema> = {
-  type: 'object',
-  properties: {
-    ad: { type: 'number', nullable: true },
-    ap: {
-      type: 'object',
-      properties: {
-        am: { type: 'number' },
-        cm: { ...vectorSchema },
-        pf: { ...quaternionSchema },
-        pi: { ...vectorSchema },
-      },
-      required: ['am', 'cm', 'pf', 'pi'],
-      nullable: true,
-    },
-    as: { type: 'number', nullable: true },
-    av: { ...vectorSchema, nullable: true },
-    b: { type: 'number', nullable: true },
-    c: { type: 'array', items: colliderSchema, nullable: true },
-    d: { type: 'number', nullable: true },
-    ce: { type: 'boolean', nullable: true },
-    en: { type: 'boolean', nullable: true },
-    er: { ...vectorBooleanSchema, nullable: true },
-    et: { ...vectorBooleanSchema, nullable: true },
-    fs: { type: 'boolean', nullable: true },
-    g: { type: 'number', nullable: true },
-    ld: { type: 'number', nullable: true },
-    lv: { ...vectorSchema, nullable: true },
-    r: { ...quaternionSchema, nullable: true },
-    rm: { type: 'boolean', nullable: true },
-    sl: { type: 'boolean', nullable: true },
-    scp: { type: 'number', nullable: true },
-    t: { ...vectorSchema, nullable: true },
-  },
-  additionalProperties: false,
-}

package/schemas/Shape.ts

@@ -1,23 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { vectorSchema } from './Vector';
-import type { VectorSchema } from './Vector';
-
-export type ShapeSchema = {
-  t?: number;        // type
-  b?: number;        // border radius
-  r?: number;        // radius
-  hx?: VectorSchema; // half extends
-  hh?: number;       // half height
-}
-
-export const shapeSchema: JSONSchemaType<ShapeSchema> = {
-  type: 'object',
-  properties: {
-    t: { type: 'number', nullable: true },
-    b: { type: 'number', nullable: true },
-    r: { type: 'number', nullable: true },
-    hx: { ...vectorSchema, nullable: true },
-    hh: { type: 'number', nullable: true },
-  },
-  additionalProperties: false,
-}

package/schemas/Simulation.ts

@@ -1,20 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { vectorSchema } from './Vector';
-import type { VectorSchema } from './Vector';
-
-export type SimulationSchema = {
-  wi: number;       // world id
-  t?: number;       // timestep (seconds)
-  g?: VectorSchema; // gravity
-};
-
-export const simulationSchema: JSONSchemaType<SimulationSchema> = {
-  type: 'object',
-  properties: {
-    wi: { type: 'number' },
-    t: { type: 'number', nullable: true },
-    g: { ...vectorSchema, nullable: true },
-  },
-  required: [ 'wi' ],
-  additionalProperties: false,
-}