feat: features OTCR natively in canary

config.lua.dist

@@ -588,3 +588,13 @@ metricsPrometheusAddress = "0.0.0.0:9464"
 --- OStream
 metricsEnableOstream = false
 metricsOstreamInterval = 1000
+
+--- OTC
+OTCRFeatures = { -- possible*
+    ["enable"] = { 
+        102, -- g_game.enableFeature(GameCreatureAttachedEffect)
+        103  -- g_game.enableFeature(GameCreatureShader)
+    },
+    ["disable"] = { -- utility ,for example in 13.10 g_game.disableFeature(GameSequencedPackets)
+    }
+}

src/creatures/creature.cpp

@@ -2002,3 +2002,20 @@ void Creature::sendAsyncTasks() {
 	},
 	                          TaskGroup::WalkParallel);
 }
+
+void Creature::attachEffectById(uint16_t id) {
+	auto it = std::find(attachedEffectList.begin(), attachedEffectList.end(), 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::find(attachedEffectList.begin(), attachedEffectList.end(), 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 &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,53 @@ 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()) {
+		if (client) {
+			client->sendAttachedEffect(creature, effectId);
+		}
+	}
+}
+
+void Player::sendDetachEffect(const std::shared_ptr<Creature> &creature, uint16_t effectId) const {
+	if (!client || !creature) {
+		return;
+	}
+	if (creature->getPlayer()) {
+		if (client) {
+			client->sendDetachEffect(creature, effectId);
+		}
+	}
+}
+
+void Player::sendShader(const std::shared_ptr<Creature> &creature, const std::string &shaderName) const {
+	if (!client || !creature) {
+		return;
+	}
+	if (creature->getPlayer()) {
+		if (client) {
+			client->sendShader(creature, shaderName);
+		}
+	}
+}
+
+void Player::sendMapShader(const std::string &shaderName) const {
+	if (client) {
+		client->sendMapShader(shaderName);
+	}
+}
+
+void Player::sendPlayerTyping(const std::shared_ptr<Creature> &creature, uint8_t typing) const {
+	if (client) {
+		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 &shaderName) const;
+	void sendMapShader(const std::string &shaderName) const;
+	const std::string &getMapShader() const {
+		return mapShader;
+	}
+	void setMapShader(const std::string &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 mapShader;
 
 	Skill skills[SKILL_LAST + 1];
 	LightInfo itemsLight;

src/game/game.cpp

@@ -10852,3 +10852,79 @@ 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) {
+		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) {
+		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) {
+		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 &shaderName) {
+		if (shaderName.empty()) {
+			removeCustomAttribute("shader");
+			return;
+		}
+
+		setCustomAttribute("shader", shaderName);
+	}
+
+	bool hasShader() const {
+		return getCustomAttribute("shader") != nullptr;
+	}
+
+	std::string getShader() const {
+		const CustomAttribute* shader = getCustomAttribute("shader");
+		return shader ? shader->getString() : "";
+	}
+
 protected:
 	std::unique_ptr<ItemAttribute> &initAttributePtr() {
 		if (!attributePtr) {

src/lua/functions/creatures/creature_functions.cpp

@@ -1107,3 +1107,62 @@ int CreatureFunctions::luaCreatureClearIcons(lua_State* L) {
 	pushBoolean(L, true);
 	return 1;
 }
+
+int CreatureFunctions::luaCreatureAttachEffectById(lua_State* L) {
+	// creature:attachEffectById(effectId, [temporary])
+	const auto &creature = getUserdataShared<Creature>(L, 1); 
+	if (!creature) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
+		pushBoolean(L, false);
+		return 1;
+	}
+	uint16_t id = getNumber<uint16_t>(L, 2);
+	bool temp = getBoolean(L, 3, false);
+	if (temp) {
+		g_game().sendAttachedEffect(creature, id);
+	} else {
+		creature->attachEffectById(id);
+	}
+	return 1;
+}
+
+int CreatureFunctions::luaCreatureDetachEffectById(lua_State* L) {
+	// creature:detachEffectById(effectId)
+	const auto &creature = getUserdataShared<Creature>(L, 1);
+	if (!creature) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
+		pushBoolean(L, false);
+		return 1;
+	}
+	uint16_t id = getNumber<uint16_t>(L, 2);
+	creature->detachEffectById(id);
+	return 1;
+}
+
+int CreatureFunctions::luaCreatureGetShader(lua_State* L) {
+	// creature:getShader()
+	const auto &creature = getUserdataShared<Creature>(L, 1);
+	if (!creature) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
+		pushBoolean(L, false);
+		return 1;
+	}
+
+	pushString(L, creature->getShader());
+
+	return 1;
+}
+
+int CreatureFunctions::luaCreatureSetShader(lua_State* L) {
+	// creature:setShader(shaderName)
+	const auto &creature = getUserdataShared<Creature>(L, 1);
+	if (!creature) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
+		pushBoolean(L, false);
+		return 1;
+	}
+	creature->setShader(getString(L, 2));
+	g_game().updateCreatureShader(creature);
+	pushBoolean(L, true);
+	return 1;
+}

src/lua/functions/creatures/creature_functions.hpp

@@ -93,6 +93,10 @@ class CreatureFunctions final : LuaScriptInterface {
 		registerMethod(L, "Creature", "getIcons", CreatureFunctions::luaCreatureGetIcons);
 		registerMethod(L, "Creature", "removeIcon", CreatureFunctions::luaCreatureRemoveIcon);
 		registerMethod(L, "Creature", "clearIcons", CreatureFunctions::luaCreatureClearIcons);
+		registerMethod(L, "Creature", "attachEffectById", CreatureFunctions::luaCreatureAttachEffectById);
+		registerMethod(L, "Creature", "detachEffectById", CreatureFunctions::luaCreatureDetachEffectById);
+		registerMethod(L, "Creature", "getShader", CreatureFunctions::luaCreatureGetShader);
+		registerMethod(L, "Creature", "setShader", CreatureFunctions::luaCreatureSetShader);
 
 		CombatFunctions::init(L);
 		MonsterFunctions::init(L);
@@ -196,4 +200,8 @@ class CreatureFunctions final : LuaScriptInterface {
 	static int luaCreatureGetIcon(lua_State* L);
 	static int luaCreatureRemoveIcon(lua_State* L);
 	static int luaCreatureClearIcons(lua_State* L);
+	static int luaCreatureAttachEffectById(lua_State* L);
+	static int luaCreatureDetachEffectById(lua_State* L);
+	static int luaCreatureGetShader(lua_State* L);
+	static int luaCreatureSetShader(lua_State* L);
 };

src/lua/functions/creatures/player/player_functions.cpp

@@ -4462,3 +4462,31 @@ int PlayerFunctions::luaPlayerSendCreatureAppear(lua_State* L) {
 	pushBoolean(L, true);
 	return 1;
 }
+
+int PlayerFunctions::luaPlayerGetMapShader(lua_State* L) {
+	// player:getMapShader()
+	const auto &player = getUserdataShared<Player>(L, 1);
+	if (!player) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
+		pushBoolean(L, false);
+		return 0;
+	}
+
+	pushString(L, player->getMapShader());
+	return 1;
+}
+
+
+int PlayerFunctions::luaPlayerSetMapShader(lua_State* L) {
+	// player:setMapShader(shaderName, [temporary])
+	const auto &player = getUserdataShared<Player>(L, 1);
+	if (!player) {
+		reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
+		pushBoolean(L, false);
+		return 0;
+	}
+	const auto shaderName = getString(L, 2);
+	player->sendMapShader(shaderName);
+	pushBoolean(L, true);
+	return 1;
+}

src/lua/functions/creatures/player/player_functions.hpp

@@ -388,6 +388,10 @@ class PlayerFunctions final : LuaScriptInterface {
 		registerMethod(L, "Player", "removeIconBakragore", PlayerFunctions::luaPlayerRemoveIconBakragore);
 		registerMethod(L, "Player", "sendCreatureAppear", PlayerFunctions::luaPlayerSendCreatureAppear);
 
+		// OTCR Features
+		registerMethod(L, "Player", "getMapShader", PlayerFunctions::luaPlayerGetMapShader);
+		registerMethod(L, "Player", "setMapShader", PlayerFunctions::luaPlayerSetMapShader);
+
 		GroupFunctions::init(L);
 		GuildFunctions::init(L);
 		MountFunctions::init(L);
@@ -755,6 +759,9 @@ class PlayerFunctions final : LuaScriptInterface {
 	static int luaPlayerRemoveIconBakragore(lua_State* L);
 
 	static int luaPlayerSendCreatureAppear(lua_State* L);
+
+	static int luaPlayerGetMapShader(lua_State* L);
+	static int luaPlayerSetMapShader(lua_State* L);
 
 	friend class CreatureFunctions;
 };