Added crouching and block based friction

assets/cubyz/blocks/frost.zig.zon

@@ -7,4 +7,5 @@
 	.model = "cubyz:cube",
 	.texture = "cubyz:frost",
 	.blockEntity = "cubyz.modding.base.MeltableBlockEntity",
+	.friction = 5,
 }

assets/cubyz/blocks/ice.zig.zon

@@ -10,4 +10,5 @@
 	.model = "cubyz:cube",
 	.texture = "cubyz:ice",
 	.blockEntity = "cubyz.modding.base.MeltableBlockEntity",
+	.friction = 1,
 }

src/blocks.zig

@@ -82,6 +82,7 @@ var _gui: [maxBlockCount][]u8 = undefined;
 var _mode: [maxBlockCount]*RotationMode = undefined;
 var _lodReplacement: [maxBlockCount]u16 = undefined;
 var _opaqueVariant: [maxBlockCount]u16 = undefined;
+var _friction: [maxBlockCount]f32 = undefined;
 
 var reverseIndices = std.StringHashMap(u16).init(allocator.allocator);
 
@@ -122,6 +123,7 @@ pub fn register(_: []const u8, id: []const u8, zon: ZonElement) u16 {
 	_alwaysViewThrough[size] = zon.get(bool, "alwaysViewThrough", false);
 	_viewThrough[size] = zon.get(bool, "viewThrough", false) or _transparent[size] or _alwaysViewThrough[size];
 	_hasBackFace[size] = zon.get(bool, "hasBackFace", false);
+	_friction[size] = zon.get(f32, "friction", 20);
 
 	const oreProperties = zon.getChild("ore");
 	if (oreProperties != .null) {
@@ -343,6 +345,10 @@ pub const Block = packed struct { // MARK: Block
 		return _opaqueVariant[self.typ];
 	}
 
+	pub inline fn friction(self: Block) f32 {
+		return _friction[self.typ];
+	}
+
 	pub fn canBeChangedInto(self: Block, newBlock: Block, item: main.items.ItemStack) main.rotation.RotationMode.CanBeChangedInto {
 		return newBlock.mode().canBeChangedInto(self, newBlock, item);
 	}

src/game.zig

@@ -15,6 +15,7 @@ const Connection = network.Connection;
 const ConnectionManager = network.ConnectionManager;
 const vec = @import("vec.zig");
 const Vec2f = vec.Vec2f;
+const Vec2d = vec.Vec2d;
 const Vec3f = vec.Vec3f;
 const Vec4f = vec.Vec4f;
 const Vec3d = vec.Vec3d;
@@ -277,6 +278,47 @@ pub const collision = struct {
 		return resultBox;
 	}
 
+	pub fn calculateFriction(comptime side: main.utils.Side, pos: Vec3d, hitBox: Box, defaultFriction: f32) f32 {
+		const boundingBox: Box = .{
+			.min = pos + hitBox.min,
+			.max = pos + hitBox.max,
+		};
+		const minX: i32 = @intFromFloat(@floor(boundingBox.min[0]));
+		const maxX: i32 = @intFromFloat(@floor(boundingBox.max[0] - 0.0001));
+		const minY: i32 = @intFromFloat(@floor(boundingBox.min[1]));
+		const maxY: i32 = @intFromFloat(@floor(boundingBox.max[1] - 0.0001));
+
+		const z: i32 = @intFromFloat(@floor(boundingBox.min[2] - 0.01));
+
+		var friction: f64 = 0;
+		var totalArea: f64 = 0;
+
+		var x = minX;
+		while (x <= maxX) : (x += 1) {
+			var y = minY;
+			while (y <= maxY) : (y += 1) {
+				const _block = if(side == .client) main.renderer.mesh_storage.getBlock(x, y, z)
+				else main.server.world.?.getBlock(x, y, z);
+				const min = @max(Vec2d{@floatFromInt(x), @floatFromInt(y)}, vec.xy(boundingBox.min));
+				const max = @min(Vec2d{@floatFromInt(x + 1), @floatFromInt(y + 1)}, vec.xy(boundingBox.max));
+				const area = (max[0] - min[0]) * (max[1] - min[1]);
+
+				if (_block) |block| {
+					if (block.collide()) {
+						totalArea += area;
+						friction += area * @as(f64, @floatCast(1 / block.friction()));
+					}
+				}
+			}
+		}
+
+		if (totalArea == 0) {
+			return defaultFriction;
+		}
+
+		return @floatCast(totalArea / friction);
+	}
+
 	pub fn collideOrStep(comptime side: main.utils.Side, comptime dir: Direction, amount: f64, pos: Vec3d, hitBox: Box, steppingHeight: f64) Vec3d {
 		const index = @intFromEnum(dir);
 
@@ -332,6 +374,7 @@ pub const Player = struct { // MARK: Player
 	pub var eyeVel: Vec3d = .{0, 0, 0};
 	pub var eyeCoyote: f64 = 0;
 	pub var eyeStep: @Vector(3, bool) = .{false, false, false};
+	pub var crouching: bool = false;
 	pub var id: u32 = 0;
 	pub var gamemode: Atomic(Gamemode) = .init(.creative);
 	pub var isFlying: Atomic(bool) = .init(false);
@@ -341,24 +384,30 @@ pub const Player = struct { // MARK: Player
 	pub var inventory: Inventory = undefined;
 	pub var selectedSlot: u32 = 0;
 
+	pub var currentFriction: f32 = 0;
+
 	pub var maxHealth: f32 = 8;
 	pub var health: f32 = 4.5;
 
 	pub var onGround: bool = false;
 	pub var jumpCooldown: f64 = 0;
 	const jumpCooldownConstant = 0.3;
 
-	pub const outerBoundingBoxExtent: Vec3d = .{0.3, 0.3, 0.9};
-	pub const outerBoundingBox: collision.Box = .{
-		.min = -outerBoundingBoxExtent,
-		.max = outerBoundingBoxExtent,
+	const standingBoundingBoxExtent: Vec3d = .{0.3, 0.3, 0.9};
+	const crouchingBoundingBoxExtent: Vec3d = .{0.3, 0.3, 0.725};
+	var crouchPerc: f32 = 0;
+
+	var outerBoundingBoxExtent: Vec3d = standingBoundingBoxExtent;
+	pub var outerBoundingBox: collision.Box = .{
+		.min = -standingBoundingBoxExtent,
+		.max = standingBoundingBoxExtent,
 	};
-	const eyeBox: collision.Box = .{
-		.min = -Vec3d{outerBoundingBoxExtent[0]*0.2, outerBoundingBoxExtent[1]*0.2, 0.6},
-		.max = Vec3d{outerBoundingBoxExtent[0]*0.2, outerBoundingBoxExtent[1]*0.2, 0.9 - 0.05},
+	var eyeBox: collision.Box = .{
+		.min = -Vec3d{standingBoundingBoxExtent[0]*0.2, standingBoundingBoxExtent[1]*0.2, 0.6},
+		.max = Vec3d{standingBoundingBoxExtent[0]*0.2, standingBoundingBoxExtent[1]*0.2, 0.9 - 0.05},
 	};
-	pub const desiredEyePos: Vec3d = .{0, 0, 1.7 - outerBoundingBoxExtent[2]};
-	pub const jumpHeight = 1.25;
+	var desiredEyePos: Vec3d = .{0, 0, 1.7 - standingBoundingBoxExtent[2]};
+	const jumpHeight = 1.25;
 
 	fn loadFrom(zon: ZonElement) void {
 		super.loadFrom(zon);
@@ -680,7 +729,8 @@ pub fn update(deltaTime: f64) void { // MARK: update()
 			acc[2] = -gravity;
 		}
 
-		var baseFrictionCoefficient: f32 = 50;
+		Player.currentFriction = if (Player.isFlying.load(.monotonic)) 20 else collision.calculateFriction(.client, Player.super.pos, Player.outerBoundingBox, 20);
+		var baseFrictionCoefficient: f32 = Player.currentFriction;
 		var directionalFrictionCoefficients: Vec3f = @splat(0);
 		const speedMultiplier: f32 = if(Player.hyperSpeed.load(.monotonic)) 4.0 else 1.0;
 
@@ -697,9 +747,11 @@ pub fn update(deltaTime: f64) void { // MARK: update()
 		const right = Vec3d{-forward[1], forward[0], 0};
 		var movementDir: Vec3d = .{0, 0, 0};
 		var movementSpeed: f64 = 0;
+
 		if(main.Window.grabbed) {
+			const walkingSpeed: f64 = if (Player.crouching) 2 else 4;
 			if(KeyBoard.key("forward").value > 0.0) {
-				if(KeyBoard.key("sprint").pressed) {
+				if (KeyBoard.key("sprint").pressed and !Player.crouching) {
 					if(Player.isGhost.load(.monotonic)) {
 						movementSpeed = @max(movementSpeed, 128)*KeyBoard.key("forward").value;
 						movementDir += forward*@as(Vec3d, @splat(128*KeyBoard.key("forward").value));
@@ -711,21 +763,21 @@ pub fn update(deltaTime: f64) void { // MARK: update()
 						movementDir += forward*@as(Vec3d, @splat(8*KeyBoard.key("forward").value));
 					}
 				} else {
-					movementSpeed = @max(movementSpeed, 4)*KeyBoard.key("forward").value;
-					movementDir += forward*@as(Vec3d, @splat(4*KeyBoard.key("forward").value));
+					movementSpeed = @max(movementSpeed, walkingSpeed)*KeyBoard.key("forward").value;
+					movementDir += forward*@as(Vec3d, @splat(walkingSpeed*KeyBoard.key("forward").value));
 				}
 			}
 			if(KeyBoard.key("backward").value > 0.0) {
-				movementSpeed = @max(movementSpeed, 4)*KeyBoard.key("backward").value;
-				movementDir += forward*@as(Vec3d, @splat(-4*KeyBoard.key("backward").value));
+				movementSpeed = @max(movementSpeed, walkingSpeed)*KeyBoard.key("backward").value;
+				movementDir += forward*@as(Vec3d, @splat(-walkingSpeed*KeyBoard.key("backward").value));
 			}
 			if(KeyBoard.key("left").value > 0.0) {
-				movementSpeed = @max(movementSpeed, 4*KeyBoard.key("left").value);
-				movementDir += right*@as(Vec3d, @splat(4*KeyBoard.key("left").value));
+				movementSpeed = @max(movementSpeed, walkingSpeed)*KeyBoard.key("left").value;
+				movementDir += right*@as(Vec3d, @splat(walkingSpeed*KeyBoard.key("left").value));
 			}
 			if(KeyBoard.key("right").value > 0.0) {
-				movementSpeed = @max(movementSpeed, 4*KeyBoard.key("right").value);
-				movementDir += right*@as(Vec3d, @splat(-4*KeyBoard.key("right").value));
+				movementSpeed = @max(movementSpeed, walkingSpeed)*KeyBoard.key("right").value;
+				movementDir += right*@as(Vec3d, @splat(-walkingSpeed*KeyBoard.key("right").value));
 			}
 			if(KeyBoard.key("jump").pressed) {
 				if(Player.isFlying.load(.monotonic)) {
@@ -779,6 +831,40 @@ pub fn update(deltaTime: f64) void { // MARK: update()
 			main.game.camera.moveRotation(newPos[0] / 64.0, newPos[1] / 64.0);
 		}
 
+		if (collision.collides(.client, .x, 0, Player.super.pos + Player.standingBoundingBoxExtent - Player.crouchingBoundingBoxExtent, .{
+			.min = -Player.standingBoundingBoxExtent,
+			.max = Player.standingBoundingBoxExtent,
+		}) == null) {
+			Player.crouching = KeyBoard.key("crouch").pressed and !Player.isFlying.load(.monotonic);
+
+			if (Player.onGround) {
+				if (Player.crouching) {
+					Player.crouchPerc += @floatCast(deltaTime * 10);
+				} else {
+					Player.crouchPerc -= @floatCast(deltaTime * 10);
+				}
+				Player.crouchPerc = std.math.clamp(Player.crouchPerc, 0, 1);
+			}
+
+			const smoothPerc = Player.crouchPerc * Player.crouchPerc * (3 - 2 * Player.crouchPerc);
+
+			const newOuterBox = (Player.crouchingBoundingBoxExtent - Player.standingBoundingBoxExtent) * @as(Vec3d, @splat(smoothPerc)) + Player.standingBoundingBoxExtent;
+
+			Player.super.pos += newOuterBox - Player.outerBoundingBoxExtent;
+
+			Player.outerBoundingBoxExtent = newOuterBox;
+
+			Player.outerBoundingBox = .{
+				.min = -Player.outerBoundingBoxExtent,
+				.max = Player.outerBoundingBoxExtent,
+			};
+			Player.eyeBox = .{
+				.min = -Vec3d{Player.outerBoundingBoxExtent[0]*0.2, Player.outerBoundingBoxExtent[1]*0.2, Player.outerBoundingBoxExtent[2] - 0.2},
+				.max = Vec3d{Player.outerBoundingBoxExtent[0]*0.2, Player.outerBoundingBoxExtent[1]*0.2, Player.outerBoundingBoxExtent[2] - 0.05},
+			};
+			Player.desiredEyePos = (Vec3d{0, 0, 1.3 - Player.crouchingBoundingBoxExtent[2]} - Vec3d{0, 0, 1.7 - Player.standingBoundingBoxExtent[2]}) * @as(Vec3f, @splat(smoothPerc)) + Vec3d{0, 0, 1.7 - Player.standingBoundingBoxExtent[2]};
+		}
+
 		// This our model for movement on a single frame:
 		// dv/dt = a - λ·v
 		// dx/dt = v
@@ -911,10 +997,25 @@ pub fn update(deltaTime: f64) void { // MARK: update()
 		}
 		steppingHeight = @min(steppingHeight, Player.eyePos[2] - Player.eyeBox.min[2]);
 
+		const slipLimit = 0.25 * Player.currentFriction;
+
 		const xMovement = collision.collideOrStep(.client, .x, move[0], Player.super.pos, hitBox, steppingHeight);
 		Player.super.pos += xMovement;
+		if (KeyBoard.key("crouch").pressed and Player.onGround and @abs(Player.super.vel[0]) < slipLimit) {
+			if (collision.collides(.client, .x, 0, Player.super.pos - Vec3d{0, 0, 1}, hitBox) == null) {
+				Player.super.pos -= xMovement;
+				Player.super.vel[0] = 0;
+			}
+		}
+
 		const yMovement = collision.collideOrStep(.client, .y, move[1], Player.super.pos, hitBox, steppingHeight);
 		Player.super.pos += yMovement;
+		if (KeyBoard.key("crouch").pressed and Player.onGround and @abs(Player.super.vel[1]) < slipLimit) {
+			if (collision.collides(.client, .y, 0, Player.super.pos - Vec3d{0, 0, 1}, hitBox) == null) {
+				Player.super.pos -= yMovement;
+				Player.super.vel[1] = 0;
+			}
+		}
 
 		if (xMovement[0] != move[0]) {
 			Player.super.vel[0] = 0;

src/main.zig

@@ -331,6 +331,7 @@ pub const KeyBoard = struct { // MARK: KeyBoard
 		.{.name = "right", .key = c.GLFW_KEY_D, .gamepadAxis = .{.axis = c.GLFW_GAMEPAD_AXIS_LEFT_X, .positive = true}},
 		.{.name = "sprint", .key = c.GLFW_KEY_LEFT_CONTROL, .gamepadButton = c.GLFW_GAMEPAD_BUTTON_LEFT_THUMB},
 		.{.name = "jump", .key = c.GLFW_KEY_SPACE, .gamepadButton = c.GLFW_GAMEPAD_BUTTON_A},
+		.{.name = "crouch", .key = c.GLFW_KEY_LEFT_SHIFT, .gamepadButton = c.GLFW_GAMEPAD_BUTTON_RIGHT_THUMB},
 		.{.name = "fly", .key = c.GLFW_KEY_F, .gamepadButton = c.GLFW_GAMEPAD_BUTTON_DPAD_DOWN, .pressAction = &game.flyToggle},
 		.{.name = "ghost", .key = c.GLFW_KEY_G, .pressAction = &game.ghostToggle},
 		.{.name = "hyperSpeed", .key = c.GLFW_KEY_H, .pressAction = &game.hyperSpeedToggle},