From 3fe772de77ae8830069b436be07f3c6c4d45a17f Mon Sep 17 00:00:00 2001 From: earthcrafterman Date: Sat, 11 Jul 2020 12:49:04 -0400 Subject: [PATCH] Physics can now be modified per-dimension. --- docs/lua-api-dimension.md | 133 ++++++++++++++++++ mods/default/dimensions.lua | 6 +- source/client/states/GameState.cpp | 2 +- source/client/world/ClientPlayer.cpp | 85 +++++++---- source/client/world/ClientPlayer.hpp | 7 +- source/common/world/Dimension.cpp | 4 +- source/common/world/Dimension.hpp | 8 +- source/common/world/DimensionPhysics.cpp | 41 ++++++ source/common/world/DimensionPhysics.hpp | 51 +++++++ .../server/lua/loader/LuaDimensionLoader.cpp | 28 +++- 10 files changed, 324 insertions(+), 41 deletions(-) create mode 100644 source/common/world/DimensionPhysics.cpp create mode 100644 source/common/world/DimensionPhysics.hpp diff --git a/docs/lua-api-dimension.md b/docs/lua-api-dimension.md index 8b2daef19..1266d9e82 100644 --- a/docs/lua-api-dimension.md +++ b/docs/lua-api-dimension.md @@ -24,6 +24,18 @@ Example: biomes = {"default:grassland", "default:desert"} ``` +### `player_physics` + +Table containing physics the properties of the dimension + +Example: +```lua +player_physics = { + gravity = 1.0, + jump_antigravity = 0.3, +} +``` + ### `gravity` Gravity of the dimension. @@ -35,6 +47,127 @@ gravity = 0.5 Default value is `1`. +### `jump_speed` + +Jump speed of the dimension. + +Example: +```lua +jump_speed = 0.3 +``` + +Default value is `0.3`. + +### `jump_antigravity` + +The gravity of the dimension is decreased by this amount while holding space prior to the peak of your jump. + +Example: +```lua +jump_antigravity = 0.04 +``` + +Default value is `0.04`. + +### `glide_gravity` + +Fall Speed while holding Space in the dimension. + +Example: +```lua +glide_gravity = 0.05 +``` + +Default value is `0.05`. + +### `horizontal_sprint_mod` + +Amount to multiply a player's horizontal velocity while sprinting in this dimension. + +Example: +```lua +horizontal_sprint_mod = 1.5 +``` + +Default value is `1.5`. + +### `vertical_sprint_mod` + +Amount to multiply a player's vertical velocity while sprinting in this dimension. + +Example: +```lua +vertical_sprint_mod = 1.5 +``` + +Default value is `1.5`. + +### `move_speed` + +Movement speed in this dimension. + +Example: +```lua +move_speed = 0.04 +``` + +Default value is `0.04`. + +### `air_speed_mod` + +The movement speed of 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`. + +### `sneak_vertical_speed` + +The vertical movement speed of this dimension is multiplied by this amount while sneaking. + +Example: +```lua +sneak_vertical_speed = 0.1 +``` + +Default value is `0.1`. + +### `sneak_horizontal_mod` + +The horizontal movement speed of this dimension is multiplied by this amount while sneaking. + +Example: +```lua +sneak_horizontal_mod = 0.1 +``` + +Default value is `0.1`. + +### `is_sneak_always_mod` + +Whether the horizontal movement speed of this dimension is only multiplied while sneaking on the ground + +Example: +```lua +sneak_horizontal_mod = false +``` + +Default value is `false`. + ### `id` ID of the dimension. **Mandatory field.** diff --git a/mods/default/dimensions.lua b/mods/default/dimensions.lua index 7567ecadd..86c1465fa 100644 --- a/mods/default/dimensions.lua +++ b/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, + } } diff --git a/source/client/states/GameState.cpp b/source/client/states/GameState.cpp index c3de47466..c6c1cec46 100644 --- a/source/client/states/GameState.cpp +++ b/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); } if (!m_areModKeysLoaded) { diff --git a/source/client/world/ClientPlayer.cpp b/source/client/world/ClientPlayer.cpp index f1f86e16e..08ea42527 100644 --- a/source/client/world/ClientPlayer.cpp +++ b/source/client/world/ClientPlayer.cpp @@ -72,41 +72,63 @@ 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 ClientWorld &world, 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 = world->dimension().physics().moveSpeed * cosf(direction * RADIANS_PER_DEGREES); + m_velocity.y = world->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 ClientWorld &world) { + ClientChunk *chunk = (ClientChunk *)world.getChunkAtBlockPos(m_x, m_y, m_z); - if(gk::GamePad::isKeyPressed(GameKey::Fly)) { - m_velocity.z = 0.1; - } + if(gk::GamePad::isKeyPressed(GameKey::Jump)) { + if (!m_isJumping) { + m_isJumping = true; + m_velocity.z = chunk->dimension().physics().jumpSpeed; + } - if(gk::GamePad::isKeyPressed(GameKey::Sneak)) { - m_velocity.z = -0.1; + if (m_isJumping && m_velocity.z > 0.0f) { + m_velocity.z += world->dimension().physics().jumpAntigravity * 0.001f; + } + + 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(world, 0.0f); + else if(gk::GamePad::isKeyPressed(GameKey::Back)) move(world, 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(world, 90.0f); + else if(gk::GamePad::isKeyPressed(GameKey::Right)) move(world, -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(world, 45.0f); + if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Forward)) move(world, -45.0f); + if (gk::GamePad::isKeyPressed(GameKey::Left) && gk::GamePad::isKeyPressed(GameKey::Back)) move(world, 135.0f); + if (gk::GamePad::isKeyPressed(GameKey::Right) && gk::GamePad::isKeyPressed(GameKey::Back)) move(world, -135.0f); if (gk::GamePad::isKeyPressed(GameKey::Sprint)) { - m_velocity.x *= 1.5f; - m_velocity.y *= 1.5f; + m_velocity.x *= world->dimension().physics().horizontalSprintMod; + m_velocity.y *= world->dimension().physics().verticalSprintMod; + } + + if(gk::GamePad::isKeyPressed(GameKey::Fly)) { + m_velocity.z = world->dimension().physics().flySpeed; + } + + if(gk::GamePad::isKeyPressed(GameKey::Sneak)) { + if (m_velocity.z == 0 || world->dimension().physics().isSneakAlwaysMod) { + m_velocity.x *= world->dimension().physics().sneakHorizontalMod; + m_velocity.y *= world->dimension().physics().sneakHorizontalMod; + } + + m_velocity.z = -world->dimension().physics().sneakVerticalSpeed; } } @@ -114,12 +136,18 @@ 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 -= chunk->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 < -chunk->dimension().physics().glideGravity) // Limit max vertical speed to glide gravity + m_velocity.z = -chunk->dimension().physics().glideGravity; + } + else { + if (m_velocity.z < -chunk->dimension().physics().jumpSpeed) // Limit max vertical speed to jump speed + m_velocity.z = -chunk->dimension().physics().jumpSpeed; + } } } else { @@ -131,8 +159,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 *= chunk->dimension().physics().airSpeedMod; + m_velocity.y *= chunk->dimension().physics().airSpeedMod; } setPosition(m_x + m_velocity.x, m_y + m_velocity.y, m_z + m_velocity.z); @@ -194,6 +222,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; } } diff --git a/source/client/world/ClientPlayer.hpp b/source/client/world/ClientPlayer.hpp index 9789881fe..c07ffad52 100644 --- a/source/client/world/ClientPlayer.hpp +++ b/source/client/world/ClientPlayer.hpp @@ -54,9 +54,9 @@ class ClientPlayer : public Player { void updateCamera(); - void move(float direction); + void move(const ClientWorld &world, float direction); - void processInputs(); + void processInputs(const ClientWorld &world); void updatePosition(const ClientWorld &world); void checkCollisions(const ClientWorld &world); @@ -86,8 +86,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_ diff --git a/source/common/world/Dimension.cpp b/source/common/world/Dimension.cpp index a4826b973..a53fa11a4 100644 --- a/source/common/world/Dimension.cpp +++ b/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 diff --git a/source/common/world/Dimension.hpp b/source/common/world/Dimension.hpp index 4d604c014..b51b63090 100644 --- a/source/common/world/Dimension.hpp +++ b/source/common/world/Dimension.hpp @@ -35,6 +35,8 @@ #include +#include "DimensionPhysics.hpp" + class Dimension : public gk::ISerializable { public: Dimension() = default; @@ -55,8 +57,8 @@ class Dimension : public gk::ISerializable { const std::string &sky() const { return m_sky; } void setSky(const std::string &sky) { m_sky = sky; } - float gravity() const { return m_gravity; } - void setGravity(float gravity) { m_gravity = gravity; } + const DimensionPhysics physics() const { return m_physics; } + void setPhysics(const DimensionPhysics physics) { m_physics = physics; } static void initUsertype(sol::state &lua); @@ -70,7 +72,7 @@ class Dimension : public gk::ISerializable { std::string m_sky; - float m_gravity = 1.f; + DimensionPhysics m_physics; }; #endif // DIMENSION_HPP_ diff --git a/source/common/world/DimensionPhysics.cpp b/source/common/world/DimensionPhysics.cpp new file mode 100644 index 000000000..e0442476f --- /dev/null +++ b/source/common/world/DimensionPhysics.cpp @@ -0,0 +1,41 @@ +/* + * ===================================================================================== + * + * OpenMiner + * + * Copyright (C) 2018-2020 Unarelith, Quentin Bazin + * Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md) + * + * This file is part of OpenMiner. + * + * OpenMiner is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * OpenMiner is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with OpenMiner; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * ===================================================================================== + */ +#include "DimensionPhysics.hpp" +#include "NetworkUtils.hpp" + +void DimensionPhysics::serialize(sf::Packet &packet) const { + packet << gravity << jumpSpeed << jumpAntigravity << glideGravity << horizontalSprintMod << + verticalSprintMod << moveSpeed << airSpeedMod << flySpeed << sneakVerticalSpeed << + sneakHorizontalMod << isSneakAlwaysMod; +} + +void DimensionPhysics::deserialize(sf::Packet &packet) { + packet >> gravity >> jumpSpeed >> jumpAntigravity >> glideGravity >> horizontalSprintMod >> + verticalSprintMod >> moveSpeed >> airSpeedMod >> flySpeed >> sneakVerticalSpeed >> + sneakHorizontalMod >> isSneakAlwaysMod; +} + diff --git a/source/common/world/DimensionPhysics.hpp b/source/common/world/DimensionPhysics.hpp new file mode 100644 index 000000000..ae76a5eb6 --- /dev/null +++ b/source/common/world/DimensionPhysics.hpp @@ -0,0 +1,51 @@ +/* + * ===================================================================================== + * + * OpenMiner + * + * Copyright (C) 2018-2020 Unarelith, Quentin Bazin + * Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md) + * + * This file is part of OpenMiner. + * + * OpenMiner is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * OpenMiner is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with OpenMiner; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * ===================================================================================== + */ +#include + +struct DimensionPhysics : public gk::ISerializable { + void serialize(sf::Packet &packet) const override; + void deserialize(sf::Packet &packet) override; + + float gravity = 1.f; + float jumpSpeed = 0.05f; + + float jumpAntigravity = 0.3f; + float glideGravity = 0.04f; + + float horizontalSprintMod = 1.5f; + float verticalSprintMod = 1.5f; + + float moveSpeed = 0.04f; + float airSpeedMod = 0.75f; + + float flySpeed = 0.1f; + float sneakVerticalSpeed = 0.1f; + float sneakHorizontalMod = 0.75f; + + bool isSneakAlwaysMod = false; +}; + diff --git a/source/server/lua/loader/LuaDimensionLoader.cpp b/source/server/lua/loader/LuaDimensionLoader.cpp index 9412f6755..34a98fb30 100644 --- a/source/server/lua/loader/LuaDimensionLoader.cpp +++ b/source/server/lua/loader/LuaDimensionLoader.cpp @@ -38,8 +38,34 @@ void LuaDimensionLoader::loadDimension(const sol::table &table) const { if (biomesObject.valid() && biomesObject.get_type() == sol::type::table) { Dimension &dimension = Registry::getInstance().registerDimension(id, name); dimension.setSky(table["sky"].get()); - dimension.setGravity(table["gravity"].get_or(1.f)); + sol::object dimensionPhysicsObject = table["dimension_physics"]; + if (dimensionPhysicsObject.valid() && dimensionPhysicsObject.get_type() == sol::type::table) { + sol::table dimensionPhysicsTable = dimensionPhysicsObject.as(); + + DimensionPhysics dimensionPhysics = dimension.physics(); + + dimensionPhysics.gravity = table["gravity"].get_or(1.f); + dimensionPhysics.jumpSpeed = table["jump_speed"].get_or(0.3f); + + dimensionPhysics.jumpAntigravity = table["jump_antigravity"].get_or(0.04f); + dimensionPhysics.glideGravity = table["glide_gravity"].get_or(0.05f); + + dimensionPhysics.horizontalSprintMod = table["horizontal_sprint_mod"].get_or(1.5f); + dimensionPhysics.verticalSprintMod = table["vertical_sprint_mod"].get_or(1.5f); + + dimensionPhysics.moveSpeed = table["move_speed"].get_or(0.04f); + dimensionPhysics.airSpeedMod = table["air_speed_mod"].get_or(0.75f); + + dimensionPhysics.flySpeed = table["fly_speed"].get_or(0.1f); + dimensionPhysics.sneakVerticalSpeed = table["sneak_vertical_speed"].get_or(0.1f); + dimensionPhysics.sneakHorizontalMod = table["sneak_horizontal_mod"].get_or(0.1f); + + dimensionPhysics.isSneakAlwaysMod = table["is_sneak_always_mod"].get_or(false); + + dimension.setPhysics(dimensionPhysics); + } + sol::table biomesTable = biomesObject.as(); for (auto &it : biomesTable) { if (it.second.get_type() == sol::type::string)