Merge branch 'mehah:main' into main

modules/game_attachedeffects/effects.lua

@@ -5,7 +5,10 @@
         duration, loop, transform, hideOwner, size{width, height}
         offset{x, y, onTop}, dirOffset[dir]{x, y, onTop},
         light { color, intensity}, drawOrder(only for tiles),
-        bounce{minHeight, height, speed}
+        bounce{minHeight, height, speed},
+        pulse{minHeight, height, speed},
+        fade{start, end, speed}
+
         onAttach, onDetach
     }
 ]]
@@ -97,7 +100,9 @@ AttachedEffectManager.register(7, 'Pentagram Aura', '/images/game/effects/pentag
 
 AttachedEffectManager.register(8, 'Ki', '/images/game/effects/ki', ThingExternalTexture, {
     size = { 140, 110 },
-    offset = { 60, 75, true }
+    offset = { 60, 75, true },
+    pulse = { 0, 50, 3000 },
+    --fade = { 0, 100, 1000 },
 })
 
 AttachedEffectManager.register(9, 'Thunder', '/images/game/effects/thunder', ThingExternalTexture, {

modules/game_attachedeffects/lib.lua

@@ -41,6 +41,14 @@ local executeConfig = function(attachedEffect, config)
         attachedEffect:setBounce(config.bounce[1], config.bounce[2], config.bounce[3] or 1000)
     end
 
+    if config.pulse then
+        attachedEffect:setPulse(config.pulse[1], config.pulse[2], config.pulse[3] or 1000)
+    end
+
+    if config.fade then
+        attachedEffect:setFade(config.fade[1], config.fade[2], config.fade[3] or 1000)
+    end
+
     if config.duration ~= nil and config.duration > 0 then
         attachedEffect:setDuration(config.duration)
     end

modules/game_mainpanel/mainpanel.lua

@@ -163,7 +163,7 @@ function optionsController:onInit()
 end
 
 function toggleStore()
-    if g_game.getFeature(GamePurseSlot) then
+    if g_game.getClientVersion() >= 1332 then
         modules.game_store.toggle()
     else
         modules.game_shop.toggle() --game_shopv8

modules/game_quickloot/quickloot.lua

@@ -61,6 +61,9 @@ function quickLootController:onGameStart()
 end
 
 function quickLootController:onGameEnd()
+    if not g_game.getFeature(GameThingQuickLoot) then
+        return
+    end
     QuickLoot.save()
     QuickLoot.toggle()
     if quickLootController.ui:isVisible() then
@@ -177,7 +180,7 @@ function QuickLoot.Define()
         end)
 
         if not status then
-            return g_logger.error("Error while saving top bar settings. Data won't be saved. Details: " .. result)
+            return g_logger.warning("Error while saving QuickLoot settings. Data won't be saved. Details: " .. result)
         end
 
         if result:len() > 104857600 then

src/client/attachedeffect.cpp

@@ -48,7 +48,9 @@ AttachedEffectPtr AttachedEffect::clone()
 
     obj->m_frame = 0;
     obj->m_animationTimer.restart();
-    obj->m_bounceTimer.restart();
+    obj->m_bounce.timer.restart();
+    obj->m_pulse.timer.restart();
+    obj->m_fade.timer.restart();
 
     if (!obj->m_texturePath.empty()) {
         if (obj->m_texture = g_textures.getTexture(obj->m_texturePath, obj->m_smooth)) {
@@ -63,6 +65,12 @@ AttachedEffectPtr AttachedEffect::clone()
     return obj;
 }
 
+int getBounce(const AttachedEffect::Bounce bounce, const ticks_t ticks) {
+    const auto minHeight = bounce.minHeight * g_drawPool.getScaleFactor();
+    const auto height = bounce.height * g_drawPool.getScaleFactor();
+    return minHeight + (height - std::abs(height - static_cast<int>(ticks / (bounce.speed / 100.f)) % static_cast<int>(height * 2)));
+}
+
 void AttachedEffect::draw(const Point& dest, bool isOnTop, const LightViewPtr& lightView, const bool drawThing) {
     if (m_transform)
         return;
@@ -85,17 +93,24 @@ void AttachedEffect::draw(const Point& dest, bool isOnTop, const LightViewPtr& l
         if (m_shader) g_drawPool.setShaderProgram(m_shader, true);
         if (m_opacity < 100) g_drawPool.setOpacity(getOpacity(), true);
 
+        const auto scaleFactor = g_drawPool.getScaleFactor();
+
+        if (m_pulse.height > 0 && m_pulse.speed > 0) {
+            g_drawPool.setScaleFactor(scaleFactor + getBounce(m_pulse, m_pulse.timer.ticksElapsed()) / 100.f);
+        }
+
+        if (m_fade.height > 0 && m_fade.speed > 0) {
+            g_drawPool.setOpacity(std::clamp<float>(getBounce(m_fade, m_fade.timer.ticksElapsed()) / 100.f, 0, 1.f));
+        }
+
         auto point = dest - (dirControl.offset * g_drawPool.getScaleFactor());
         if (!m_toPoint.isNull()) {
             const float fraction = std::min<float>(m_animationTimer.ticksElapsed() / static_cast<float>(m_duration), 1.f);
             point += m_toPoint * fraction * g_drawPool.getScaleFactor();
         }
 
         if (m_bounce.height > 0 && m_bounce.speed > 0) {
-            const auto minHeight = m_bounce.minHeight * g_drawPool.getScaleFactor();
-            const auto height = m_bounce.height * g_drawPool.getScaleFactor();
-            const auto pixel = minHeight + (height - std::abs(height - static_cast<int>(m_bounceTimer.ticksElapsed() / (m_bounce.speed / 100.f)) % static_cast<int>(height * 2)));
-            point -= pixel;
+            point -= getBounce(m_bounce, m_bounce.timer.ticksElapsed());
         }
 
         if (lightView && m_light.intensity > 0)
@@ -111,6 +126,14 @@ void AttachedEffect::draw(const Point& dest, bool isOnTop, const LightViewPtr& l
         } else {
             getThingType()->draw(point, 0, m_direction, 0, 0, animation, Color::white, drawThing, lightView, { .order = getDrawOrder() });
         }
+
+        if (m_pulse.height > 0 && m_pulse.speed > 0) {
+            g_drawPool.setScaleFactor(scaleFactor);
+        }
+
+        if (m_fade.height > 0 && m_fade.speed > 0) {
+            g_drawPool.resetOpacity();
+        }
     }
 
     if (drawThing) {

src/client/attachedeffect.h

@@ -71,6 +71,9 @@ class AttachedEffect : public LuaObject
     void setDirection(const Otc::Direction dir) { m_direction = std::min<Otc::Direction>(dir, Otc::NorthWest); }
 
     void setBounce(uint8_t minHeight, uint8_t height, uint16_t speed) { m_bounce = { minHeight, height , speed }; }
+    void setPulse(uint8_t minHeight, uint8_t height, uint16_t speed) { m_pulse = { minHeight, height , speed }; }
+    void setFade(uint8_t start, uint8_t end, uint16_t speed) { m_fade = { start, end , speed }; }
+
     void setOnTop(bool onTop) { for (auto& control : m_offsetDirections) control.onTop = onTop; }
     void setOffset(int16_t x, int16_t y) { for (auto& control : m_offsetDirections) control.offset = { x, y }; }
     void setOnTopByDir(Otc::Direction direction, bool onTop) { m_offsetDirections[direction].onTop = onTop; }
@@ -91,6 +94,14 @@ class AttachedEffect : public LuaObject
 
     ThingType* getThingType() const;
 
+    struct Bounce
+    {
+        uint8_t minHeight{ 0 };
+        uint8_t height{ 0 };
+        uint16_t speed{ 0 };
+        Timer timer;
+    };
+
 private:
     int getCurrentAnimationPhase();
 
@@ -128,19 +139,15 @@ class AttachedEffect : public LuaObject
     Size m_size;
 
     Timer m_animationTimer;
-    Timer m_bounceTimer;
 
     Otc::Direction m_direction{ Otc::North };
 
     std::array<DirControl, Otc::Direction::NorthWest + 1> m_offsetDirections;
     std::string m_texturePath;
 
-    struct
-    {
-        uint8_t minHeight{ 0 };
-        uint8_t height{ 0 };
-        uint16_t speed{ 0 };
-    } m_bounce;
+    Bounce m_bounce;
+    Bounce m_pulse;
+    Bounce m_fade;
 
     PainterShaderProgramPtr m_shader;
     TexturePtr m_texture;

src/client/luafunctions.cpp

@@ -574,6 +574,7 @@ void Client::registerLuaFunctions()
     g_lua.bindClassMemberFunction<Creature>("isStaticSquareVisible", &Creature::isStaticSquareVisible);
     g_lua.bindClassMemberFunction<Creature>("getStaticSquareColor", &Creature::getStaticSquareColor);
     g_lua.bindClassMemberFunction<Creature>("setBounce", &Creature::setBounce);
+
     g_lua.bindClassMemberFunction<Creature>("setTyping", &Creature::setTyping);
     g_lua.bindClassMemberFunction<Creature>("getTyping", &Creature::getTyping);
     g_lua.bindClassMemberFunction<Creature>("sendTyping", &Creature::sendTyping);
@@ -760,6 +761,9 @@ void Client::registerLuaFunctions()
     g_lua.bindClassMemberFunction<AttachedEffect>("setDrawOrder", &AttachedEffect::setDrawOrder);
     g_lua.bindClassMemberFunction<AttachedEffect>("setLight", &AttachedEffect::setLight);
     g_lua.bindClassMemberFunction<AttachedEffect>("setBounce", &AttachedEffect::setBounce);
+    g_lua.bindClassMemberFunction<AttachedEffect>("setPulse", &AttachedEffect::setPulse);
+    g_lua.bindClassMemberFunction<AttachedEffect>("setFade", &AttachedEffect::setFade);
+
     g_lua.bindClassMemberFunction<AttachedEffect>("setDirection", &AttachedEffect::setDirection);
     g_lua.bindClassMemberFunction<AttachedEffect>("getDirection", &AttachedEffect::getDirection);
     g_lua.bindClassMemberFunction<AttachedEffect>("move", &AttachedEffect::move);

src/client/protocolgameparse.cpp

@@ -708,7 +708,7 @@ void ProtocolGame::parseWorldTime(const InputMessagePtr& msg)
 
 void ProtocolGame::parseStore(const InputMessagePtr& msg) const
 {
-    if (g_game.getClientVersion() <= 1332) {
+    if (g_game.getClientVersion() < 1332) {
         parseCoinBalance(msg);
     }
 
@@ -719,7 +719,7 @@ void ProtocolGame::parseStore(const InputMessagePtr& msg) const
         StoreCategory category;
         category.name = msg->getString();
 
-        if (g_game.getClientVersion() <= 1332) {
+        if (g_game.getClientVersion() < 1332) {
             msg->getString();
         }
 

src/framework/core/garbagecollection.cpp

@@ -59,32 +59,16 @@ void GarbageCollection::drawpoll() {
 void GarbageCollection::texture() {
     static constexpr uint32_t IDLE_TIME = 25 * 60 * 1000; // 25min
 
-    std::vector<std::string> textureRemove;
-    std::vector<AnimatedTexturePtr> animatedTextureRemove;
-
-    {
-        std::shared_lock l(g_textures.m_mutex);
-        for (const auto& [fileName, tex] : g_textures.m_textures) {
-            if (tex->m_lastTimeUsage.ticksElapsed() > IDLE_TIME) {
-                textureRemove.emplace_back(fileName);
-            }
-        }
-
-        for (const auto& tex : g_textures.m_animatedTextures) {
-            if (tex->m_lastTimeUsage.ticksElapsed() > IDLE_TIME) {
-                animatedTextureRemove.emplace_back(tex);
-            }
-        }
-    }
+    std::shared_lock l(g_textures.m_mutex);
 
-    if (!textureRemove.empty() || !animatedTextureRemove.empty()) {
-        std::unique_lock l(g_textures.m_mutex);
-        for (const auto& path : textureRemove)
-            g_textures.m_textures.erase(path);
+    std::erase_if(g_textures.m_textures, [](const auto& item) {
+        const auto& [key, tex] = item;
+        return tex.use_count() == 1 && tex->m_lastTimeUsage.ticksElapsed() > IDLE_TIME;
+    });
 
-        for (const auto& text : animatedTextureRemove)
-            std::erase(g_textures.m_animatedTextures, text);
-    }
+    std::erase_if(g_textures.m_animatedTextures, [](const TexturePtr& tex) {
+        return tex.use_count() == 1 && tex->m_lastTimeUsage.ticksElapsed() > IDLE_TIME;
+    });
 }
 
 void GarbageCollection::thingType() {
@@ -122,4 +106,4 @@ void GarbageCollection::thingType() {
                 thingType->unload();
         });
     }
-}
+}

src/framework/graphics/texturemanager.cpp

@@ -138,13 +138,15 @@ TexturePtr TextureManager::getTexture(const std::string& fileName, bool smooth)
         if (texture) {
             texture->setTime(stdext::time());
             texture->setSmooth(smooth);
-
             std::unique_lock l(m_mutex);
             m_textures[filePath] = texture;
         }
     }
 
-    texture->m_lastTimeUsage.restart();
+    if (texture) {
+        texture->m_lastTimeUsage.restart();
+    }
+
     return texture;
 }