@hytopia.com/server-protocol 1.0.29 → 1.0.31

package/package.json

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

package/packets/PacketCore.ts

@@ -30,7 +30,8 @@ export enum PacketId {
   BLOCK_TYPE = 34,
   CHUNK = 35,
   ENTITY = 36,
-  WORLD = 37,
+  SIMULATION = 37,
+  WORLD = 38,
 
   // Debug Inbound Packet Types: 128 - 191 range
   // NONE atm, start at 128
@@ -51,9 +52,11 @@ export interface IPacketDefinition<TId extends PacketId, TSchema> {
 
 export type WorldTick = number;
 
-export type IPacket<TId extends PacketId, TSchema, TRequireWorldTick extends boolean = false> = TRequireWorldTick extends true
-  ? [TId, TSchema, WorldTick]
-  : [TId, TSchema];
+export type IPacket<TId extends PacketId, TSchema> = [
+  TId,     // packet id
+  TSchema, // packet data
+  WorldTick?,  // world tick
+];
 
 export type AnyPacket = IPacket<PacketId, unknown>;
 
@@ -65,23 +68,25 @@ export interface Serializable {
   serialize(): AnySchema;
 }
 
-export function createPacket<TId extends PacketId, TSchema, TRequireWorldTick extends boolean = false>(
+export function createPacket<TId extends PacketId, TSchema>(
   packetDef: IPacketDefinition<TId, TSchema>,
   data: TSchema,
-  worldTick?: TRequireWorldTick extends true ? WorldTick : WorldTick | undefined
-): IPacket<TId, TSchema, TRequireWorldTick> {
+  worldTick?: WorldTick,
+): IPacket<TId, TSchema> {
   if (!packetDef.validate(data)) {
     throw new Error(`Invalid payload for packet with id ${packetDef.id}. Error: ${Ajv.instance.errorsText(packetDef.validate.errors)}`);
   }
 
-  if (worldTick === undefined) {
-    return [packetDef.id, data] as IPacket<TId, TSchema, TRequireWorldTick>;
+  const packet: IPacket<TId, TSchema> = [packetDef.id, data];
+
+  if (typeof worldTick === 'number') {
+    packet.push(worldTick);
   }
 
-  return [packetDef.id, data, worldTick] as IPacket<TId, TSchema, TRequireWorldTick>;
+  return packet;
 }
 
-export function definePacket<TId extends PacketId, TSchema, TRequireWorldTick extends boolean = false>(
+export function definePacket<TId extends PacketId, TSchema>(
   id: TId,
   schema: JSONSchemaType<TSchema>,
 ): IPacketDefinition<TId, TSchema> {

package/packets/PacketDefinitions.ts

@@ -22,11 +22,11 @@ for (const packet of Object.values(allPackets)) {
 
 export function isValidPacket(packet: unknown): packet is AnyPacket {
   if (
-    !Array.isArray(packet) ||
-    packet.length < 2 || packet.length > 3 ||
+    typeof packet !== 'object' || 
+    packet === null || 
     typeof packet[0] !== 'number' || packet[0] < 0 ||
     packet[1] === undefined ||
-    (packet.length === 3 && typeof packet[2] !== 'number')
+    (packet[2] !== undefined && (typeof packet[2] !== 'number' || packet[2] < 0))
   ) {
     return false;
   }

package/packets/outbound/Block.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { blockSchema } from '../../schemas/Block';
 import type { BlockSchema } from '../../schemas/Block';
+import type { WorldTick } from '../PacketCore';
 
-export type BlockPacket = IPacket<typeof PacketId.BLOCK, BlockSchema, true>;
+export type BlockPacket = IPacket<typeof PacketId.BLOCK, BlockSchema> & [WorldTick];
 
-export const blockPacketDefinition = definePacket<typeof PacketId.BLOCK, BlockSchema, true>(
+export const blockPacketDefinition = definePacket(
   PacketId.BLOCK,
   blockSchema,
 );

package/packets/outbound/BlockType.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { blockTypeSchema } from '../../schemas/BlockType';
 import type { BlockTypeSchema } from '../../schemas/BlockType';
+import type { WorldTick } from '../PacketCore';
 
-export type BlockTypePacket = IPacket<typeof PacketId.BLOCK_TYPE, BlockTypeSchema, true>;
+export type BlockTypePacket = IPacket<typeof PacketId.BLOCK_TYPE, BlockTypeSchema> & [WorldTick];
 
-export const blockTypePacketDefinition = definePacket<typeof PacketId.BLOCK_TYPE, BlockTypeSchema, true>(
+export const blockTypePacketDefinition = definePacket(
   PacketId.BLOCK_TYPE,
   blockTypeSchema,
 );

package/packets/outbound/BlockTypeRegistry.ts

@@ -4,9 +4,9 @@ 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, true>;
+export type BlockTypeRegistryPacket = IPacket<typeof PacketId.BLOCK_TYPE_REGISTRY, BlockTypeRegistrySchema> & [WorldTick];
 
-export const blockTypeRegistryPacketDefinition = definePacket<typeof PacketId.BLOCK_TYPE_REGISTRY, BlockTypeRegistrySchema, true>(
+export const blockTypeRegistryPacketDefinition = definePacket(
   PacketId.BLOCK_TYPE_REGISTRY,
   blockTypeRegistrySchema,
 );

package/packets/outbound/Chunk.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { chunkSchema } from '../../schemas/Chunk';
 import type { ChunkSchema } from '../../schemas/Chunk';
+import type { WorldTick } from '../PacketCore';
 
-export type ChunkPacket = IPacket<typeof PacketId.CHUNK, ChunkSchema, true>;
+export type ChunkPacket = IPacket<typeof PacketId.CHUNK, ChunkSchema> & [WorldTick];
 
-export const chunkPacketDefinition = definePacket<typeof PacketId.CHUNK, ChunkSchema, true>(
+export const chunkPacketDefinition = definePacket(
   PacketId.CHUNK,
   chunkSchema,
 );

package/packets/outbound/Entity.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { entitySchema } from '../../schemas/Entity';
 import type { EntitySchema } from '../../schemas/Entity';
+import type { WorldTick } from '../PacketCore';
 
-export type EntityPacket = IPacket<typeof PacketId.ENTITY, EntitySchema, true>;
+export type EntityPacket = IPacket<typeof PacketId.ENTITY, EntitySchema> & [WorldTick];
 
-export const entityPacketDefinition = definePacket<typeof PacketId.ENTITY, EntitySchema, true>(
+export const entityPacketDefinition = definePacket(
   PacketId.ENTITY,
   entitySchema,
 );

package/packets/outbound/PhysicsDebugRender.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { physicsDebugRenderSchema } from '../../schemas/PhysicsDebugRender';
 import type { PhysicsDebugRenderSchema } from '../../schemas/PhysicsDebugRender';
+import type { WorldTick } from '../PacketCore';
 
-export type PhysicsDebugRenderPacket = IPacket<typeof PacketId.PHYSICS_DEBUG_RENDER, PhysicsDebugRenderSchema, true>;
+export type PhysicsDebugRenderPacket = IPacket<typeof PacketId.PHYSICS_DEBUG_RENDER, PhysicsDebugRenderSchema> & [WorldTick];
 
-export const physicsDebugRenderPacketDefinition = definePacket<typeof PacketId.PHYSICS_DEBUG_RENDER, PhysicsDebugRenderSchema, true>(
+export const physicsDebugRenderPacketDefinition = definePacket(
   PacketId.PHYSICS_DEBUG_RENDER,
   physicsDebugRenderSchema,
 );

package/packets/outbound/Simulation.ts

@@ -0,0 +1,12 @@
+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/packets/outbound/World.ts

@@ -2,10 +2,11 @@ import { definePacket, PacketId } from '../PacketCore';
 import type { IPacket } from '../PacketCore';
 import { worldSchema } from '../../schemas/World';
 import type { WorldSchema } from '../../schemas/World';
+import type { WorldTick } from '../PacketCore';
 
-export type WorldPacket = IPacket<typeof PacketId.WORLD, WorldSchema, true>;
+export type WorldPacket = IPacket<typeof PacketId.WORLD, WorldSchema> & [WorldTick];
 
-export const worldPacketDefinition = definePacket<typeof PacketId.WORLD, WorldSchema, true>(
+export const worldPacketDefinition = definePacket(
   PacketId.WORLD,
   worldSchema,
 );

package/packets/outbound/index.ts

@@ -4,4 +4,5 @@ export * from './BlockType';
 export * from './Chunk';
 export * from './Entity';
 export * from './PhysicsDebugRender';
+export * from './Simulation';
 export * from './World';

package/schemas/Simulation.ts

@@ -0,0 +1,20 @@
+import { JSONSchemaType } from 'ajv';
+import { vectorSchema } from './Vector';
+import type { VectorSchema } from './Vector';
+
+export type SimulationSchema = {
+  wi: number;      // world id
+  t?: number;       // tickRate (ticks per second)
+  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,
+}