@vaitosoi/minejs 0.2.2 → 0.4.0

package/src/{translator → packet}/encoder.ts

@@ -1,8 +1,17 @@
-import { Vec3 } from "../base/direction";
+import { Vec3 } from "../physics/direction";
 import { CONTINUATION_FLAG, CONTINUE_BIT, isFixedSizeTag, isTag, MAX_QUANTIZED_VALUE, SCALE_BITS, SEGMENT_BITS } from "./static";
 import { InvalidValue, NumberTooBig, UnexpectedValue } from "../base/error";
 import { FixedSizeTag, Tag } from "./static";
 
+export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
+    let flag = 0;
+    if (onGround)
+        flag &= 1;
+    if (pushingWall)
+        flag |= 1 << 2;
+    return flag;
+}
+
 export class BinaryEncoder {
     private buffer = Buffer.alloc(0);
 
@@ -14,8 +23,9 @@ export class BinaryEncoder {
         this.buffer = Buffer.alloc(0);
     }
 
-    public concat(buf: Buffer) {
+    public writeRaw(buf: Buffer) {
         this.buffer = Buffer.concat([this.buffer, buf]);
+        return this;
     }
 
 
@@ -27,7 +37,7 @@ export class BinaryEncoder {
     public write(size: number, val: any, writeFunc: (buf: Buffer) => ((val: any) => void)) {
         const buf = Buffer.alloc(size);
         writeFunc(buf).bind(buf)(val);
-        this.concat(buf);
+        this.writeRaw(buf);
         return this;
     }
 
@@ -129,7 +139,7 @@ export class BinaryEncoder {
      */
     public writeString(str: string) {
         this.writeVarInt(str.length);
-        this.concat(Buffer.from(str));
+        this.writeRaw(Buffer.from(str));
         return this;
     }
 
@@ -171,7 +181,7 @@ export class BinaryEncoder {
             else return val;
         });
         this.writeVarInt(length);
-        this.concat(Buffer.concat(array));
+        this.writeRaw(Buffer.concat(array));
         return this;
     }
 
@@ -187,7 +197,7 @@ export class BinaryEncoder {
     public writeRawPrefixedArray(data: Buffer, size: number) {
         const length = Math.ceil(data.length / size);
         this.writeVarInt(length);
-        this.concat(data);
+        this.writeRaw(data);
         return this;
     }
 
@@ -224,8 +234,9 @@ export class BinaryEncoder {
                 this.writeVarInt(Number(scaleFactor >> 2n));
             }
         }
-    }
 
+        return this;
+    }
 }
 
 type CompoundField = any | {
@@ -306,7 +317,7 @@ export class NBTEncoder extends BinaryEncoder {
     public writeString(str: string) {
         this.writeUShort(str.length);
         if (str.length === 0) return this;
-        this.concat(Buffer.from(str));
+        this.writeRaw(Buffer.from(str));
         return this;
     }
 
@@ -322,7 +333,7 @@ export class NBTEncoder extends BinaryEncoder {
             for (const item of arr)
                 this.writeString(item);
         else
-            this.concat(Buffer.from(arr));
+            this.writeRaw(Buffer.from(arr));
         return this;
     }
 

package/src/{base → physics}/aabb.ts

@@ -1,9 +1,9 @@
-import { BitSet } from "./bitset";
+import { BitSet } from "../base/bitset";
 import { Axis, AxisCycle, BaseAxis, BaseVec3, Direction, Vec3 } from "./direction";
-import { RegistryItemNotFound } from "./error";
-import { EntityRegistry } from "./registry";
-import { Epsilon, lowerBoundBinarySearch } from "./math";
-import { BlockHitResult } from "./block";
+import { RegistryItemNotFound } from "../base/error";
+import { EntityRegistry } from "../version/registry";
+import { Epsilon, lowerBoundBinarySearch } from "../base/math";
+import { BlockHitResult } from "../world/block";
 
 export interface BaseAABB {
     minX: number;

package/src/{base → physics}/player.ts

@@ -1,24 +1,33 @@
-import { EntitiesManager } from "./entity";
+import { EntitiesManager } from "../world/entity";
 import { Angle, Axis, BaseAxis, BaseVec3, Vec3 } from "./direction";
 import { AABB, Shapes, VoxelShape } from "./aabb";
-import { BlockGetter, BlockManager, BlockState } from "./block";
-import { clamp, Epsilon, equal, lerp } from "./math";
-import { TCPClient } from "../client/tcp";
-import { ClientNotReady } from "./error";
+import { BlockGetter, BlockManager, BlockState } from "../world/block";
+import { clamp, Epsilon, equal, lerp } from "../base/math";
+import { ClientNotReady, NotImplemented } from "../base/error";
 import { LevelHeightLimit } from "../client/static";
+import { SharedState } from "../world/state";
+import { TypedEmmiter } from "../base/event";
+import { ClientEvents } from "../client/client";
+import { makeMovementFlag } from "../packet/encoder";
 
-export enum MoveDirection {
+export enum Input {
     Forward = "W",
     Backward = "S",
     Left = "A",
     Right = "D",
+    Crouching = "shift",
+    Jump = "space",
+    Sprint = "cttl"
 }
 
-const VectorMovement: Record<MoveDirection, Vec3> = {
-    [MoveDirection.Forward]: new Vec3(0, 0, 1),
-    [MoveDirection.Backward]: new Vec3(0, 0, -1),
-    [MoveDirection.Left]: new Vec3(1, 0, 0),
-    [MoveDirection.Right]: new Vec3(-1, 0, 0),
+const VectorMovement: Record<Input, Vec3> = {
+    [Input.Forward]: new Vec3(0, 0, 1),
+    [Input.Backward]: new Vec3(0, 0, -1),
+    [Input.Left]: new Vec3(1, 0, 0),
+    [Input.Right]: new Vec3(-1, 0, 0),
+    [Input.Crouching]: Vec3.Zero,
+    [Input.Jump]: Vec3.Zero,
+    [Input.Sprint]: Vec3.Zero,
 };
 
 /**
@@ -39,12 +48,11 @@ export class Player {
 
     // Moving state
     // TODO: need is sprinting
-    private heldInputs: Set<MoveDirection> = new Set();
-    private isCrouncing: boolean = false;
-    private isJumping: boolean = false;
+    private heldInputs: Set<Input> = new Set();
     private lastPos: BaseVec3 | null = null;
     private lastAngle: Angle | null = null;
     private positionReminder: number = 0;
+    private noJumpDelay: number = 0;
 
     // Collision
     private horizontalCollision: boolean = false;
@@ -54,18 +62,45 @@ export class Player {
     private lastOnGround: boolean = true;
 
     constructor(
+        private state: SharedState,
+        private on: TypedEmmiter<ClientEvents>["on"],
         private entities: EntitiesManager,
         private blocks: BlockManager,
-        private tcp: TCPClient
     ) {
-        this.tcp.on("playerPosition", () => {
+        this.on("playerPosition", () => {
             this.onGround = true;
             this.horizontalCollision = false;
             this.fallDistance = 0;
-            this.deltaMovement = new Vec3(this.tcp.player!.velocity);
+            this.deltaMovement = new Vec3(this.state.player!.velocity);
+            this.setInitialVal();
         });
     }
 
+
+    public sendPlayerPos: (
+        position: BaseVec3,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) => void = () => { throw new NotImplemented(); };
+
+    public sendPlayerPosRot: (
+        position: BaseVec3,
+        angle: Angle,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) => void = () => { throw new NotImplemented(); };
+
+    public sendPlayerRot: (
+        angle: Angle,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) => void = () => { throw new NotImplemented(); };
+
+    public sendPlayerStatus: (
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) => void = () => { throw new NotImplemented(); };
+
     /**
      * Set initial value
      */
@@ -81,8 +116,6 @@ export class Player {
         this.deltaMovement = Vec3.Zero;
         this.supportBlockPos = null;
         this.heldInputs = new Set();
-        this.isCrouncing = false;
-        this.isJumping = false;
         this.lastPos = null;
         this.lastAngle = null;
         this.positionReminder = 0;
@@ -97,31 +130,19 @@ export class Player {
     /**
      * Press and hold a key
      */
-    public input(input: MoveDirection) { this.heldInputs.add(input); }
+    public input(input: Input) { this.heldInputs.add(input); }
     /**
      * Release a key
      */
-    public releaseInput(input: MoveDirection) { this.heldInputs.delete(input); }
+    public releaseInput(input: Input) { this.heldInputs.delete(input); }
     /**
      * Release all key
      */
     public releaseAllInputs() { this.heldInputs.clear(); }
-    /**
-     * Press and hold shift. Do nothing for now
-     */
-    public pressShift() { this.isCrouncing = true; }
-    /**
-     * Release shift
-     */
-    public releaseShift() { this.isCrouncing = false; }
-    /**
-     * Press and hold space. Do nothing for now
-     */
-    public pressSpace() { this.isJumping = true; }
-    /**
-     * Release shift
-     */
-    public releaseSpace() { this.isJumping = false; }
+
+    private get isCrouncing() { return this.heldInputs.has(Input.Crouching); };
+    private get isJumping() { return this.heldInputs.has(Input.Jump); };
+    private get isSprinting() { return this.heldInputs.has(Input.Sprint); }
 
     private getInputVector(): Vec3 {
         let vec = Vec3.Zero;
@@ -132,20 +153,27 @@ export class Player {
 
     /* Getting helper, from TCP client */
     private getPos() {
-        this.tcp.checkReady();
-        return new Vec3(this.tcp.player!.position);
+        this.state.checkReady();
+        return new Vec3(this.state.player!.position);
     }
     private setPos(pos: Vec3) {
-        this.tcp.checkReady();
-        this.tcp.player!.position = pos.copyBase();
+        this.state.checkReady();
+        this.state.enqueueMutation((state) => state.player!.position = pos.copyBase());
     }
     private getAngle() {
-        this.tcp.checkReady();
-        return this.tcp.player!.angle;
+        this.state.checkReady();
+        return this.state.player!.angle;
+    }
+    public setAngle(yaw: number, pitch: number) {
+        this.state.checkReady();
+        this.state.enqueueMutation((state) => state.player!.angle = {
+            yaw: yaw % 360,
+            pitch: pitch % 360
+        });
     }
     private getDimension() {
-        this.tcp.checkReady();
-        return this.tcp.player!.dimension;
+        this.state.checkReady();
+        return this.state.player!.dimension;
     }
 
     private setDeltaMovement(x: number, y: number, z: number): void;
@@ -217,7 +245,7 @@ export class Player {
      * Ticking
      */
     public tick() {
-        if (!this.tcp.isReady()) return;
+        if (!this.state.isReady()) return;
         if (!this.lastPos || !this.lastAngle) throw new ClientNotReady();
 
         // console.log("tick");
@@ -226,7 +254,7 @@ export class Player {
         this.aiStep();
         const { x, y, z } = this.getPos(),
             { x: xLast, y: yLast, z: zLast } = this.lastPos,
-            { yaw: xRot, pitch: yRot } = this.getAngle(),
+            { yaw, yaw: xRot, pitch, pitch: yRot } = this.getAngle(),
             { yaw: xRotLast, pitch: yRotLast } = this.lastAngle;
         const deltaX = x - xLast,
             deltaY = y - yLast,
@@ -237,16 +265,16 @@ export class Player {
         const move = new Vec3(deltaX, deltaY, deltaZ).lengthSqr() > (2e-4 * 2e-4) || this.positionReminder > 20,
             rot = deltaXRot !== 0 || deltaYRot !== 0;
         if (move && rot)
-            this.tcp.sendPlayerPosRot(this.getPos(), this.getAngle(), this.onGround, this.horizontalCollision);
+            this.sendPlayerPosRot(this.getPos(), this.getAngle(), this.onGround, this.horizontalCollision);
         else if (move)
-            this.tcp.sendPlayerPos(this.getPos(), this.onGround, this.horizontalCollision);
+            this.sendPlayerPos(this.getPos(), this.onGround, this.horizontalCollision);
         else if (rot)
-            this.tcp.sendPlayerRot(this.getAngle(), this.onGround, this.horizontalCollision);
+            this.sendPlayerRot(this.getAngle(), this.onGround, this.horizontalCollision);
         else if (
             this.onGround !== this.lastOnGround ||
             this.horizontalCollision !== this.lastHorizontalCollision
         )
-            this.tcp.sendPlayerStatus(this.onGround, this.horizontalCollision);
+            this.sendPlayerStatus(this.onGround, this.horizontalCollision);
 
         if (move) {
             this.lastPos = this.getPos();
@@ -260,6 +288,10 @@ export class Player {
     }
 
     private aiStep() {
+        if (this.noJumpDelay > 0) {
+            this.noJumpDelay--;
+        }
+
         // eslint-disable-next-line prefer-const
         let { x, y, z } = this.deltaMovement;
         if (this.deltaMovement.horizontalDistanceSqr() < 9e-6) {
@@ -268,13 +300,23 @@ export class Player {
         }
         this.setDeltaMovement(x, y, z);
 
-        if (this.isJumping) {
+        if (this.isJumping && this.noJumpDelay === 0) {
             const jumpPower = this.getJumpFactor();
 
             if (jumpPower > 1e-5) {
                 const { x: dx, y: dy, z: dz } = this.deltaMovement;
                 this.setDeltaMovement(dx, Math.max(dy, jumpPower), dz);
+                if (this.isSprinting) {
+                    const yawInRad = this.getAngle().yaw * (Math.PI / 180.0);
+                    this.setDeltaMovement(
+                        this.deltaMovement.add(
+                            new Vec3(-Math.sin(yawInRad) * 0.2, 0.0, Math.cos(yawInRad) * 0.2)
+                        )
+                    );
+                }
             }
+
+            this.noJumpDelay = 15; // Original value to 10
         }
         // TODO: Handle in fluid
 
@@ -296,14 +338,15 @@ export class Player {
         const { x, y, z } = this.getPos();
         const inBlock = this.blocks.at(x, y, z)!;
         const belowBlock = this.blocks.at(x, y - 0.5, z)!;
-        return inBlock.owner.getJumpFactor() === 1 ? belowBlock.owner.getJumpFactor() : inBlock.owner.getJumpFactor();
+        // 0.42F is the default jump strength, which will apply for player here
+        return (inBlock.owner.getJumpFactor() === 1 ? belowBlock.owner.getJumpFactor() : inBlock.owner.getJumpFactor()) * 0.42;
     }
 
     /*
      * Invoking flow
      * 
      *         |-> travelInAir ---|
-     * travel -|-> travelInFluid -|--> move -> colision
+     * travel -|-> travelInFluid -+--> move -> colision
      *         |-> flying? -------|
      */
 
@@ -318,8 +361,8 @@ export class Player {
     private travelInAir(input: Vec3) {
         const posBelow = this.getOnPos(0.50001);
         if (!this.blocks.hasChunkAt(posBelow))
-            return; // // console.log(`no chunk at ${Math.floor(posBelow.x / 16)} ${Math.floor(posBelow.y / 16)} ${Math.floor(posBelow.z / 16)}`);
-        // // console.log('posBelow', posBelow, 'block', this.blocks.at(posBelow)?.owner.getType());
+            return; // console.log(`no chunk at ${Math.floor(posBelow.x / 16)} ${Math.floor(posBelow.y / 16)} ${Math.floor(posBelow.z / 16)}`);
+        // console.log('posBelow', posBelow, 'block', this.blocks.at(posBelow)?.owner.getType());
         const blockFriction = this.onGround ? this.blocks.at(posBelow)!.owner.getFriction() : 1;
         const movement = this.handleFrictionAndCalculateMovement(input, blockFriction);
         let movementY = movement.y;
@@ -373,7 +416,7 @@ export class Player {
     private getSpeed() {
         // return the base for now
         // TODO: Handle other cases: sprinting, speed-enchanted gear and potion
-        return 0.1;
+        return this.isSprinting ? 0.13 : 0.1;
     }
 
     private moveRelative(input: Vec3, speed: number) {
@@ -417,14 +460,12 @@ export class Player {
                     to: checkTo,
                     getBlockState: (position) => this.blocks.at(position)!.shape
                 });
-                if (hitResult?.miss !== false) {
+                if (hitResult?.miss !== false)
                     this.fallDistance = 0;
-                }
             }
 
             const pos = this.getPos();
             const newPosition = pos.add(movement);
-            // addMovementThisTick(new Movement(pos, newPosition, delta2));
             this.setPos(newPosition);
         }
 
@@ -503,7 +544,7 @@ export class Player {
 
     private collide(movement: Vec3): Vec3 {
         // Get player's bounding box
-        const { x: playerX, y: playerY, z: playerZ } = this.tcp.player!.position;
+        const { x: playerX, y: playerY, z: playerZ } = this.state.player!.position;
         const playerBB = AABB.fromEntityType("minecraft:player")
             .move(playerX, playerY, playerZ);
         const expandedBB = playerBB.expandTowards(movement);
@@ -515,7 +556,7 @@ export class Player {
         // });
 
         // Collect all colliders
-        const colliders = this.collectColliders(expandedBB, [this.tcp.player!.entityId]);
+        const colliders = this.collectColliders(expandedBB, [this.state.player!.entityId]);
         // // console.log('nonEmptyColliders', colliders.filter(c => !c.isEmpty()).length);
 
         // Get the farest distance can move
@@ -535,7 +576,7 @@ export class Player {
             if (!onGroundAfterCollision)
                 stepUpAABB = stepUpAABB.expandTowards(0, -1e-5, 0);
 
-            const colliders = this.collectColliders(stepUpAABB, [this.tcp.player!.entityId]);
+            const colliders = this.collectColliders(stepUpAABB, [this.state.player!.entityId]);
             const stepHeightToSkip = movementStep.y;
             const stepUpCandidateSet: Set<number> = new Set();
             for (const collider of colliders) {
@@ -584,8 +625,8 @@ export class Player {
             }
         }
 
-        // // console.log('expandedBB', expandedBB, 'colliderCount', colliders.length);
-        // // console.log('movement.y', movement.y, 'movementStep.y', movementStep.y);
+        // console.log('expandedBB', expandedBB, 'colliderCount', colliders.length);
+        // console.log('movement.y', movement.y, 'movementStep.y', movementStep.y);
 
         return movementStep;
     }