@hytopia.com/server-protocol 1.1.5 → 1.2.1

package/package.json

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

package/packets/PacketCore.ts

@@ -26,16 +26,12 @@ export enum PacketId {
 
   // Standard Outbound Packet Types: 32 - 127 range
   SYNC_RESPONSE = 32,
-  BLOCK = 33,
-  BLOCK_BATCH = 34,
-  BLOCK_TYPE = 35,
-  BLOCK_TYPE_BATCH = 36,
-  CHUNK = 37,
-  CHUNK_BATCH = 38,
-  ENTITY = 39,
-  ENTITY_BATCH = 40,
-  WORLD = 41,
-  CHAT_MESSAGE = 42,
+  BLOCKS = 33,
+  BLOCK_TYPES = 34,
+  CHAT_MESSAGES = 35,
+  CHUNKS = 36,
+  ENTITIES = 37,
+  WORLD = 38,
 
   // Debug Inbound Packet Types: 128 - 191 range
   DEBUG_CONFIG = 128,

package/packets/outbound/BlockTypes.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { blockTypesSchema } from '../../schemas/BlockTypes';
+import type { BlockTypesSchema } from '../../schemas/BlockTypes';
+import type { WorldTick } from '../PacketCore';
+
+export type BlockTypesPacket = IPacket<typeof PacketId.BLOCK_TYPES, BlockTypesSchema> & [WorldTick];
+
+export const blockTypesPacketDefinition = definePacket(
+  PacketId.BLOCK_TYPES,
+  blockTypesSchema,
+);

package/packets/outbound/Blocks.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { blocksSchema } from '../../schemas/Blocks';
+import type { BlocksSchema } from '../../schemas/Blocks';
+import type { WorldTick } from '../PacketCore';
+
+export type BlocksPacket = IPacket<typeof PacketId.BLOCKS, BlocksSchema> & [WorldTick];
+
+export const blocksPacketDefinition = definePacket(
+  PacketId.BLOCKS,
+  blocksSchema,
+);

package/packets/outbound/ChatMessages.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { chatMessagesSchema } from '../../schemas/ChatMessages';
+import type { ChatMessagesSchema } from '../../schemas/ChatMessages';
+import type { WorldTick } from '../PacketCore';
+
+export type ChatMessagesPacket = IPacket<typeof PacketId.CHAT_MESSAGES, ChatMessagesSchema> & [WorldTick];
+
+export const chatMessagesPacketDefinition = definePacket(
+  PacketId.CHAT_MESSAGES,
+  chatMessagesSchema,
+);

package/packets/outbound/Chunks.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { chunksSchema } from '../../schemas/Chunks';
+import type { ChunksSchema } from '../../schemas/Chunks';
+import type { WorldTick } from '../PacketCore';
+
+export type ChunksPacket = IPacket<typeof PacketId.CHUNKS, ChunksSchema> & [WorldTick];
+
+export const chunksPacketDefinition = definePacket(
+  PacketId.CHUNKS,
+  chunksSchema,
+);

package/packets/outbound/Entities.ts

@@ -0,0 +1,12 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { entitiesSchema } from '../../schemas/Entities';
+import type { EntitiesSchema } from '../../schemas/Entities';
+import type { WorldTick } from '../PacketCore';
+
+export type EntitiesPacket = IPacket<typeof PacketId.ENTITIES, EntitiesSchema> & [WorldTick];
+
+export const entitiesPacketDefinition = definePacket(
+  PacketId.ENTITIES,
+  entitiesSchema,
+);

package/packets/outbound/index.ts

@@ -1,12 +1,8 @@
-export * from './Block';
-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 './Blocks';
+export * from './BlockTypes';
+export * from './ChatMessages';
+export * from './Chunks';
+export * from './Entities';
 export * from './PhysicsDebugRender';
 export * from './SyncResponse';
 export * from './World';

package/schemas/Block.ts

@@ -4,7 +4,7 @@ import type { VectorSchema } from './Vector';
 
 export type BlockSchema = {
   i: number;        // block id
-  c: VectorSchema;  // coordinate
+  c: VectorSchema;  // block global coordinate
 };
 
 export const blockSchema: JSONSchemaType<BlockSchema> = {

package/schemas/{BlockTypeBatch.ts → BlockTypes.ts}

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

package/schemas/{BlockBatch.ts → Blocks.ts}

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

package/schemas/ChatMessages.ts

@@ -0,0 +1,10 @@
+import { chatMessageSchema } from './ChatMessage';
+import type { JSONSchemaType } from 'ajv';
+import type { ChatMessageSchema } from './ChatMessage';
+
+export type ChatMessagesSchema = ChatMessageSchema[];
+
+export const chatMessagesSchema: JSONSchemaType<ChatMessagesSchema> = {
+  type: 'array',
+  items: { ...chatMessageSchema },
+}

package/schemas/Chunk.ts

@@ -3,8 +3,9 @@ import type { JSONSchemaType } from 'ajv';
 import type { VectorSchema } from './Vector';
 
 export type ChunkSchema = {
-  c: VectorSchema;          // chunk coordinate [ 16n, 16n, 16n ]
-  b: Uint8Array | number[]; // block ids in chunk, 16^3 entries, registry block ids 1-255, 0 = none
+  c: VectorSchema;           // chunk origin coordinate [ 16n, 16n, 16n ]
+  b?: Uint8Array | number[]; // block ids in chunk, 16^3 entries, registry block ids 1-255, 0 = none
+  rm?: boolean;              // removed/remove
 };
 
 export const chunkSchema: JSONSchemaType<ChunkSchema> = {
@@ -19,9 +20,11 @@ export const chunkSchema: JSONSchemaType<ChunkSchema> = {
         maximum: 255
       },
       minItems: 4096,
-      maxItems: 4096
-    }
+      maxItems: 4096,
+      nullable: true,
+    },
+    rm: { type: 'boolean', nullable: true },
   },
-  required: [ 'c', 'b' ],
+  required: [ 'c' ],
   additionalProperties: false,
 }

package/schemas/{ChunkBatch.ts → Chunks.ts}

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

package/schemas/{EntityBatch.ts → Entities.ts}

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

package/schemas/Input.ts

@@ -5,9 +5,26 @@ export type InputSchema = {
   a?: boolean;  // a key pressed
   s?: boolean;  // s key pressed
   d?: boolean;  // d key pressed
+  q?: boolean;  // q key pressed
+  e?: boolean;  // e key pressed
+  r?: boolean;  // r key pressed
+  f?: boolean;  // f key pressed
+  z?: boolean;  // z key pressed
+  x?: boolean;  // x key pressed
+  c?: boolean;  // c key pressed
+  v?: boolean;  // v key pressed
+  1?: boolean;  // 1 key pressed
+  2?: boolean;  // 2 key pressed
+  3?: boolean;  // 3 key pressed
+  4?: boolean;  // 4 key pressed
+  5?: boolean;  // 5 key pressed
+  6?: boolean;  // 6 key pressed
+  7?: boolean;  // 7 key pressed
+  8?: boolean;  // 8 key pressed
+  9?: boolean;  // 9 key pressed
+  0?: boolean;  // 0 key pressed
   sp?: boolean; // space key pressed
   sh?: boolean; // shift key pressed
-  ct?: boolean; // ctrl key pressed
   tb?: boolean; // tab key pressed
   ml?: boolean; // mouse left pressed
   mr?: boolean; // mouse right pressed
@@ -22,9 +39,26 @@ export const inputSchema: JSONSchemaType<InputSchema> = {
     a: { type: 'boolean', nullable: true },
     s: { type: 'boolean', nullable: true },
     d: { type: 'boolean', nullable: true },
+    q: { type: 'boolean', nullable: true },
+    e: { type: 'boolean', nullable: true },
+    r: { type: 'boolean', nullable: true },
+    f: { type: 'boolean', nullable: true },
+    z: { type: 'boolean', nullable: true },
+    x: { type: 'boolean', nullable: true },
+    c: { type: 'boolean', nullable: true },
+    v: { type: 'boolean', nullable: true },
+    1: { type: 'boolean', nullable: true },
+    2: { type: 'boolean', nullable: true },
+    3: { type: 'boolean', nullable: true },
+    4: { type: 'boolean', nullable: true },
+    5: { type: 'boolean', nullable: true },
+    6: { type: 'boolean', nullable: true },
+    7: { type: 'boolean', nullable: true },
+    8: { type: 'boolean', nullable: true },
+    9: { type: 'boolean', nullable: true },
+    0: { type: 'boolean', nullable: true },
     sp: { type: 'boolean', nullable: true },
     sh: { type: 'boolean', nullable: true },
-    ct: { type: 'boolean', nullable: true },
     tb: { type: 'boolean', nullable: true },
     ml: { type: 'boolean', nullable: true },
     mr: { type: 'boolean', nullable: true },

package/schemas/index.ts

@@ -1,13 +1,14 @@
 export * from './Block';
-export * from './BlockBatch';
+export * from './Blocks';
 export * from './BlockType';
-export * from './BlockTypeBatch';
+export * from './BlockTypes';
 export * from './ChatMessage';
+export * from './ChatMessages';
 export * from './Chunk';
-export * from './ChunkBatch';
+export * from './Chunks';
 export * from './DebugConfig';
 export * from './Entity';
-export * from './EntityBatch';
+export * from './Entities';
 export * from './HexColor';
 export * from './Input';
 export * from './PhysicsDebugRender';

package/packets/outbound/Block.ts

@@ -1,12 +0,0 @@
-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> & [WorldTick];
-
-export const blockPacketDefinition = definePacket(
-  PacketId.BLOCK,
-  blockSchema,
-);

package/packets/outbound/BlockBatch.ts

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

@@ -1,12 +0,0 @@
-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> & [WorldTick];
-
-export const blockTypePacketDefinition = definePacket(
-  PacketId.BLOCK_TYPE,
-  blockTypeSchema,
-);

package/packets/outbound/BlockTypeBatch.ts

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

@@ -1,12 +0,0 @@
-import { definePacket, PacketId } from '../PacketCore';
-import type { IPacket } from '../PacketCore';
-import { chatMessageSchema } from '../../schemas/ChatMessage';
-import type { ChatMessageSchema } from '../../schemas/ChatMessage';
-import type { WorldTick } from '../PacketCore';
-
-export type ChatMessagePacket = IPacket<typeof PacketId.CHAT_MESSAGE, ChatMessageSchema> & [WorldTick];
-
-export const chatMessagePacketDefinition = definePacket(
-  PacketId.CHAT_MESSAGE,
-  chatMessageSchema,
-);

package/packets/outbound/Chunk.ts

@@ -1,12 +0,0 @@
-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> & [WorldTick];
-
-export const chunkPacketDefinition = definePacket(
-  PacketId.CHUNK,
-  chunkSchema,
-);

package/packets/outbound/ChunkBatch.ts

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

@@ -1,12 +0,0 @@
-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> & [WorldTick];
-
-export const entityPacketDefinition = definePacket(
-  PacketId.ENTITY,
-  entitySchema,
-);

package/packets/outbound/EntityBatch.ts

@@ -1,12 +0,0 @@
-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,
-);