feat: features OTCR natively in canary

config.lua.dist

@@ -588,3 +588,16 @@ metricsPrometheusAddress = "0.0.0.0:9464"
 --- OStream
 metricsEnableOstream = false
 metricsOstreamInterval = 1000
+
+-- OTC Features
+-- NOTE: Features added in this list will be forced to be used on the client
+-- These features can be found in "modules/gamelib/const.lua"
+OTCRFeatures = {
+    enable = { 
+        101, -- g_game.enableFeature(GameItemShader)
+        102, -- g_game.enableFeature(GameCreatureAttachedEffect)
+        103  -- g_game.enableFeature(GameCreatureShader)
+    },
+    disable = { -- utility: for example in 13.10 g_game.disableFeature(GameSequencedPackets)
+    }
+}

src/config/configmanager.cpp

@@ -363,6 +363,8 @@ bool ConfigManager::load() {
 	loadStringConfig(L, WORLD_TYPE, "worldType", "pvp");
 	loadStringConfig(L, LOGLEVEL, "logLevel", "info");
 
+	loadLuaOTCFeatures(L);
+
 	loaded = true;
 	lua_close(L);
 	return true;
@@ -464,3 +466,43 @@ float ConfigManager::getFloat(const ConfigKey_t &key, const std::source_location
 	g_logger().warn("[{}] accessing invalid or wrong type index: {}[{}]. Called line: {}:{}, in {}", __FUNCTION__, magic_enum::enum_name(key), fmt::underlying(key), location.line(), location.column(), location.function_name());
 	return 0.0f;
 }
+
+void ConfigManager::loadLuaOTCFeatures(lua_State* L) {
+	lua_getglobal(L, "OTCRFeatures");
+	if (!lua_istable(L, -1)) {
+		return;
+	}
+
+	lua_pushstring(L, "enable");
+	lua_gettable(L, -2);
+	if (lua_istable(L, -1)) {
+		lua_pushnil(L);
+		while (lua_next(L, -2) != 0) {
+			const auto feature = static_cast<uint8_t>(lua_tointeger(L, -1));
+			enabledOTCFeatures.push_back(feature);
+			lua_pop(L, 1);
+		}
+	}
+	lua_pop(L, 1);
+
+	lua_pushstring(L, "disable");
+	lua_gettable(L, -2);
+	if (lua_istable(L, -1)) {
+		lua_pushnil(L);
+		while (lua_next(L, -2) != 0) {
+			const auto feature = static_cast<uint8_t>(lua_tointeger(L, -1));
+			disabledOTCFeatures.push_back(feature);
+			lua_pop(L, 1);
+		}
+	}
+	lua_pop(L, 1);
+
+	lua_pop(L, 1);
+}
+OTCFeatures ConfigManager::getEnabledOTCFeatures() const {
+	return enabledOTCFeatures;
+}
+
+OTCFeatures ConfigManager::getDisabledOTCFeatures() const {
+	return disabledOTCFeatures;
+}

src/config/configmanager.hpp

@@ -12,6 +12,7 @@
 #include "config_enums.hpp"
 
 using ConfigValue = std::variant<std::string, int32_t, bool, float>;
+using OTCFeatures = std::vector<uint8_t>;
 
 class ConfigManager {
 public:
@@ -40,6 +41,8 @@ class ConfigManager {
 	[[nodiscard]] int32_t getNumber(const ConfigKey_t &key, const std::source_location &location = std::source_location::current()) const;
 	[[nodiscard]] bool getBoolean(const ConfigKey_t &key, const std::source_location &location = std::source_location::current()) const;
 	[[nodiscard]] float getFloat(const ConfigKey_t &key, const std::source_location &location = std::source_location::current()) const;
+	OTCFeatures getEnabledOTCFeatures() const;
+	OTCFeatures getDisabledOTCFeatures() const;
 
 private:
 	phmap::flat_hash_map<ConfigKey_t, ConfigValue> configs;
@@ -50,6 +53,9 @@ class ConfigManager {
 
 	std::string configFileLua = { "config.lua" };
 	bool loaded = false;
+	OTCFeatures enabledOTCFeatures = {};
+	OTCFeatures disabledOTCFeatures = {};
+	void loadLuaOTCFeatures(lua_State* L);
 };
 
 constexpr auto g_configManager = ConfigManager::getInstance;

src/creatures/creature.cpp

@@ -2002,3 +2002,20 @@ void Creature::sendAsyncTasks() {
 	},
 	                          TaskGroup::WalkParallel);
 }
+
+void Creature::attachEffectById(uint16_t id) {
+	auto it = std::ranges::find(attachedEffectList, id);
+	if (it != attachedEffectList.end()) {
+		return;
+	}
+	attachedEffectList.push_back(id);
+	g_game().sendAttachedEffect(static_self_cast<Creature>(), id);
+}
+void Creature::detachEffectById(uint16_t id) {
+	auto it = std::ranges::find(attachedEffectList, id);
+	if (it == attachedEffectList.end()) {
+		return;
+	}
+	attachedEffectList.erase(it);
+	g_game().sendDetachEffect(static_self_cast<Creature>(), id);
+}

src/creatures/creature.hpp

@@ -692,6 +692,17 @@ class Creature : virtual public Thing, public SharedObject {
 	void setCharmChanceModifier(int8_t value) {
 		charmChanceModifier = value;
 	}
+	std::string getShader() const {
+		return shader;
+	}
+	void setShader(const std::string_view &shaderName) {
+		shader = shaderName;
+	}
+	void attachEffectById(uint16_t id);
+	void detachEffectById(uint16_t id);
+	const std::vector<uint16_t> getAttachedEffectList() const {
+		return attachedEffectList;
+	}
 
 protected:
 	enum FlagAsyncClass_t : uint8_t {
@@ -881,4 +892,6 @@ class Creature : virtual public Thing, public SharedObject {
 	}
 
 	uint8_t m_flagAsyncTask = 0;
+	std::vector<uint16_t> attachedEffectList;
+	std::string shader;
 };

src/creatures/players/player.cpp

@@ -9572,6 +9572,52 @@ void Player::sendLootContainers() const {
 	}
 }
 
+// OTCR Features
+
+void Player::sendAttachedEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) const {
+	if (!client || !creature) {
+		return;
+	}
+
+	if (creature->getPlayer()) {
+		client->sendAttachedEffect(creature, effectId);
+	}
+}
+
+void Player::sendDetachEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) const {
+	if (!client || !creature) {
+		return;
+	}
+	if (creature->getPlayer()) {
+		client->sendDetachEffect(creature, effectId);
+	}
+}
+
+void Player::sendShader(const std::shared_ptr<Creature> &creature, const std::string_view &shaderName) const {
+	if (!client || !creature) {
+		return;
+	}
+	if (creature->getPlayer()) {
+			client->sendShader(creature, shaderName);
+	}
+}
+
+void Player::sendMapShader(const std::string_view &shaderName) const {
+	if (!client) {
+		return;
+	}
+
+	client->sendMapShader(shaderName);
+}
+
+void Player::sendPlayerTyping(const std::shared_ptr<Creature> &creature, uint8_t typing) const {
+	if (!client) {
+		return;
+	}
+
+	client->sendPlayerTyping(creature, typing);
+}
+
 void Player::sendSingleSoundEffect(const Position &pos, SoundEffect_t id, SourceEffect_t source) const {
 	if (client) {
 		client->sendSingleSoundEffect(pos, id, source);

src/creatures/players/player.hpp

@@ -1262,6 +1262,18 @@ class Player final : public Creature, public Cylinder, public Bankable {
 
 	uint16_t getPlayerVocationEnum() const;
 
+	void sendAttachedEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) const;
+	void sendDetachEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) const;
+	void sendShader(const std::shared_ptr<Creature> &creature, const std::string_view &shaderName) const;
+	void sendMapShader(const std::string_view &shaderName) const;
+	const std::string_view &getMapShader() const {
+		return mapShader;
+	}
+	void setMapShader(const std::string_view &shaderName) {
+		this->mapShader = shaderName;
+	}
+	void sendPlayerTyping(const std::shared_ptr<Creature> &creature, uint8_t typing) const;
+
 private:
 	friend class PlayerLock;
 	std::mutex mutex;
@@ -1371,6 +1383,7 @@ class Player final : public Creature, public Cylinder, public Bankable {
 	std::string name;
 	std::string guildNick;
 	std::string loyaltyTitle;
+	std::string_view mapShader;
 
 	Skill skills[SKILL_LAST + 1];
 	LightInfo itemsLight;

src/game/game.cpp

@@ -10852,3 +10852,80 @@ void Game::updatePlayersOnline() const {
 		g_logger().error("[Game::updatePlayersOnline] Failed to update players online.");
 	}
 }
+
+void Game::sendAttachedEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) {
+	auto spectators = Spectators().find<Player>(creature->getPosition(), true);
+	for (const auto &spectator : spectators) {
+		const auto &player = spectator->getPlayer();
+		if (player) {
+			player->sendAttachedEffect(creature, effectId);
+		}
+	}
+}
+
+void Game::sendDetachEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) {
+	auto spectators = Spectators().find<Player>(creature->getPosition(), true);
+	for (const auto &spectator : spectators) {
+		const auto &player = spectator->getPlayer();
+		if (player) { 
+			player->sendDetachEffect(creature, effectId);
+		}
+	}
+}
+
+void Game::updateCreatureShader(const std::shared_ptr<Creature> &creature) {
+	auto spectators = Spectators().find<Player>(creature->getPosition(), true);
+	for (const auto &spectator : spectators) {
+		const auto &player = spectator->getPlayer();
+		if (player) {
+			player->sendShader(creature, creature->getShader());
+		}
+	}
+}
+
+void Game::playerSetTyping(uint32_t playerId, uint8_t typing) {
+	const auto &player = getPlayerByID(playerId);
+	if (!player) {
+		return;
+	}
+	for (const auto &spectator : Spectators().find<Player>(player->getPosition(), true)) {
+		if (const auto &tmpPlayer = spectator->getPlayer()) {
+			tmpPlayer->sendPlayerTyping(player, typing);
+		}
+	}
+}
+
+void Game::refreshItem(const std::shared_ptr<Item> &item) {
+	if (!item || !item->getParent()) {
+		return;
+	}
+	const auto &parent = item->getParent();
+	if (const auto &creature = parent->getCreature()) {
+		if (const auto &player = creature->getPlayer()) {
+			int32_t index = player->getThingIndex(item);
+			if (index > -1) {
+				player->sendInventoryItem(static_cast<Slots_t>(index), item);
+			}
+		}
+		return;
+	}
+	if (const auto &container = parent->getContainer()) {
+		int32_t index = container->getThingIndex(item);
+		if (index > -1 && index <= std::numeric_limits<uint16_t>::max()) {
+			const auto spectators = Spectators().find<Player>(container->getPosition(), false, 2, 2, 2, 2);
+			// send to client
+			for (const auto &spectator : spectators) {
+				spectator->getPlayer()->sendUpdateContainerItem(container, static_cast<uint16_t>(index), item);
+			}
+		}
+		return;
+	}
+	if (const auto &tile = parent->getTile()) {
+		const auto spectators = Spectators().find<Player>(tile->getPosition(), true);
+		// send to client
+		for (const auto &spectator : spectators) {
+			spectator->getPlayer()->sendUpdateTileItem(tile, tile->getPosition(), item);
+		}
+		return;
+	}
+}

src/game/game.hpp

@@ -712,6 +712,11 @@ class Game {
 	const std::map<uint8_t, std::string> &getBlessingNames();
 	const std::unordered_map<uint16_t, std::string> &getHirelingSkills();
 	const std::unordered_map<uint16_t, std::string> &getHirelingOutfits();
+	void sendAttachedEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId);
+	void sendDetachEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId);
+	void updateCreatureShader(const std::shared_ptr<Creature> &creature);
+	void playerSetTyping(uint32_t playerId, uint8_t typing);
+	void refreshItem(const std::shared_ptr<Item> &item);
 
 private:
 	std::map<uint16_t, Achievement> m_achievements;

src/items/item.hpp

@@ -141,6 +141,24 @@ class ItemProperties {
 		return getCorpseOwner() == static_cast<uint32_t>(std::numeric_limits<int32_t>::max());
 	}
 
+	void setShader(const std::string_view &shaderName) {
+		if (shaderName.empty()) {
+			removeCustomAttribute("shader");
+			return;
+		}
+
+		setCustomAttribute("shader", std::string(shaderName)); // temp
+	}
+
+	bool hasShader() const {
+		return getCustomAttribute("shader") != nullptr;
+	}
+
+	std::string_view getShader() const {
+		const CustomAttribute* shader = getCustomAttribute("shader");
+		return shader ? shader->getString() : "";
+	}
+
 protected:
 	std::unique_ptr<ItemAttribute> &initAttributePtr() {
 		if (!attributePtr) {