Bom, todos acham 255 efeitos muito pouco, né? Então tá aí, pra quem quiser aumentar esse limite pra 65,535.
Mas como nem tudo é perfeito, pra fazer isso você precisará estar usando OTClient e também ter as sources do seu servidor.

PS: Só testei em 8.54

Vamos ás edições do servidor:

No protocolgame.cpp:

void ProtocolGame::sendMagicEffect(const Position& pos, uint8_t type)

void ProtocolGame::sendMagicEffect(const Position& pos, uint16_t type)

void ProtocolGame::AddMagicEffect(NetworkMessage_ptr msg,const Position& pos, uint8_t type)
{
msg->AddByte(0x83);
msg->AddPosition(pos);
msg->AddByte(type + 1);
}

void ProtocolGame::AddMagicEffect(NetworkMessage_ptr msg,const Position& pos, uint16_t type)
{
msg->AddByte(0x83);
msg->AddPosition(pos);
msg->AddU16(type + 1);
}

No protocolgame.h:

void ProtocolGame::AddMagicEffect(NetworkMessage_ptr msg,const Position& pos, uint8_t type);

void ProtocolGame::AddMagicEffect(NetworkMessage_ptr msg,const Position& pos, uint16_t type);

void ProtocolGame::sendMagicEffect(const Position& pos, uint8_t type);

void ProtocolGame::sendMagicEffect(const Position& pos, uint16_t type);

No game.cpp:

void Game::addMagicEffect(const Position& pos, uint8_t effect, bool ghostMode /* = false */)

void Game::addMagicEffect(const Position& pos, uint16_t effect, bool ghostMode /* = false */)

void Game::addMagicEffect(const SpectatorVec& list, const Position& pos, uint8_t effect, bool ghostMode/* = false*/)

void Game::addMagicEffect(const SpectatorVec& list, const Position& pos, uint16_t effect, bool ghostMode/* = false*/)

No game.h:

void Game::addMagicEffect(const Position& pos, uint8_t effect, bool ghostMode /* = false */);

void Game::addMagicEffect(const Position& pos, uint16_t effect, bool ghostMode /* = false */);

void addMagicEffect(const SpectatorVec& list, const Position& pos, uint8_t effect, bool ghostMode = false);

void addMagicEffect(const SpectatorVec& list, const Position& pos, uint16_t effect, bool ghostMode = false);

No player.h:

void sendMagicEffect(const Position& pos, uint8_t type) const

void sendMagicEffect(const Position& pos, uint16_t type) const

Bom, agora falta editar no const.h:

MAGIC_EFFECT_INSECTS4dz = 0x13B, //220

MAGIC_EFFECT_INSECTS4ea = 0xDD, //221

MAGIC_EFFECT_LAST = MAGIC_EFFECT_INSECTS4ea,

Está quase pronto, agora, falta fazer o client aceitar esses dados, pra isso, em otclient/modules/game_things/things.lua, em baixo de:

local version = g_game.getClientVersion()

Adicine:

g_game.enableFeature(GameMagicEffectU16)

Pronto, se fizer tudo corretamente, funcionará \o


Bom, Lordbaxx disponibilizou a sua source(de poketibia) com o limite estendido:

Créditos:
Featzen(100%)

////////////////////////////////////////////////////////////////////////// OpenTibia - an opensource roleplaying game////////////////////////////////////////////////////////////////////////// This program is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.//// This program 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 General Public License for more details.//// You should have received a copy of the GNU General Public License// along with this program.  If not, see <http://www.gnu.org/licenses/>.//////////////////////////////////////////////////////////////////////// #ifndef __PROTOCOLGAME__#define __PROTOCOLGAME__ #include "otsystem.h"#include "enums.h" #include "protocol.h"#include "creature.h" class NetworkMessage;class Player;class Game;class House;class Container;class Tile;class Connection;class Quest; typedef boost::shared_ptr<NetworkMessage> NetworkMessage_ptr;class ProtocolGame : public Protocol{public:#ifdef __ENABLE_SERVER_DIAGNOSTIC__static uint32_t protocolGameCount;#endifProtocolGame(Connection_ptr connection): Protocol(connection){#ifdef __ENABLE_SERVER_DIAGNOSTIC__protocolGameCount++;#endifplayer = NULL;m_eventConnect = 0;m_debugAssertSent = m_acceptPackets = false;} virtual ~ProtocolGame(){#ifdef __ENABLE_SERVER_DIAGNOSTIC__protocolGameCount--;#endifplayer = NULL;} enum {protocolId = 0x0A};enum {isSingleSocket = true};enum {hasChecksum = true};static const char* protocolName() {return "game protocol";} bool login(const std::string& name, uint32_t id, const std::string& password,OperatingSystem_t operatingSystem, uint16_t version, bool gamemaster);bool logout(bool displayEffect, bool forceLogout); void setPlayer(Player* p); private:void disconnectClient(uint8_t error, const char* message); std::list<uint32_t> knownCreatureList;void checkCreatureAsKnown(uint32_t id, bool& known, uint32_t& removedKnown); bool connect(uint32_t playerId, OperatingSystem_t operatingSystem, uint16_t version);void disconnect(); virtual void releaseProtocol();virtual void deleteProtocolTask(); bool canSee(uint16_t x, uint16_t y, uint16_t z) const;bool canSee(const Creature*) const;bool canSee(const Position& pos) const; virtual void onConnect();virtual void onRecvFirstMessage(NetworkMessage& msg); bool parseFirstPacket(NetworkMessage& msg);virtual void parsePacket(NetworkMessage& msg); //Parse methodsvoid parseLogout(NetworkMessage& msg);void parseCancelMove(NetworkMessage& msg); void parseReceivePing(NetworkMessage& msg);void parseAutoWalk(NetworkMessage& msg);void parseMove(NetworkMessage& msg, Direction dir);void parseTurn(NetworkMessage& msg, Direction dir); void parseRequestOutfit(NetworkMessage& msg);void parseSetOutfit(NetworkMessage& msg);void parseSay(NetworkMessage& msg);void parseLookAt(NetworkMessage& msg);void parseFightModes(NetworkMessage& msg);void parseAttack(NetworkMessage& msg);void parseFollow(NetworkMessage& msg); void parseBugReport(NetworkMessage& msg);void parseDebugAssert(NetworkMessage& msg); void parseThrow(NetworkMessage& msg);void parseUseItemEx(NetworkMessage& msg);void parseBattleWindow(NetworkMessage& msg);void parseUseItem(NetworkMessage& msg);void parseCloseContainer(NetworkMessage& msg);void parseUpArrowContainer(NetworkMessage& msg);void parseUpdateTile(NetworkMessage& msg);void parseUpdateContainer(NetworkMessage& msg);void parseTextWindow(NetworkMessage& msg);void parseHouseWindow(NetworkMessage& msg); void parseLookInShop(NetworkMessage& msg);void parsePlayerPurchase(NetworkMessage& msg);void parsePlayerSale(NetworkMessage& msg);void parseCloseShop(NetworkMessage& msg); void parseQuests(NetworkMessage& msg);void parseQuestInfo(NetworkMessage& msg); void parseInviteToParty(NetworkMessage& msg);void parseJoinParty(NetworkMessage& msg);void parseRevokePartyInvite(NetworkMessage& msg);void parsePassPartyLeadership(NetworkMessage& msg);void parseLeaveParty(NetworkMessage& msg);void parseSharePartyExperience(NetworkMessage& msg); //trade methodsvoid parseRequestTrade(NetworkMessage& msg);void parseLookInTrade(NetworkMessage& msg);void parseAcceptTrade(NetworkMessage& msg);void parseCloseTrade(); //VIP methodsvoid parseAddVip(NetworkMessage& msg);void parseRemoveVip(NetworkMessage& msg); void parseRotateItem(NetworkMessage& msg); //Channel tabsvoid parseCreatePrivateChannel(NetworkMessage& msg);void parseChannelInvite(NetworkMessage& msg);void parseChannelExclude(NetworkMessage& msg);void parseGetChannels(NetworkMessage& msg);void parseOpenChannel(NetworkMessage& msg);void parseOpenPriv(NetworkMessage& msg);void parseCloseChannel(NetworkMessage& msg);void parseCloseNpc(NetworkMessage& msg);void parseProcessRuleViolation(NetworkMessage& msg);void parseCloseRuleViolation(NetworkMessage& msg);void parseCancelRuleViolation(NetworkMessage& msg); //Send functionsvoid sendChannelMessage(std::string author, std::string text, SpeakClasses type, uint8_t channel);void sendClosePrivate(uint16_t channelId);void sendCreatePrivateChannel(uint16_t channelId, const std::string& channelName);void sendChannelsDialog();void sendChannel(uint16_t channelId, const std::string& channelName);void sendRuleViolationsChannel(uint16_t channelId);void sendOpenPrivateChannel(const std::string& receiver);void sendToChannel(const Creature* creature, SpeakClasses type, const std::string& text, uint16_t channelId, uint32_t time = 0);void sendRemoveReport(const std::string& name);void sendLockRuleViolation();void sendRuleViolationCancel(const std::string& name);void sendIcons(int32_t icons);void sendFYIBox(const std::string& message); void sendDistanceShoot(const Position& from, const Position& to, uint8_t type);void sendMagicEffect(const Position& pos, uint8_t type);void sendAnimatedText(const Position& pos, uint8_t color, std::string text);void sendCreatureHealth(const Creature* creature);void sendSkills();void sendPing();void sendCreatureTurn(const Creature* creature, int16_t stackpos);void sendCreatureSay(const Creature* creature, SpeakClasses type, const std::string& text, Position* pos = NULL); void sendCancel(const std::string& message);void sendCancelWalk();void sendChangeSpeed(const Creature* creature, uint32_t speed);void sendCancelTarget();void sendCreatureOutfit(const Creature* creature, const Outfit_t& outfit);void sendStats();void sendTextMessage(MessageClasses mclass, const std::string& message);void sendReLoginWindow(); void sendTutorial(uint8_t tutorialId);void sendAddMarker(const Position& pos, MapMarks_t markType, const std::string& desc); void sendCreatureSkull(const Creature* creature);void sendCreatureShield(const Creature* creature); void sendShop(const ShopInfoList& shop);void sendCloseShop();void sendGoods(const ShopInfoList& shop);void sendTradeItemRequest(const Player* player, const Item* item, bool ack);void sendCloseTrade(); void sendTextWindow(uint32_t windowTextId, Item* item, uint16_t maxLen, bool canWrite);void sendTextWindow(uint32_t windowTextId, uint32_t itemId, const std::string& text);void sendHouseWindow(uint32_t windowTextId, House* house, uint32_t listId, const std::string& text); void sendOutfitWindow();void sendQuests();void sendQuestInfo(Quest* quest); void sendVIPLogIn(uint32_t guid);void sendVIPLogOut(uint32_t guid);void sendVIP(uint32_t guid, const std::string& name, bool isOnline); void sendCreatureLight(const Creature* creature);void sendWorldLight(const LightInfo& lightInfo); void sendCreatureSquare(const Creature* creature, SquareColor_t color); //tilesvoid sendAddTileItem(const Tile* tile, const Position& pos, uint32_t stackpos, const Item* item);void sendUpdateTileItem(const Tile* tile, const Position& pos, uint32_t stackpos, const Item* item);void sendRemoveTileItem(const Tile* tile, const Position& pos, uint32_t stackpos);void sendUpdateTile(const Tile* tile, const Position& pos); void sendAddCreature(const Creature* creature, const Position& pos, uint32_t stackpos);void sendRemoveCreature(const Creature* creature, const Position& pos, uint32_t stackpos);void sendMoveCreature(const Creature* creature, const Tile* newTile, const Position& newPos, uint32_t newStackPos,const Tile* oldTile, const Position& oldPos, uint32_t oldStackpos, bool teleport); //containersvoid sendAddContainerItem(uint8_t cid, const Item* item);void sendUpdateContainerItem(uint8_t cid, uint8_t slot, const Item* item);void sendRemoveContainerItem(uint8_t cid, uint8_t slot); void sendContainer(uint32_t cid, const Container* container, bool hasParent);void sendCloseContainer(uint32_t cid); //inventoryvoid sendAddInventoryItem(slots_t slot, const Item* item);void sendUpdateInventoryItem(slots_t slot, const Item* item);void sendRemoveInventoryItem(slots_t slot); //Help functions // translate a tile to clientreadable formatvoid GetTileDescription(const Tile* tile, NetworkMessage_ptr msg); // translate a floor to clientreadable formatvoid GetFloorDescription(NetworkMessage_ptr msg, int32_t x, int32_t y, int32_t z,int32_t width, int32_t height, int32_t offset, int32_t& skip); // translate a map area to clientreadable formatvoid GetMapDescription(int32_t x, int32_t y, int32_t z,int32_t width, int32_t height, NetworkMessage_ptr msg); void AddMapDescription(NetworkMessage_ptr msg, const Position& pos);void AddTextMessage(NetworkMessage_ptr msg, MessageClasses mclass, const std::string& message);void AddAnimatedText(NetworkMessage_ptr msg, const Position& pos, uint8_t color, const std::string& text);void AddMagicEffect(NetworkMessage_ptr msg, const Position& pos, uint8_t type);void AddDistanceShoot(NetworkMessage_ptr msg, const Position& from, const Position& to, uint8_t type);void AddCreature(NetworkMessage_ptr msg, const Creature* creature, bool known, uint32_t remove);void AddPlayerStats(NetworkMessage_ptr msg);void AddCreatureSpeak(NetworkMessage_ptr msg, const Creature* creature, SpeakClasses type,std::string text, uint16_t channelId, uint32_t time = 0, Position* pos = NULL);void AddCreatureHealth(NetworkMessage_ptr msg, const Creature* creature);void AddCreatureOutfit(NetworkMessage_ptr msg, const Creature* creature, const Outfit_t& outfit, bool outfitWindow = false);void AddPlayerSkills(NetworkMessage_ptr msg);void AddWorldLight(NetworkMessage_ptr msg, const LightInfo& lightInfo);void AddCreatureLight(NetworkMessage_ptr msg, const Creature* creature); //tilesvoid AddTileItem(NetworkMessage_ptr msg, const Position& pos, uint32_t stackpos, const Item* item);void AddTileCreature(NetworkMessage_ptr msg, const Position& pos, uint32_t stackpos, const Creature* creature);void UpdateTileItem(NetworkMessage_ptr msg, const Position& pos, uint32_t stackpos, const Item* item);void RemoveTileItem(NetworkMessage_ptr msg, const Position& pos, uint32_t stackpos); void MoveUpCreature(NetworkMessage_ptr msg, const Creature* creature,const Position& newPos, const Position& oldPos, uint32_t oldStackpos);void MoveDownCreature(NetworkMessage_ptr msg, const Creature* creature,const Position& newPos, const Position& oldPos, uint32_t oldStackpos); //containervoid AddContainerItem(NetworkMessage_ptr msg, uint8_t cid, const Item* item);void UpdateContainerItem(NetworkMessage_ptr msg, uint8_t cid, uint8_t slot, const Item* item);void RemoveContainerItem(NetworkMessage_ptr msg, uint8_t cid, uint8_t slot); //inventoryvoid AddInventoryItem(NetworkMessage_ptr msg, slots_t slot, const Item* item);void UpdateInventoryItem(NetworkMessage_ptr msg, slots_t slot, const Item* item);void RemoveInventoryItem(NetworkMessage_ptr msg, slots_t slot); //rule violation windowvoid parseViolationWindow(NetworkMessage& msg); //shopvoid AddShopItem(NetworkMessage_ptr msg, const ShopInfo item);void parseExtendedOpcode(NetworkMessage& msg);        void sendExtendedOpcode(uint8_t opcode, const std::string& buffer); #define addGameTask(f, ...) addGameTaskInternal(0, boost::bind(f, &g_game, __VA_ARGS__))#define addGameTaskTimed(delay, f, ...) addGameTaskInternal(delay, boost::bind(f, &g_game, __VA_ARGS__))template<class FunctionType>void addGameTaskInternal(uint32_t delay, const FunctionType&); friend class Player;Player* player; uint32_t m_eventConnect;bool m_debugAssertSent, m_acceptPackets;};#endif 

Não achei isto:

void ProtocolGamesendMagicEffect(const Position& pos, uint8_t type);

nem isto:

void ProtocolGameAddMagicEffect(NetworkMessage_ptr msg,const Position& pos, uint8_t type);

Então procure sem o prefixo ProtocolGame

void sendMagicEffect(const Position& pos, uint8_t type);

Ou algo similiar.

Pronto no Protocolgame.h eu achei as duas tags sem o "::protocolgame" então eu removi eles e adicionei no server,

mas então eu não achei nada similar no game.h com oque vc pediu:

////////////////////////////////////////////////////////////////////////
// OpenTibia - an opensource roleplaying game
////////////////////////////////////////////////////////////////////////
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
////////////////////////////////////////////////////////////////////////
 
#ifndef __GAME__
#define __GAME__
#include "otsystem.h"
 
#include "enums.h"
#include "templates.h"
#include "scheduler.h"
 
#include "map.h"
#include "spawn.h"
 
#include "item.h"
#include "player.h"
#include "npc.h"
#include "monster.h"
 
class ServiceManager;
class Creature;
class Player;
class Monster;
class Npc;
class CombatInfo;
 
enum stackposType_t
{
STACKPOS_NORMAL,
STACKPOS_MOVE,
STACKPOS_LOOK,
STACKPOS_USE,
STACKPOS_USEITEM
};
 
enum WorldType_t
{
WORLD_TYPE_FIRST = 1,
WORLD_TYPE_NO_PVP = WORLD_TYPE_FIRST,
WORLD_TYPE_PVP = 2,
WORLD_TYPE_PVP_ENFORCED = 3,
WORLD_TYPE_LAST = WORLD_TYPE_PVP_ENFORCED
};
 
enum GameState_t
{
GAME_STATE_FIRST = 1,
GAME_STATE_STARTUP = GAME_STATE_FIRST,
GAME_STATE_INIT = 2,
GAME_STATE_NORMAL = 3,
GAME_STATE_MAINTAIN = 4,
GAME_STATE_CLOSED = 5,
GAME_STATE_CLOSING = 6,
GAME_STATE_SHUTDOWN = 7,
GAME_STATE_LAST = GAME_STATE_SHUTDOWN
};
 
enum LightState_t
{
LIGHT_STATE_DAY,
LIGHT_STATE_NIGHT,
LIGHT_STATE_SUNSET,
LIGHT_STATE_SUNRISE
};
 
enum ReloadInfo_t
{
RELOAD_FIRST = 1,
RELOAD_ACTIONS = RELOAD_FIRST,
RELOAD_CHAT = 2,
RELOAD_CONFIG = 3,
RELOAD_CREATUREEVENTS = 4,
RELOAD_GAMESERVERS = 5,
RELOAD_GLOBALEVENTS = 6,
RELOAD_GROUPS = 7,
RELOAD_HIGHSCORES = 8,
RELOAD_HOUSEPRICES = 9,
RELOAD_ITEMS = 10,
RELOAD_MONSTERS = 11,
RELOAD_MOVEEVENTS = 12,
RELOAD_NPCS = 13,
RELOAD_OUTFITS = 14,
RELOAD_QUESTS = 15,
RELOAD_RAIDS = 16,
RELOAD_SPELLS = 17,
RELOAD_STAGES = 18,
RELOAD_TALKACTIONS = 19,
RELOAD_VOCATIONS = 20,
RELOAD_WEAPONS = 21,
RELOAD_MODS = 22,
RELOAD_ALL = 23,
RELOAD_LAST = RELOAD_MODS
};
 
struct RuleViolation
{
RuleViolation(Player* _reporter, const std::string& _text, uint32_t _time):
reporter(_reporter), gamemaster(NULL), text(_text), time(_time), isOpen(true) {}
 
Player* reporter;
Player* gamemaster;
std::string text;
uint32_t time;
bool isOpen;
 
private:
RuleViolation(const RuleViolation&);
};
 
struct RefreshBlock_t
{
TileItemVector list;
uint64_t lastRefresh;
};
 
typedef std::map<uint32_t, shared_ptr<RuleViolation> > RuleViolationsMap;
typedef std::map<Tile*, RefreshBlock_t> RefreshTiles;
typedef std::vector< std::pair<std::string, uint32_t> > Highscore;
typedef std::list<Position> Trash;
typedef std::map<int32_t, float> StageList;
 
#define EVENT_LIGHTINTERVAL 10000
#define EVENT_DECAYINTERVAL 1000
#define EVENT_DECAYBUCKETS 16
#define STATE_DELAY 1000
 
/**
  * Main Game class.
  * This class is responsible to control everything that happens
  */
 
class Game
{
public:
Game();
virtual ~Game();
void start(ServiceManager* servicer);
 
Highscore getHighscore(uint16_t skill);
std::string getHighscoreString(uint16_t skill);
void checkHighscores();
bool reloadHighscores();
 
void prepareGlobalSave();
void globalSave();
 
/**
 * Load a map.
 * \param filename Mapfile to load
 * \returns int32_t 0 built-in spawns, 1 needs xml spawns, 2 needs sql spawns, -1 if got error
 */
int32_t loadMap(std::string filename);
 
/**
 * Get the map size - info purpose only
 * \param width width of the map
 * \param height height of the map
 */
void getMapDimensions(uint32_t& width, uint32_t& height)
{
width = map->mapWidth;
height = map->mapHeight;
return;
}
 
void setWorldType(WorldType_t type) {worldType = type;}
WorldType_t getWorldType() const {return worldType;}
 
Cylinder* internalGetCylinder(Player* player, const Position& pos);
Thing* internalGetThing(Player* player, const Position& pos, int32_t index,
uint32_t spriteId = 0, stackposType_t type = STACKPOS_NORMAL);
void internalGetPosition(Item* item, Position& pos, int16_t& stackpos);
 
std::string getTradeErrorDescription(ReturnValue ret, Item* item);
 
/**
 * Get a single tile of the map.
 * \returns A pointer to the tile
 */
Tile* getTile(int32_t x, int32_t y, int32_t z) {return map->getTile(x, y, z);}
Tile* getTile(const Position& pos) {return map->getTile(pos);}
 
/**
 * Set a single tile of the map, position is read from this tile
 */
void setTile(Tile* newTile) {if(map) return map->setTile(newTile->getPosition(), newTile);}
 
/**
 * Get a leaf of the map.
 * \returns A pointer to a leaf
 */
QTreeLeafNode* getLeaf(uint32_t x, uint32_t y) {return map->getLeaf(x, y);}
 
/**
 * Returns a creature based on the unique creature identifier
 * \param id is the unique creature id to get a creature pointer to
 * \returns A Creature pointer to the creature
 */
Creature* getCreatureByID(uint32_t id);
 
/**
 * Returns a player based on the unique creature identifier
 * \param id is the unique player id to get a player pointer to
 * \returns A Pointer to the player
 */
Player* getPlayerByID(uint32_t id);
 
/**
 * Returns a creature based on a string name identifier
 * \param s is the name identifier
 * \returns A Pointer to the creature
 */
Creature* getCreatureByName(std::string s);
 
/**
 * Returns a player based on a string name identifier
 * \param s is the name identifier
 * \returns A Pointer to the player
 */
Player* getPlayerByName(std::string s);
 
/**
 * Returns a player based on a string name identifier
 * this function returns a pointer even if the player is offline,
 * it is up to the caller of the function to delete the pointer - if the player is offline
 * use isOffline() to determine if the player was offline
 * \param s is the name identifier
 * \return A Pointer to the player
 */
Player* getPlayerByNameEx(const std::string& s);
 
/**
 * Returns a player based on a guid identifier
 * this function returns a pointer even if the player is offline,
 * it is up to the caller of the function to delete the pointer - if the player is offline
 * use isOffline() to determine if the player was offline
 * \param guid is the identifier
 * \return A Pointer to the player
 */
Player* getPlayerByGuid(uint32_t guid);
 
/**
 * Returns a player based on a guid identifier
 * this function returns a pointer even if the player is offline,
 * it is up to the caller of the function to delete the pointer - if the player is offline
 * use isOffline() to determine if the player was offline
 * \param guid is the identifier
 */
Player* getPlayerByGuidEx(uint32_t guid);
 
/**
 * Returns a player based on a string name identifier, with support for the "~" wildcard.
 * \param s is the name identifier, with or without wildcard
 * \param player will point to the found player (if any)
 * \return "RET_PLAYERWITHTHISNAMEISNOTONLINE" or "RET_NAMEISTOOAMBIGUOUS"
 */
ReturnValue getPlayerByNameWildcard(std::string s, Player*& player);
 
/**
 * Returns a player based on an account number identifier
 * \param acc is the account identifier
 * \returns A Pointer to the player
 */
Player* getPlayerByAccount(uint32_t acc);
 
/**
 * Returns all players based on their name
 * \param s is the player name
 * \return A vector of all players with the selected name
 */
PlayerVector getPlayersByName(std::string s);
 
/**
 * Returns all players based on their account number identifier
 * \param acc is the account identifier
 * \return A vector of all players with the selected account number
 */
PlayerVector getPlayersByAccount(uint32_t acc);
 
/**
 * Returns all players with a certain IP address
 * \param ip is the IP address of the clients, as an unsigned long
 * \param mask An IP mask, default 255.255.255.255
 * \return A vector of all players with the selected IP
 */
PlayerVector getPlayersByIP(uint32_t ip, uint32_t mask = 0xFFFFFFFF);
 
/**
 * Place Creature on the map without sending out events to the surrounding.
 * \param creature Creature to place on the map
 * \param pos The position to place the creature
 * \param forced If true, placing the creature will not fail because of obstacles (creatures/items)
 */
bool internalPlaceCreature(Creature* creature, const Position& pos, bool extendedPos = false, bool forced = false);
 
/**
 * Place Creature on the map.
 * \param creature Creature to place on the map
 * \param pos The position to place the creature
 * \param forced If true, placing the creature will not fail because of obstacles (creatures/items)
 */
bool placeCreature(Creature* creature, const Position& pos, bool extendedPos = false, bool forced = false);
ReturnValue placeSummon(Creature* creature, const std::string& name);
 
/**
 * Remove Creature from the map.
 * Removes the Creature the map
 * \param c Creature to remove
 */
bool removeCreature(Creature* creature, bool isLogout = true);
 
void addCreatureCheck(Creature* creature);
void removeCreatureCheck(Creature* creature);
 
uint32_t getPlayersOnline() {return (uint32_t)Player::autoList.size();}
uint32_t getMonstersOnline() {return (uint32_t)Monster::autoList.size();}
uint32_t getNpcsOnline() {return (uint32_t)Npc::autoList.size();}
uint32_t getCreaturesOnline() {return (uint32_t)autoList.size();}
 
uint32_t getPlayersRecord() {return playersRecord;}
void getWorldLightInfo(LightInfo& lightInfo);
 
void getSpectators(SpectatorVec& list, const Position& centerPos, bool checkforduplicate = false, bool multifloor = false,
int32_t minRangeX = 0, int32_t maxRangeX = 0,
int32_t minRangeY = 0, int32_t maxRangeY = 0)
{map->getSpectators(list, centerPos, checkforduplicate, multifloor, minRangeX, maxRangeX, minRangeY, maxRangeY);}
const SpectatorVec& getSpectators(const Position& centerPos) {return map->getSpectators(centerPos);}
void clearSpectatorCache() {if(map) map->clearSpectatorCache();}
 
ReturnValue internalMoveCreature(Creature* creature, Direction direction, uint32_t flags = 0);
ReturnValue internalMoveCreature(Creature* actor, Creature* creature, Cylinder* fromCylinder, Cylinder* toCylinder, uint32_t flags = 0);
 
ReturnValue internalMoveItem(Creature* actor, Cylinder* fromCylinder, Cylinder* toCylinder, int32_t index,
Item* item, uint32_t count, Item** _moveItem, uint32_t flags = 0);
 
ReturnValue internalAddItem(Creature* actor, Cylinder* toCylinder, Item* item, int32_t index = INDEX_WHEREEVER,
uint32_t flags = 0, bool test = false);
ReturnValue internalRemoveItem(Creature* actor, Item* item, int32_t count = -1,  bool test = false, uint32_t flags = 0);
 
ReturnValue internalPlayerAddItem(Creature* actor, Player* player, Item* item, bool dropOnMap = true);
 
/**
 * Find an item of a certain type
 * \param cylinder to search the item
 * \param itemId is the item to remove
 * \param subType is the extra type an item can have such as charges/fluidtype, default is -1
* meaning it's not used
 * \param depthSearch if true it will check child containers aswell
 * \returns A pointer to the item to an item and NULL if not found
 */
Item* findItemOfType(Cylinder* cylinder, uint16_t itemId,
bool depthSearch = true, int32_t subType = -1);
 
/**
 * Remove item(s) of a certain type
 * \param cylinder to remove the item(s) from
 * \param itemId is the item to remove
 * \param count is the amount to remove
 * \param subType is the extra type an item can have such as charges/fluidtype, default is -1
* meaning it's not used
 * \returns true if the removal was successful
 */
bool removeItemOfType(Cylinder* cylinder, uint16_t itemId, int32_t count, int32_t subType = -1);
 
/**
 * Get the amount of money in a a cylinder
 * \returns the amount of money found
 */
uint32_t getMoney(const Cylinder* cylinder);
 
/**
 * Remove/Add item(s) with a monetary value
 * \param cylinder to remove the money from
 * \param money is the amount to remove
 * \param flags optional flags to modifiy the default behaviour
 * \returns true if the removal was successful
 */
bool removeMoney(Cylinder* cylinder, int32_t money, uint32_t flags = 0);
 
/**
 * Add item(s) with monetary value
 * \param cylinder which will receive money
 * \param money the amount to give
 * \param flags optional flags to modify default behavior
 */
void addMoney(Cylinder* cylinder, int32_t money, uint32_t flags = 0);
 
/**
 * Transform one item to another type/count
 * \param item is the item to transform
 * \param newId is the new itemid
 * \param newCount is the new count value, use default value (-1) to not change it
 * \returns true if the tranformation was successful
 */
Item* transformItem(Item* item, uint16_t newId, int32_t newCount = -1);
 
/**
 * Teleports an object to another position
 * \param thing is the object to teleport
 * \param newPos is the new position
 * \param flags optional flags to modify default behavior
 * \returns true if the teleportation was successful
 */
ReturnValue internalTeleport(Thing* thing, const Position& newPos, bool pushMove, uint32_t flags = 0);
 
/**
* Turn a creature to a different direction.
* \param creature Creature to change the direction
* \param dir Direction to turn to
*/
bool internalCreatureTurn(Creature* creature, Direction dir);
 
/**
 * Creature wants to say something.
 * \param creature Creature pointer
 * \param type Type of message
 * \param text The text to say
 * \param ghostMode Is creature on ghost mode
 * \param spectators Send message only to creatures pointed in vector
 * \param pos Appear as sent from different position
 */
bool internalCreatureSay(Creature* creature, SpeakClasses type, const std::string& text,
bool ghostMode, SpectatorVec* spectators = NULL, Position* pos = NULL);
 
bool internalStartTrade(Player* player, Player* partner, Item* tradeItem);
bool internalCloseTrade(Player* player);
 
//Implementation of player invoked events
bool playerBroadcastMessage(Player* player, SpeakClasses type, const std::string& text);
bool playerReportBug(uint32_t playerId, std::string bug);
bool playerViolationWindow(uint32_t playerId, std::string name, uint8_t reason,
ViolationAction_t action, std::string comment, std::string statement,
uint32_t statementId, bool ipBanishment);
bool playerMoveThing(uint32_t playerId, const Position& fromPos, uint16_t spriteId,
int16_t fromStackpos, const Position& toPos, uint8_t count);
bool playerMoveCreature(uint32_t playerId, uint32_t movingCreatureId,
const Position& movingCreatureOrigPos, const Position& toPos);
bool playerMoveItem(uint32_t playerId, const Position& fromPos,
uint16_t spriteId, int16_t fromStackpos, const Position& toPos, uint8_t count);
bool playerMove(uint32_t playerId, Direction dir);
bool playerCreatePrivateChannel(uint32_t playerId);
bool playerChannelInvite(uint32_t playerId, const std::string& name);
bool playerChannelExclude(uint32_t playerId, const std::string& name);
bool playerRequestChannels(uint32_t playerId);
bool playerOpenChannel(uint32_t playerId, uint16_t channelId);
bool playerCloseChannel(uint32_t playerId, uint16_t channelId);
bool playerOpenPrivateChannel(uint32_t playerId, std::string& receiver);
bool playerCloseNpcChannel(uint32_t playerId);
bool playerProcessRuleViolation(uint32_t playerId, const std::string& name);
bool playerCloseRuleViolation(uint32_t playerId, const std::string& name);
bool playerCancelRuleViolation(uint32_t playerId);
bool playerReceivePing(uint32_t playerId);
bool playerAutoWalk(uint32_t playerId, std::list<Direction>& listDir);
bool playerStopAutoWalk(uint32_t playerId);
bool playerUseItemEx(uint32_t playerId, const Position& fromPos, int16_t fromStackpos,
uint16_t fromSpriteId, const Position& toPos, int16_t toStackpos, uint16_t toSpriteId, bool isHotkey);
bool playerUseItem(uint32_t playerId, const Position& pos, int16_t stackpos,
uint8_t index, uint16_t spriteId, bool isHotkey);
bool playerUseBattleWindow(uint32_t playerId, const Position& fromPos,
int16_t fromStackpos, uint32_t creatureId, uint16_t spriteId, bool isHotkey);
bool playerCloseContainer(uint32_t playerId, uint8_t cid);
bool playerMoveUpContainer(uint32_t playerId, uint8_t cid);
bool playerUpdateContainer(uint32_t playerId, uint8_t cid);
bool playerUpdateTile(uint32_t playerId, const Position& pos);
bool playerRotateItem(uint32_t playerId, const Position& pos, int16_t stackpos, const uint16_t spriteId);
bool playerWriteItem(uint32_t playerId, uint32_t windowTextId, const std::string& text);
bool playerUpdateHouseWindow(uint32_t playerId, uint8_t listId, uint32_t windowTextId, const std::string& text);
bool playerRequestTrade(uint32_t playerId, const Position& pos, int16_t stackpos,
uint32_t tradePlayerId, uint16_t spriteId);
bool playerAcceptTrade(uint32_t playerId);
bool playerLookInTrade(uint32_t playerId, bool lookAtCounterOffer, int index);
bool playerPurchaseItem(uint32_t playerId, uint16_t spriteId, uint8_t count, uint8_t amount,
bool ignoreCap = false, bool inBackpacks = false);
bool playerSellItem(uint32_t playerId, uint16_t spriteId, uint8_t count, uint8_t amount);
bool playerCloseShop(uint32_t playerId);
bool playerLookInShop(uint32_t playerId, uint16_t spriteId, uint8_t count);
bool playerCloseTrade(uint32_t playerId);
bool playerSetAttackedCreature(uint32_t playerId, uint32_t creatureId);
bool playerFollowCreature(uint32_t playerId, uint32_t creatureId);
bool playerCancelAttackAndFollow(uint32_t playerId);
bool playerSetFightModes(uint32_t playerId, fightMode_t fightMode, chaseMode_t chaseMode, secureMode_t secureMode);
bool playerLookAt(uint32_t playerId, const Position& pos, uint16_t spriteId, int16_t stackpos);
bool playerQuests(uint32_t playerId);
bool playerQuestInfo(uint32_t playerId, uint16_t questId);
bool playerRequestAddVip(uint32_t playerId, const std::string& name);
bool playerRequestRemoveVip(uint32_t playerId, uint32_t guid);
bool playerTurn(uint32_t playerId, Direction dir);
bool playerRequestOutfit(uint32_t playerId);
bool playerSay(uint32_t playerId, uint16_t channelId, SpeakClasses type,
const std::string& receiver, const std::string& text);
bool playerChangeOutfit(uint32_t playerId, Outfit_t outfit);
bool playerInviteToParty(uint32_t playerId, uint32_t invitedId);
bool playerJoinParty(uint32_t playerId, uint32_t leaderId);
bool playerRevokePartyInvitation(uint32_t playerId, uint32_t invitedId);
bool playerPassPartyLeadership(uint32_t playerId, uint32_t newLeaderId);
bool playerLeaveParty(uint32_t playerId);
bool playerSharePartyExperience(uint32_t playerId, bool activate, uint8_t unknown);
 
void kickPlayer(uint32_t playerId, bool displayEffect);
bool broadcastMessage(const std::string& text, MessageClasses type);
void showHotkeyUseMessage(Player* player, Item* item);
 
int32_t getMotdId();
void loadMotd();
void loadPlayersRecord();
void checkPlayersRecord(Player* player);
 
bool reloadInfo(ReloadInfo_t reload, uint32_t playerId = 0);
void cleanup();
void shutdown();
void freeThing(Thing* thing);
 
bool canThrowObjectTo(const Position& fromPos, const Position& toPos, bool checkLineOfSight = true,
int32_t rangex = Map::maxClientViewportX, int32_t rangey = Map::maxClientViewportY);
bool isSightClear(const Position& fromPos, const Position& toPos, bool sameFloor);
 
bool getPathTo(const Creature* creature, const Position& destPos,
std::list<Direction>& listDir, int32_t maxSearchDist /*= -1*/);
 
bool getPathToEx(const Creature* creature, const Position& targetPos, std::list<Direction>& dirList,
const FindPathParams& fpp);
 
bool getPathToEx(const Creature* creature, const Position& targetPos, std::list<Direction>& dirList,
uint32_t minTargetDist, uint32_t maxTargetDist, bool fullPathSearch = true,
bool clearSight = true, int32_t maxSearchDist = -1);
 
Position getClosestFreeTile(Creature* creature, Position pos, bool extended = false, bool ignoreHouse = true);
std::string getSearchString(const Position fromPos, const Position toPos, bool fromIsCreature = false, bool toIsCreature = false);
 
void changeLight(const Creature* creature);
void changeSpeed(Creature* creature, int32_t varSpeedDelta);
void internalCreatureChangeOutfit(Creature* creature, const Outfit_t& oufit, bool forced = false);
void internalCreatureChangeVisible(Creature* creature, Visible_t visible);
void updateCreatureSkull(Creature* creature);
void sendPublicSquare(Player* sender, SquareColor_t color);
 
GameState_t getGameState() const {return gameState;}
void setGameState(GameState_t newState);
 
void saveGameState(bool shallow);
void loadGameState();
 
void cleanMap(uint32_t& count);
void refreshMap(RefreshTiles::iterator* it = NULL, uint32_t limit = 0);
void proceduralRefresh(RefreshTiles::iterator* it = NULL);
 
void addTrash(Position pos) {trash.push_back(pos);}
void addRefreshTile(Tile* tile, RefreshBlock_t rb) {refreshTiles[tile] = rb;}
 
//Events
void checkCreatureWalk(uint32_t creatureId);
void updateCreatureWalk(uint32_t creatureId);
void checkCreatureAttack(uint32_t creatureId);
void checkCreatures();
void checkLight();
 
bool combatBlockHit(CombatType_t combatType, Creature* attacker, Creature* target,
int32_t& healthChange, bool checkDefense, bool checkArmor);
 
bool combatChangeHealth(CombatType_t combatType, Creature* attacker, Creature* target, int32_t healthChange,
MagicEffect_t hitEffect = MAGIC_EFFECT_UNKNOWN, TextColor_t hitColor = TEXTCOLOR_UNKNOWN, bool force = false);
bool combatChangeMana(Creature* attacker, Creature* target, int32_t manaChange);
 
//animation help functions
void addCreatureHealth(const Creature* target);
void addCreatureHealth(const SpectatorVec& list, const Creature* target);
void addAnimatedText(const Position& pos, uint8_t textColor, const std::string& text);
void addAnimatedText(const SpectatorVec& list, const Position& pos, uint8_t textColor, const std::string& text);
void addMagicEffect(const Position& pos, uint8_t effect, bool ghostMode = false);
void addMagicEffect(const SpectatorVec& list, const Position& pos, uint8_t effect, bool ghostMode = false);
void addDistanceEffect(const SpectatorVec& list, const Position& fromPos, const Position& toPos, uint8_t effect);
void addDistanceEffect(const Position& fromPos, const Position& toPos, uint8_t effect);
 
const RuleViolationsMap& getRuleViolations() const {return ruleViolations;}
bool cancelRuleViolation(Player* player);
bool closeRuleViolation(Player* player);
 
std::vector<std::string> blacklist;
bool fetchBlacklist();
 
bool loadExperienceStages();
double getExperienceStage(uint32_t level, double divider = 1.);
 
inline StageList::const_iterator getFirstStage() const {return stages.begin();}
inline StageList::const_iterator getLastStage() const {return stages.end();}
size_t getStagesCount() const {return stages.size();}
 
void setGlobalSaveMessage(int16_t key, bool value) {globalSaveMessage[key] = value;}
bool getGlobalSaveMessage(int16_t key) const {return globalSaveMessage[key];}
 
Map* getMap() {return map;}
const Map* getMap() const {return map;}
 
int32_t getLightHour() {return lightHour;}
void startDecay(Item* item);
void parsePlayerExtendedOpcode(uint32_t playerId, uint8_t opcode, const std::string& buffer);
 
protected:
bool playerWhisper(Player* player, const std::string& text);
bool playerYell(Player* player, const std::string& text);
bool playerSpeakTo(Player* player, SpeakClasses type, const std::string& receiver, const std::string& text);
bool playerTalkToChannel(Player* player, SpeakClasses type, const std::string& text, uint16_t channelId);
bool playerSpeakToNpc(Player* player, const std::string& text);
bool playerReportRuleViolation(Player* player, const std::string& text);
bool playerContinueReport(Player* player, const std::string& text);
 
struct GameEvent
{
int64_t tick;
int32_t type;
void* data;
};
 
std::vector<Thing*> releaseThings;
std::map<Item*, uint32_t> tradeItems;
AutoList<Creature> autoList;
RuleViolationsMap ruleViolations;
 
size_t checkCreatureLastIndex;
std::vector<Creature*> checkCreatureVectors[EVENT_CREATURECOUNT];
std::vector<Creature*> toAddCheckCreatureVector;
 
void checkDecay();
void internalDecayItem(Item* item);
 
typedef std::list<Item*> DecayList;
DecayList decayItems[EVENT_DECAYBUCKETS];
DecayList toDecayItems;
size_t lastBucket;
 
static const int32_t LIGHT_LEVEL_DAY = 250;
static const int32_t LIGHT_LEVEL_NIGHT = 40;
static const int32_t SUNSET = 1305;
static const int32_t SUNRISE = 430;
int32_t lightLevel, lightHour, lightHourDelta;
LightState_t lightState;
 
GameState_t gameState;
WorldType_t worldType;
 
ServiceManager* services;
Map* map;
 
std::string lastMotd;
int32_t lastMotdId;
uint32_t playersRecord;
uint32_t checkLightEvent, checkCreatureEvent, checkDecayEvent, saveEvent;
bool globalSaveMessage[2];
 
RefreshTiles refreshTiles;
Trash trash;
 
StageList stages;
uint32_t lastStageLevel;
 
Highscore highscoreStorage[9];
time_t lastHighscoreCheck;
};
#endif

Amigo pode arruma esse otclient que vc testou. Pq eu n tenho nenhum.

g_game.enableFeature(GameMagicEffectU16)

Featzen, muito obrigado por essa parte! Rep++

Zet0, use spoilers, por favor.

Em game.h, em baixo de //animation help functions.

Quando não achar algo do tipo, procure sem os prefixos, no caso, Game::

Avronex, fica parecendo que tu tem raiva de mim :\

UHAEHUAE

Amigo pode arruma esse otclient que vc testou. Pq eu n tenho nenhum.

Esse aqui serve:http://www.xtibia.com/forum/topic/233498-otcclient-067-para-74-ha-1071/

Zet0, use spoilers, por favor.

 

Em game.h, em baixo de //animation help functions.

 

Quando não achar algo do tipo, procure sem os prefixos, no caso, Game::

 

Avronex, fica parecendo que tu tem raiva de mim :\

UHAEHUAE

Esse aqui serve:http://www.xtibia.com/forum/topic/233498-otcclient-067-para-74-ha-1071/

Manow eu achei isto:

void addMagicEffect(const Position& pos, uint8_t effect, bool ghostMode = false);

ai modifiquei para isto:

void addMagicEffect(const Position& pos, uint16_t effect, bool ghostMode = false);

no que vc postou ali encima tem o "/* = false */" e o meu n tem, eu deixo do mesmo jeito que está agora ou modifico mais algo??

Manow eu achei isto:

 

void addMagicEffect(const Position& pos, uint8_t effect, bool ghostMode = false);

 

ai modifiquei para isto:

 

void addMagicEffect(const Position& pos, uint16_t effect, bool ghostMode = false);

 

no que vc postou ali encima tem o "/* = false */" e o meu n tem, eu deixo do mesmo jeito que está agora ou modifico mais algo??

Deixa do jeito que está agora, está certo.

Tenho raiva de vc nao Featzen! Estou é muito agradecido! kkk

Amigo isso Server pra distance effect tb.

Amigo isso Server pra distance effect tb.

Não me lembro se tem a opção no otclient, kk.

Aah cara featzen seu lindo kk tava procurando faz tempo isso vlw rep+

Aah cara featzen seu lindo kk tava procurando faz tempo isso vlw rep+

UAEHU

Nada

Igual ao método que utilizei nas minhas sources, parabéns pela vontade de disponibilizar rep+ rs'