Physics can now be modified per-dimension.

CONTRIBUTORS.md

@@ -2,3 +2,4 @@ The following people have contributed code to this project and hold the copyrigh
 * Pedro Gimeno Fortea (pgimeno) \<[email protected]\>
 * Nikola Schordinger (DeatHunter) \<Discord: DH#9367\>
 * Kurt Spencer (K.jpg) \<Discord: K.jpg#4154\>
+* Daniel Bradley (1SDAN) \<Discord: 1SDAN#3699\>

docs/lua-api-dimension.md

@@ -24,7 +24,74 @@ Example:
 biomes = {"default:grassland", "default:desert"}
 ```
 
-### `gravity`
+### `id`
+
+ID of the dimension. **Mandatory field.**
+
+Example:
+```lua
+id = "dimension_nether"
+```
+
+IDs are usually of the form `mod:dimension` but the `mod:` prefix is prepended automatically so it's not needed.
+
+### `name`
+
+Label of the dimension. **Mandatory field.**
+
+Example:
+```lua
+name = "Nether"
+```
+
+This label is the name that will appear everywhere in the game.
+
+### `player_physics`
+
+Table containing the physics properties of the dimension
+
+Example:
+```lua
+player_physics = {
+	gravity = 1.0,
+	jump_antigravity = 0.3,
+}
+```
+
+#### `air_speed_mod`
+
+The movement speed of players in this dimension is multiplied by this amount while in the air.
+
+Example:
+```lua
+air_speed_mod = 0.75
+```
+
+Default value is `0.75`.
+
+#### `fly_speed`
+
+Fly speed in this dimension.
+
+Example:
+```lua
+fly_speed = 0.75
+```
+
+Default value is `0.75`.
+
+#### `glide_gravity`
+
+Fall speed while holding Jump key in this dimension.
+
+Example:
+```lua
+glide_gravity = 0.05
+```
+
+Default value is `0.05`.
+
+#### `gravity`
 
 Gravity of the dimension.
 
@@ -35,27 +102,93 @@ gravity = 0.5
 
 Default value is `1`.
 
-### `id`
+#### `horizontal_sprint_mod`
 
-ID of the dimension. **Mandatory field.**
+Horizontal sprint speed multiplier.
 
 Example:
 ```lua
-id = "dimension_nether"
+horizontal_sprint_mod = 1.5
 ```
 
-IDs are usually of the form `mod:dimension` but the `mod:` prefix is prepended automatically so it's not needed.
+Default value is `1.5`.
 
-### `name`
+#### `is_sneak_always_mod`
 
-Label of the dimension. **Mandatory field.**
+Whether sneaking applies the horizontal mod while airborne.
 
 Example:
 ```lua
-name = "Nether"
+is_sneak_always_mod = false
 ```
 
-This label is the name that will appear everywhere in the game.
+Default value is `false`.
+
+#### `jump_antigravity`
+
+Gravity is decreased by this amount while holding the jump key prior to the peak of the jump.
+
+Example:
+```lua
+jump_antigravity = 0.04
+```
+
+Default value is `0.04`.
+
+#### `jump_speed`
+
+Jump speed of the dimension.
+
+Example:
+```lua
+jump_speed = 0.3
+```
+
+Default value is `0.3`.
+
+#### `move_speed`
+
+Movement speed in this dimension.
+
+Example:
+```lua
+move_speed = 0.04
+```
+
+Default value is `0.04`.
+
+#### `sneak_horizontal_mod`
+
+Horizontal movement speed is multiplied by this amount while sneaking.
+
+Example:
+```lua
+sneak_horizontal_mod = 0.1
+```
+
+Default value is `0.1`.
+
+#### `sneak_vertical_speed`
+
+Vertical movement speed is multiplied by this amount while sneaking.
+
+Example:
+```lua
+sneak_vertical_speed = 0.1
+```
+
+Default value is `0.1`.
+
+#### `vertical_sprint_mod`
+
+Vertical sprint speed multiplier.
+
+Example:
+```lua
+vertical_sprint_mod = 1.5
+```
+
+Default value is `1.5`.
 
 ### `sky`
 

mods/default/dimensions.lua

@@ -41,7 +41,9 @@ mod:dimension {
 	biomes = {"default:netherland"},
 
 	sky = "default:sky_nether",
-
-	gravity = 1.4,
+
+	player_physics = {
+		gravity = 1.4,
+	}
 }
 

source/client/states/GameState.cpp

@@ -159,7 +159,7 @@ void GameState::update() {
 		m_camera.setFieldOfView(Config::cameraFOV);
 
 	if (!m_stateStack->empty() && &m_stateStack->top() == this) {
-		m_player.processInputs();
+		m_player.processInputs(*m_world.dimension());
 	}
 
 	if (!m_areModKeysLoaded) {

source/client/world/ClientPlayer.cpp

@@ -72,54 +72,80 @@ void ClientPlayer::updateCamera() {
 	m_camera.setUpVector(gk::Vector3f{sh * sr - ch * sv * cr, -ch * sr - sh * sv * cr, cv * cr});
 }
 
-void ClientPlayer::move(float direction) {
+void ClientPlayer::move(const Dimension &dimension, float direction) {
 	direction += m_viewAngleH;
 
-	m_velocity.x = 0.04f * cosf(direction * RADIANS_PER_DEGREES);
-	m_velocity.y = 0.04f * sinf(direction * RADIANS_PER_DEGREES);
+	m_velocity.x = dimension.physics().moveSpeed * cosf(direction * RADIANS_PER_DEGREES);
+	m_velocity.y =dimension.physics().moveSpeed * sinf(direction * RADIANS_PER_DEGREES);
 }
 
-void ClientPlayer::processInputs() {
-	if(gk::GamePad::isKeyPressed(GameKey::Jump) && !m_isJumping) {
-		m_isJumping = true;
-		m_velocity.z = m_jumpSpeed;
-	}
+void ClientPlayer::processInputs(const Dimension &dimension) {
+	if(gk::GamePad::isKeyPressed(GameKey::Jump)) {
+		if (!m_isJumping) {
+			m_isJumping = true;
+			m_velocity.z = dimension.physics().jumpSpeed;
+		}
 
-	if(gk::GamePad::isKeyPressed(GameKey::Fly)) {
-		m_velocity.z = 0.1;
-	}
+		if (m_isJumping && m_velocity.z > 0.0f) {
+			m_velocity.z += dimension.physics().jumpAntigravity * 0.001f;
+		}
 
-	if(gk::GamePad::isKeyPressed(GameKey::Sneak)) {
-		m_velocity.z = -0.1;
+		if (m_velocity.z < 0.0f) {
+			if (!m_isGliding) m_isGliding = true;
+		}
+	}
+	else {
+		if (m_velocity.z < 0.0f) {
+			if (m_isGliding) m_isGliding = false;
+		}
 	}
 
-	if(gk::GamePad::isKeyPressed(GameKey::Forward))    move(0.0f);
-	else if(gk::GamePad::isKeyPressed(GameKey::Back))  move(180.0f);
+	if(gk::GamePad::isKeyPressed(GameKey::Forward))    move(dimension, 0.0f);
+	else if(gk::GamePad::isKeyPressed(GameKey::Back))  move(dimension, 180.0f);
 
-	if(gk::GamePad::isKeyPressed(GameKey::Left))       move(90.0f);
-	else if(gk::GamePad::isKeyPressed(GameKey::Right)) move(-90.0f);
+	if(gk::GamePad::isKeyPressed(GameKey::Left))       move(dimension, 90.0f);
+	else if(gk::GamePad::isKeyPressed(GameKey::Right)) move(dimension, -90.0f);
 
-	if (gk::GamePad::isKeyPressed(GameKey::Left)  && gk::GamePad::isKeyPressed(GameKey::Forward)) move(45.0f);
-	if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Forward)) move(-45.0f);
-	if (gk::GamePad::isKeyPressed(GameKey::Left)  && gk::GamePad::isKeyPressed(GameKey::Back))    move(135.0f);
-	if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Back))    move(-135.0f);
+	if (gk::GamePad::isKeyPressed(GameKey::Left)  && gk::GamePad::isKeyPressed(GameKey::Forward)) move(dimension, 45.0f);
+	if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Forward)) move(dimension, -45.0f);
+	if (gk::GamePad::isKeyPressed(GameKey::Left)  && gk::GamePad::isKeyPressed(GameKey::Back))    move(dimension, 135.0f);
+	if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Back))    move(dimension, -135.0f);
 
 	if (gk::GamePad::isKeyPressed(GameKey::Sprint)) {
-		m_velocity.x *= 1.5f;
-		m_velocity.y *= 1.5f;
+		m_velocity.x *= dimension.physics().horizontalSprintMod;
+		m_velocity.y *= dimension.physics().verticalSprintMod;
+	}
+
+	if(gk::GamePad::isKeyPressed(GameKey::Fly)) {
+		m_velocity.z = dimension.physics().flySpeed;
+	}
+
+	if(gk::GamePad::isKeyPressed(GameKey::Sneak)) {
+		if (m_velocity.z == 0 || dimension.physics().isSneakAlwaysMod) {
+			m_velocity.x *= dimension.physics().sneakHorizontalMod;
+			m_velocity.y *= dimension.physics().sneakHorizontalMod;
+		}
+
+		m_velocity.z = -dimension.physics().sneakVerticalSpeed;
 	}
 }
 
 void ClientPlayer::updatePosition(const ClientWorld &world) {
 	ClientChunk *chunk = (ClientChunk *)world.getChunkAtBlockPos(m_x, m_y, m_z);
 	if (chunk && chunk->isInitialized()) {
 		if (!Config::isFlyModeEnabled) {
-			m_velocity.z -= chunk->dimension().gravity() * 0.001f;
+			m_velocity.z -= world.dimension()->physics().gravity * 0.001f;
 
 			m_isJumping = true;
 
-			if (m_velocity.z < -m_jumpSpeed) // Limit max vertical speed to jump speed
-				m_velocity.z = -m_jumpSpeed;
+			if (m_isGliding) {
+				if (m_velocity.z < -world.dimension()->physics().glideGravity) // Limit max vertical speed to glide gravity
+					m_velocity.z = -world.dimension()->physics().glideGravity;
+			}
+			else {
+				if (m_velocity.z < -world.dimension()->physics().jumpSpeed) // Limit max vertical speed to jump speed
+					m_velocity.z = -world.dimension()->physics().jumpSpeed;
+			}
 		}
 	}
 	else {
@@ -131,8 +157,8 @@ void ClientPlayer::updatePosition(const ClientWorld &world) {
 		checkCollisions(world);
 
 	if (!Config::isFlyModeEnabled && m_velocity.z != 0.f) {
-		m_velocity.x *= 0.75f;
-		m_velocity.y *= 0.75f;
+		m_velocity.x *= world.dimension()->physics().airSpeedMod;
+		m_velocity.y *= world.dimension()->physics().airSpeedMod;
 	}
 
 	setPosition(m_x + m_velocity.x, m_y + m_velocity.y, m_z + m_velocity.z);
@@ -194,6 +220,7 @@ void ClientPlayer::testPoint(const ClientWorld &world, double x, double y, doubl
 	if(!passable(world, x, y + vel.y, z)) vel.y = 0.f;
 	if(!passable(world, x, y, z + vel.z)) {
 		if(vel.z < 0.f && m_isJumping) m_isJumping = false;
+		if(vel.z < 0.f && m_isGliding) m_isGliding = false;
 		vel.z = 0.f;
 	}
 }

source/client/world/ClientPlayer.hpp

@@ -34,6 +34,7 @@
 #include <gk/gl/Camera.hpp>
 
 #include "Player.hpp"
+#include "Dimension.hpp"
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
@@ -54,9 +55,9 @@ class ClientPlayer : public Player {
 
 		void updateCamera();
 
-		void move(float direction);
+		void move(const Dimension &dimension, float direction);
 
-		void processInputs();
+		void processInputs(const Dimension &dimension);
 		void updatePosition(const ClientWorld &world);
 
 		void checkCollisions(const ClientWorld &world);
@@ -86,8 +87,7 @@ class ClientPlayer : public Player {
 
 		glm::vec3 m_velocity{0.f};
 		bool m_isJumping = false;
-
-		const float m_jumpSpeed = 0.06f;
+		bool m_isGliding = false;
 };
 
 #endif // CLIENTPLAYER_HPP_

source/client/world/ClientWorld.hpp

@@ -52,7 +52,8 @@ class ClientWorld : public World, public gk::Drawable {
 		void checkPlayerChunk(double playerX, double playerY, double playerZ);
 
 		void clear();
-
+
+		const Dimension *dimension() const { return m_dimension; }
 		void changeDimension(u16 dimensionID);
 
 		void receiveChunkData(Network::Packet &packet);

source/common/world/Dimension.cpp

@@ -28,11 +28,11 @@
 #include "NetworkUtils.hpp"
 
 void Dimension::serialize(sf::Packet &packet) const {
-	packet << m_id << m_stringID << m_name << m_biomes << m_sky << m_gravity;
+	packet << m_id << m_stringID << m_name << m_biomes << m_sky << m_physics;
 }
 
 void Dimension::deserialize(sf::Packet &packet) {
-	packet >> m_id >> m_stringID >> m_name >> m_biomes >> m_sky >> m_gravity;
+	packet >> m_id >> m_stringID >> m_name >> m_biomes >> m_sky >> m_physics;
 }
 
 // Please update 'docs/lua-api-cpp.md' if you change this