]> git.lizzy.rs Git - minetest.git/blobdiff - src/client/clientenvironment.cpp
fix: drop old irrlicht <1.8 compat on Client::loadMedia
[minetest.git] / src / client / clientenvironment.cpp
index f831978a88e534b96871e54ff6c74c08a8f08419..1bdf5390d2fe7ac06be900837fe31ccfeb4aa3f3 100644 (file)
@@ -51,12 +51,8 @@ class CAOShaderConstantSetter : public IShaderConstantSetter
 
        ~CAOShaderConstantSetter() override = default;
 
-       void onSetConstants(video::IMaterialRendererServices *services,
-                       bool is_highlevel) override
+       void onSetConstants(video::IMaterialRendererServices *services) override
        {
-               if (!is_highlevel)
-                       return;
-
                // Ambient color
                video::SColorf emissive_color(m_emissive_color);
 
@@ -183,86 +179,72 @@ void ClientEnvironment::step(float dtime)
        if(dtime > 0.5)
                dtime = 0.5;
 
-       f32 dtime_downcount = dtime;
-
        /*
                Stuff that has a maximum time increment
        */
 
-       u32 loopcount = 0;
-       do
-       {
-               loopcount++;
-
-               f32 dtime_part;
-               if(dtime_downcount > dtime_max_increment)
-               {
-                       dtime_part = dtime_max_increment;
-                       dtime_downcount -= dtime_part;
-               }
-               else
-               {
-                       dtime_part = dtime_downcount;
-                       /*
-                               Setting this to 0 (no -=dtime_part) disables an infinite loop
-                               when dtime_part is so small that dtime_downcount -= dtime_part
-                               does nothing
-                       */
-                       dtime_downcount = 0;
-               }
-
+       u32 steps = ceil(dtime / dtime_max_increment);
+       f32 dtime_part = dtime / steps;
+       for (; steps > 0; --steps) {
                /*
-                       Handle local player
+                       Local player handling
                */
 
-               {
-                       // Control local player
-                       lplayer->applyControl(dtime_part, this);
-
-                       // Apply physics
-                       if (!free_move && !is_climbing) {
-                               // Gravity
-                               v3f speed = lplayer->getSpeed();
-                               if (!lplayer->in_liquid)
-                                       speed.Y -= lplayer->movement_gravity *
-                                               lplayer->physics_override_gravity * dtime_part * 2.0f;
-
-                               // Liquid floating / sinking
-                               if (lplayer->in_liquid && !lplayer->swimming_vertical &&
-                                               !lplayer->swimming_pitch)
-                                       speed.Y -= lplayer->movement_liquid_sink * dtime_part * 2.0f;
-
-                               // Liquid resistance
-                               if (lplayer->in_liquid_stable || lplayer->in_liquid) {
-                                       // How much the node's viscosity blocks movement, ranges
-                                       // between 0 and 1. Should match the scale at which viscosity
-                                       // increase affects other liquid attributes.
-                                       static const f32 viscosity_factor = 0.3f;
-
-                                       v3f d_wanted = -speed / lplayer->movement_liquid_fluidity;
-                                       f32 dl = d_wanted.getLength();
-                                       if (dl > lplayer->movement_liquid_fluidity_smooth)
-                                               dl = lplayer->movement_liquid_fluidity_smooth;
-
-                                       dl *= (lplayer->liquid_viscosity * viscosity_factor) +
-                                               (1 - viscosity_factor);
-                                       v3f d = d_wanted.normalize() * (dl * dtime_part * 100.0f);
-                                       speed += d;
-                               }
-
-                               lplayer->setSpeed(speed);
+               // Control local player
+               lplayer->applyControl(dtime_part, this);
+
+               // Apply physics
+               if (!free_move && !is_climbing) {
+                       // Gravity
+                       v3f speed = lplayer->getSpeed();
+                       if (!lplayer->in_liquid)
+                               speed.Y -= lplayer->movement_gravity *
+                                       lplayer->physics_override_gravity * dtime_part * 2.0f;
+
+                       // Liquid floating / sinking
+                       if (lplayer->in_liquid && !lplayer->swimming_vertical &&
+                                       !lplayer->swimming_pitch)
+                               speed.Y -= lplayer->movement_liquid_sink * dtime_part * 2.0f;
+
+                       // Liquid resistance
+                       if (lplayer->in_liquid_stable || lplayer->in_liquid) {
+                               // How much the node's viscosity blocks movement, ranges
+                               // between 0 and 1. Should match the scale at which viscosity
+                               // increase affects other liquid attributes.
+                               static const f32 viscosity_factor = 0.3f;
+
+                               v3f d_wanted = -speed / lplayer->movement_liquid_fluidity;
+                               f32 dl = d_wanted.getLength();
+                               if (dl > lplayer->movement_liquid_fluidity_smooth)
+                                       dl = lplayer->movement_liquid_fluidity_smooth;
+
+                               dl *= (lplayer->liquid_viscosity * viscosity_factor) +
+                                       (1 - viscosity_factor);
+                               v3f d = d_wanted.normalize() * (dl * dtime_part * 100.0f);
+                               speed += d;
                        }
 
-                       /*
-                               Move the lplayer.
-                               This also does collision detection.
-                       */
-                       lplayer->move(dtime_part, this, position_max_increment,
-                               &player_collisions);
+                       lplayer->setSpeed(speed);
                }
-       } while (dtime_downcount > 0.001);
 
-       bool player_immortal = lplayer->getCAO() && lplayer->getCAO()->isImmortal();
+               /*
+                       Move the lplayer.
+                       This also does collision detection.
+               */
+               lplayer->move(dtime_part, this, position_max_increment,
+                       &player_collisions);
+       }
+
+       bool player_immortal = false;
+       f32 player_fall_factor = 1.0f;
+       GenericCAO *playercao = lplayer->getCAO();
+       if (playercao) {
+               player_immortal = playercao->isImmortal();
+               int addp_p = itemgroup_get(playercao->getGroups(),
+                       "fall_damage_add_percent");
+               // convert armor group into an usable fall damage factor
+               player_fall_factor = 1.0f + (float)addp_p / 100.0f;
+       }
 
        for (const CollisionInfo &info : player_collisions) {
                v3f speed_diff = info.new_speed - info.old_speed;;
@@ -275,17 +257,20 @@ void ClientEnvironment::step(float dtime)
                speed_diff.Z = 0;
                f32 pre_factor = 1; // 1 hp per node/s
                f32 tolerance = BS*14; // 5 without damage
-               f32 post_factor = 1; // 1 hp per node/s
                if (info.type == COLLISION_NODE) {
                        const ContentFeatures &f = m_client->ndef()->
                                get(m_map->getNode(info.node_p));
-                       // Determine fall damage multiplier
-                       int addp = itemgroup_get(f.groups, "fall_damage_add_percent");
-                       pre_factor = 1.0f + (float)addp / 100.0f;
+                       // Determine fall damage modifier
+                       int addp_n = itemgroup_get(f.groups, "fall_damage_add_percent");
+                       // convert node group to an usable fall damage factor
+                       f32 node_fall_factor = 1.0f + (float)addp_n / 100.0f;
+                       // combine both player fall damage modifiers
+                       pre_factor = node_fall_factor * player_fall_factor;
                }
                float speed = pre_factor * speed_diff.getLength();
-               if (speed > tolerance && !player_immortal) {
-                       f32 damage_f = (speed - tolerance) / BS * post_factor;
+
+               if (speed > tolerance && !player_immortal && pre_factor > 0.0f) {
+                       f32 damage_f = (speed - tolerance) / BS;
                        u16 damage = (u16)MYMIN(damage_f + 0.5, U16_MAX);
                        if (damage != 0) {
                                damageLocalPlayer(damage, true);
@@ -361,13 +346,6 @@ GenericCAO* ClientEnvironment::getGenericCAO(u16 id)
        return NULL;
 }
 
-bool isFreeClientActiveObjectId(const u16 id,
-       ClientActiveObjectMap &objects)
-{
-       return id != 0 && objects.find(id) == objects.end();
-
-}
-
 u16 ClientEnvironment::addActiveObject(ClientActiveObject *object)
 {
        // Register object. If failed return zero id