@vaitosoi/minejs 0.3.1 → 0.4.0

package/src/message/link.ts

@@ -0,0 +1,17 @@
+export class MessageLink {
+    constructor (
+        public index: number,
+        public sender: string,
+        public session: string
+    ) { }
+
+    public static root(sender: string, session: string) {
+        return new MessageLink(0, sender, session);
+    }
+
+    public static unsinged(sender: string) { return this.root(sender, "null"); }
+
+    public isDescendantOf(link: MessageLink) {
+        return link.index > this.index && this.sender === link.sender && this.session === link.session;
+    }
+}

package/src/message/sigCache.ts

@@ -0,0 +1,25 @@
+export class SignatureCache {
+    private entries: Buffer[];
+
+    constructor(public capacity: number) {
+        this.entries = Array.from({ length: this.capacity });
+    }
+
+    public static default() { return new SignatureCache(128); }
+
+    public get(index: number) { return this.entries[index]; }
+
+    public unpack = (messages: { message_id: number, signature?: number[] | undefined }[]) => 
+        messages.map(({ message_id: id, signature }) => signature ? Buffer.from(signature) : this.get(id)!);
+
+    public push(input: Buffer[]) {
+        const queue = input.slice();
+        const set = new Set(queue.map(v => v.toString("hex")));
+        for (let i = 0; i < this.entries.length && queue.length > 0; i++) {
+            const entry = !!this.entries[i] && Buffer.from(this.entries[i]!);
+            this.entries[i] = queue.pop()!;
+            if (entry && !set.has(entry.toString("hex")))
+                queue.unshift(entry);
+        }
+    }
+}

package/src/packet/decoder.ts

@@ -397,6 +397,27 @@ export class BinaryDecoder {
         return readX(this);
     }
 
+    /**
+     * Represents a set of IDs in a certain registry (implied by context), either directly (enumerated IDs) or indirectly (tag name).
+     * | Field Name | Field Type | Meaning |
+     * |------------|------------|---------|
+     * | Type       | VarInt     | Value used to determine the data that follows. It can be either: 0 - Represents a named set of IDs defined by a tag. Anything else - Represents an ad-hoc set of IDs enumerated inline. |
+     * | Tag Name   | Optional Identifier | The registry tag defining the ID set. Only present if Type is 0. |
+     * | IDs        | Optional Array of VarInt | An array of registry IDs. Only present if Type is not 0. The size of the array is equal to Type - 1. |
+     */
+    public readIdSet() {
+        const type = this.readVarInt();
+        let tagName: string | null = null,
+            ids: number[] | null = null;
+        if (type === 0) tagName = this.readString();
+        else ids = this.readArray(type - 1, decoder => decoder.readVarInt());
+        return {
+            type,
+            tagName,
+            ids
+        };
+    }
+
     /**
      * Read Chat Type Decoration
      * 

package/src/packet/dispatcher.ts

@@ -1,13 +1,18 @@
 import zod from "zod";
-import { createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes, constants as crypto_constants } from "node:crypto";
+import { createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes, constants as crypto_constants, createVerify } from "node:crypto";
 import { BlockEntity, ChunkSection, ClientPlayer, ClientStatus, ConnectionState, Entity, GameMode, PaletteContainer, ServerKnownPack, ServerWorld, SharedState } from "../world/state";
 import { BinaryDecoder, getTextFromTextComponent } from "./decoder";
 import { packBlockPos, SectionsPerChunk } from "../client/static";
-import { Vec3 } from "../physics/direction";
+import { Angle, BaseVec3, Vec3 } from "../physics/direction";
 import { ProtocolVersionMapping } from "../version/registry";
 import { TypedEmmiter } from "../base/event";
 import { ClientEvents } from "../client/client";
 import { makeMovementFlag } from "./encoder";
+import { TextComponent } from "../base/typing";
+import { AuthRelatedNotFound, HaveSignatureButNotIndex, MessageLinkNotFound, MissingAuthOption, NotImplemented, UnexpectedValue } from "../base/error";
+import { randomUUIDBytes, uuidToBuffer } from "../base/math";
+import { MessageLink } from "../message/link";
+import { sliceBuffer } from "../base/buffer";
 
 function zodParse<Type extends zod.ZodType>(data: object, zod: Type): zod.infer<Type> {
     return zod.parse(data);
@@ -50,8 +55,8 @@ export class Dispatcher {
         };
     }
 
-    public sendPacket: (packetId: string, data: object) => void = (...args) => { throw new Error("method not implemented"); };
-    public tcpDisconnect: () => void = () => { throw new Error("method not implemented"); };
+    public sendPacket: (packetId: string, data: object) => void = () => { throw new NotImplemented(); };
+    public disconnect: (reason: string, reasonRaw?: TextComponent) => void = () => { throw new NotImplemented(); };
 
 
     public handlePacket(packetId: string, data: object) {
@@ -65,15 +70,7 @@ export class Dispatcher {
         const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
         const text = getTextFromTextComponent(reason);
 
-        this.state.enqueueMutation((state) => {
-            state.status = ClientStatus.Disconnected;
-            state.state = ConnectionState.Disconnected;
-            state.pruneStates();
-        });
-
-        this.emit("disconnect", text.toString());
-        this.emit("disconnectRaw", reason);
-        this.tcpDisconnect();
+        this.disconnect(text, reason);
     }
 
     private handleEncryption(data: object) {
@@ -81,22 +78,30 @@ export class Dispatcher {
             server_id,
             public_key,
             verify_token,
-            shoudl_call_mojang
+            should_authenticate
         } = zodParse(data, zod.object({
             server_id: zod.string(),
             public_key: zod.array(zod.number()),
             verify_token: zod.array(zod.number()),
-            shoudl_call_mojang: zod.boolean()
+            should_authenticate: zod.boolean()
         }));
 
         const sharedSecret = randomBytes(16);
-        this.state.enqueueMutation((state) => {
-            state.sharedSecret = sharedSecret;
-            state.cipher = createCipheriv("aes-128-cfb8", state.sharedSecret, state.sharedSecret);
-            state.decipher = createDecipheriv("aes-128-cfb8", state.sharedSecret, state.sharedSecret);
-        });
-
-        this.sendEncryptionResponse(Buffer.from(public_key), Buffer.from(verify_token));
+        this.state.sharedSecret = sharedSecret;
+        this.state.cipher = createCipheriv("aes-128-cfb8", sharedSecret, sharedSecret);
+        this.state.decipher = createDecipheriv("aes-128-cfb8", sharedSecret, sharedSecret);
+        this.state.useEncryption = true;
+
+        const publicKey = Buffer.from(public_key),
+            verifyToken = Buffer.from(verify_token);
+        if (should_authenticate)
+            if (!this.state.authClient)
+                throw new AuthRelatedNotFound("auth client");
+            else
+                this.state.authClient.sendAuth(server_id, sharedSecret, publicKey)
+                    .then(() => this.sendEncryptionResponse(publicKey, verifyToken));
+        else
+            this.sendEncryptionResponse(publicKey, verifyToken);
     }
 
     private handleSetCompression(data: object) {
@@ -176,13 +181,7 @@ export class Dispatcher {
         const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
         const text = getTextFromTextComponent(reason);
 
-        this.state.status = ClientStatus.Disconnected;
-        this.state.state = ConnectionState.Disconnected;
-        this.state.pruneStates();
-
-        this.emit("disconnect", text.toString());
-        this.emit("disconnectRaw", reason);
-        this.tcpDisconnect();
+        this.disconnect(text, reason);
     }
 
     // Play
@@ -225,6 +224,9 @@ export class Dispatcher {
         this.state.player!.gameMode = game_mode;
         this.state.status = ClientStatus.Ready;
 
+        if (this.state.useEncryption)
+            this.sendPlayerSession();
+
         this.emit("ready");
     }
 
@@ -640,16 +642,84 @@ export class Dispatcher {
         const senderNameText = getTextFromTextComponent(sender_name).toString(),
             targetNameText = target_name ? getTextFromTextComponent(target_name).toString() : undefined;
 
-        this.emit("message", {
+        const emitObject = {
             sender: senderNameText,
             target: targetNameText,
-            content: message,
+            content: getTextFromTextComponent(unsigned_content),
             raw: {
                 sender: sender_name,
                 target: target_name || undefined,
                 content: unsigned_content || undefined,
             }
-        });
+        };
+
+        let link: MessageLink | undefined = undefined;
+        if (this.state.clientOptions.shouldVerifyMessageOrder && this.state.messageLinks) {
+            if (index === 0) {
+                if (this.state.sessionID)
+                    link = MessageLink.root(sender, this.state.sessionID.toString("hex"));
+                else
+                    link = MessageLink.unsinged(sender);
+                this.state.messageLinks[sender] = link;
+            } else {
+                const oldLink = this.state.messageLinks[sender];
+                if (!oldLink)
+                    throw new MessageLinkNotFound(sender);
+                let newLink;
+                if (this.state.sessionID)
+                    newLink = new MessageLink(global_index, sender, this.state.sessionID.toString("hex"));
+                else
+                    newLink = MessageLink.unsinged(sender);
+                if (!newLink.isDescendantOf(oldLink))
+                    throw new UnexpectedValue("message order", newLink.index.toString(), (oldLink.index + 1).toString());
+                this.state.messageLinks[sender] = newLink;
+                link = newLink;
+            }
+        }
+
+        if (this.state.clientOptions.shouldVerifyMessageSignature === true && message_signature_bytes) {
+            if (!this.state.sessionID)
+                throw new AuthRelatedNotFound("session uuid");
+            if (!this.state.messageSignatureCache)
+                throw new AuthRelatedNotFound("signature cache");
+            if (!link)
+                throw new HaveSignatureButNotIndex();
+            const { publicKey } = this.state.getSignature();
+
+            const formatVersion = Buffer.alloc(4); formatVersion.writeInt32BE(1);
+            const senderUUIDBuf = uuidToBuffer(sender);
+            const sessionUUIDBuf = this.state.sessionID;
+            const indexBuf = Buffer.alloc(4); indexBuf.writeInt32BE(link.index);
+            const saltBuf = Buffer.alloc(8); saltBuf.writeBigInt64BE(salt);
+            const timestampBuf = Buffer.alloc(8); timestampBuf.writeBigInt64BE(timestamp);
+            const _messageBuf = Buffer.from(message, "utf-8");
+            const lengthBuf = Buffer.alloc(4); lengthBuf.writeInt32BE(_messageBuf.length);
+            const messageBuf = _messageBuf;
+            const previousMessagesLenghtBuf = Buffer.alloc(4); previousMessagesLenghtBuf.writeInt32BE(previous_messages.length);
+            const previousMessagesBuf = Buffer.concat(this.state.messageSignatureCache.unpack(previous_messages));
+            const signaturePayload = Buffer.concat([
+                formatVersion,
+                senderUUIDBuf,
+                sessionUUIDBuf,
+                indexBuf,
+                saltBuf,
+                timestampBuf,
+                lengthBuf,
+                messageBuf,
+                previousMessagesLenghtBuf,
+                previousMessagesBuf
+            ]);
+
+            const verify = createVerify("RSA-SHA256");
+            verify.update(signaturePayload);
+            verify.end();
+            const signature = Buffer.from(message_signature_bytes);
+
+            if (!verify.verify(publicKey!, signature))
+                this.emit("failedMessage", emitObject);
+        }
+
+        this.emit("message", emitObject);
     }
 
     private handleSystemMessage(data: object) {
@@ -728,7 +798,7 @@ export class Dispatcher {
         this.state.status = ClientStatus.Logining;
         this.sendPacket("hello", {
             name: this.state.clientOptions.playerName,
-            player_uuid: this.state.getUuid()
+            player_uuid: Buffer.from(this.state.playerUUID!, "hex")
         });
     }
 
@@ -741,9 +811,11 @@ export class Dispatcher {
             key: createPublicKey({ key: publicKey, format: 'der', type: 'spki' }),
             padding: crypto_constants.RSA_PKCS1_PADDING
         }, verifyToken);
+        const secretBuf = sliceBuffer(encryptedSecret, 1, (buf) => buf.readInt8());
+        const token = sliceBuffer(encryptedVerifyToken, 1, (buf) => buf.readInt8());
         this.sendPacket("key", {
-            shared_secret: { value: encryptedSecret, length: 8 },
-            verify_token: { value: encryptedVerifyToken, length: 8 }
+            shared_secret: { value: secretBuf, length: secretBuf.length },
+            verify_token: { value: token, length: token.length }
         });
     }
 
@@ -771,6 +843,20 @@ export class Dispatcher {
 
     // Play
 
+    private sendPlayerSession() {
+        const sessionUUID = randomUUIDBytes();
+        const expireTime = 15 * 60 * 1000; // 15min in ms
+        const expiredAt = Date.now() + expireTime;
+        const { publicKey, signature } = this.state.getSignature();
+        this.state.sessionID = sessionUUID;
+        this.sendPacket("chat_session_update", {
+            session_id: sessionUUID,
+            expire_at: expiredAt,
+            public_key: publicKey,
+            signature
+        });
+    }
+
     private sendConfirmTeleportation(teleportId: number) {
         this.sendPacket("accept_teleportation", {
             teleport_id: teleportId
@@ -782,4 +868,52 @@ export class Dispatcher {
             keep_alive_id: id
         });
     }
+
+    public sendPlayerPos(
+        position: BaseVec3,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) {
+        const { x, y, z } = position;
+        this.state.enqueuePacket("move_player_pos", {
+            x, feet_y: y, z,
+            flags: makeMovementFlag(onGround, horizontalCollision)
+        });
+    }
+
+    public sendPlayerPosRot(
+        position: BaseVec3,
+        angle: Angle,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) {
+        const { x, y, z } = position,
+            { yaw, pitch } = angle;
+        this.state.enqueuePacket("move_player_pos_rot", {
+            x, feet_y: y, z,
+            yaw, pitch,
+            flags: makeMovementFlag(onGround, horizontalCollision)
+        });
+    }
+
+    public sendPlayerRot(
+        angle: Angle,
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) {
+        const { yaw, pitch } = angle;
+        this.state.enqueuePacket("move_player_rot", {
+            yaw, pitch,
+            flags: makeMovementFlag(onGround, horizontalCollision)
+        });
+    }
+
+    public sendPlayerStatus(
+        onGround: boolean,
+        horizontalCollision: boolean
+    ) {
+        this.state.enqueuePacket("move_player_status_only", {
+            flags: makeMovementFlag(onGround, horizontalCollision)
+        });
+    }
 }

package/src/physics/player.ts

@@ -3,25 +3,31 @@ import { Angle, Axis, BaseAxis, BaseVec3, Vec3 } from "./direction";
 import { AABB, Shapes, VoxelShape } from "./aabb";
 import { BlockGetter, BlockManager, BlockState } from "../world/block";
 import { clamp, Epsilon, equal, lerp } from "../base/math";
-import { ClientNotReady } from "../base/error";
+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,
 };
 
 /**
@@ -42,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;
@@ -67,9 +72,35 @@ export class Player {
             this.horizontalCollision = false;
             this.fallDistance = 0;
             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
      */
@@ -85,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;
@@ -101,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;
@@ -141,12 +158,19 @@ export class Player {
     }
     private setPos(pos: Vec3) {
         this.state.checkReady();
-        this.state.player!.position = pos.copyBase();
+        this.state.enqueueMutation((state) => state.player!.position = pos.copyBase());
     }
     private getAngle() {
         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.state.checkReady();
         return this.state.player!.dimension;
@@ -241,28 +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.state.enqueuePacket("move_player_pos_rot", {
-                x, feet_y: y, z,
-                yaw, pitch,
-                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
-            });
+            this.sendPlayerPosRot(this.getPos(), this.getAngle(), this.onGround, this.horizontalCollision);
         else if (move)
-            this.state.enqueuePacket("move_player_pos", {
-                x, feet_y: y, z,
-                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
-            });
+            this.sendPlayerPos(this.getPos(), this.onGround, this.horizontalCollision);
         else if (rot)
-            this.state.enqueuePacket("move_player_rot", {
-                yaw, pitch,
-                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
-            });
+            this.sendPlayerRot(this.getAngle(), this.onGround, this.horizontalCollision);
         else if (
             this.onGround !== this.lastOnGround ||
             this.horizontalCollision !== this.lastHorizontalCollision
         )
-            this.state.enqueuePacket("move_player_status_only", {
-                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
-            });
+            this.sendPlayerStatus(this.onGround, this.horizontalCollision);
 
         if (move) {
             this.lastPos = this.getPos();
@@ -276,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) {
@@ -284,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
 
@@ -312,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? -------|
      */
 
@@ -334,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;
@@ -389,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) {
@@ -433,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);
         }
 
@@ -600,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;
     }