TV System é um sistema que possibilita players assistirem outros jogadores pela tv em seu servidor, bom eu só irei deixar á parte dos códigos aqui vocês terão que desenvolver os scripts em lua para funcionar porém os códigos estão prontos e funcionais.
em luascript.cpp adicione:
Spoiler
//getCreatureNoMove(cid)
lua_register(m_luaState, "getCreatureNoMove", LuaScriptInterface::luaGetCreatureNoMove);
//doCreatureSetNoMove(cid, block)
lua_register(m_luaState, "doCreatureSetNoMove", LuaScriptInterface::luaDoCreatureSetNoMove);
//doInviteToPrivateChannel(cid, msg)
lua_register(m_luaState, "doInviteToPrivateChannel", LuaScriptInterface::luaDoInviteToPrivateChannel);
//doRemoveIntoPrivateChannel(cid, msg)
lua_register(m_luaState, "doRemoveIntoPrivateChannel", LuaScriptInterface::luaDoRemoveIntoPrivateChannel);
//doDeletePrivateChannel(cid)
lua_register(m_luaState, "doDeletePrivateChannel", LuaScriptInterface::luaDoDeletePrivateChannel);
//getCreatureHideHealth(cid)
lua_register(m_luaState, "getCreatureHideHealth", LuaScriptInterface::luaGetCreatureHideHealth);
//doCreatureSetHideHealth(cid, hide)
lua_register(m_luaState, "doCreatureSetHideHealth", LuaScriptInterface::luaDoCreatureSetHideHealth);
//doCreatePrivateChannel(cid)
lua_register(m_luaState, "doCreatePrivateChannel", LuaScriptInterface::luaDoCreatePrivateChannel);
ainda em luascript.cpp:
Spoiler
int32_t LuaScriptInterface::luaGetCreatureHideHealth(lua_State* L)
{
//getCreatureHideHealth(cid)
ScriptEnviroment* env = getEnv();
if(Creature* creature = env->getCreatureByUID(popNumber(L)))
lua_pushboolean(L, creature->getHideHealth());
else
{
errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoCreatureSetHideHealth(lua_State* L)
{
//doCreatureSetHideHealth(cid, hide)
bool hide = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Creature* creature = env->getCreatureByUID(popNumber(L)))
{
creature->setHideHealth(hide);
g_game.addCreatureHealth(creature);
lua_pushboolean(L, true);
}
else
{
errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoRemoveIntoPrivateChannel(lua_State* L)
{
//doRemoveIntoPrivateChannel(cid, string)
std::string name = popString(L);
uint32_t cid = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Player* player = env->getPlayerByUID(cid))
{
if(g_game.playerChannelExclude(player->getID(), name))
lua_pushboolean(L, true);
else
lua_pushboolean(L, false);
}
else
{
errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoDeletePrivateChannel(lua_State* L)
{
//doDeletePrivateChannel(cid)
uint32_t cid = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Player* player = env->getPlayerByUID(cid))
{
if(g_chat.deleteChannel(player, g_chat.getPrivateChannel(player)->getId()))
lua_pushboolean(L, true);
else
lua_pushboolean(L, false);
}
else
{
errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoInviteToPrivateChannel(lua_State* L)
{
//doCreatePrivateChannel(cid)
std::string name = popString(L);
uint32_t cid = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Player* player = env->getPlayerByUID(cid))
{
if(g_game.playerChannelInvite(player->getID(), name))
lua_pushboolean(L, true);
else
lua_pushboolean(L, false);
}
else
{
errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoCreatePrivateChannel(lua_State* L)
{
//doCreatePrivateChannel(cid)
//std::string loot = popString(L);
uint32_t cid = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Player* player = env->getPlayerByUID(cid))
{
if(g_game.playerCreatePrivateChannel(player->getID()))
lua_pushboolean(L, true);
else
lua_pushboolean(L, false);
}
else
{
errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaDoCreatureSetNoMove(lua_State* L)
{
//doCreatureSetNoMove(cid, block)
bool block = popNumber(L);
ScriptEnviroment* env = getEnv();
if(Creature* creature = env->getCreatureByUID(popNumber(L)))
{
creature->setNoMove(block);
lua_pushboolean(L, true);
}
else
{
errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
int32_t LuaScriptInterface::luaGetCreatureNoMove(lua_State* L)
{
//getCreatureNoMove(cid)
ScriptEnviroment* env = getEnv();
if(Creature* creature = env->getCreatureByUID(popNumber(L)))
lua_pushboolean(L, creature->getNoMove());
else
{
errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
lua_pushboolean(L, false);
}
return 1;
}
agora em luascript.h adicione:
Spoiler
static int32_t luaDoCreatePrivateChannel(lua_State* L);
static int32_t luaDoInviteToPrivateChannel(lua_State* L);
static int32_t luaDoRemoveIntoPrivateChannel(lua_State* L);
static int32_t luaDoDeletePrivateChannel(lua_State* L);
static int32_t luaGetCreatureNoMove(lua_State* L);
static int32_t luaDoCreatureSetNoMove(lua_State* L);
static int32_t luaGetCreatureHideHealth(lua_State* L);
static int32_t luaDoCreatureSetHideHealth(lua_State* L);
agora vai em chat.cpp e adicione:
Spoiler
ChatChannel* Chat::createChannel(Player* player, uint16_t channelId) // tv cam system
{
if(!player || player->isRemoved() || getChannel(player, channelId))
return NULL;
switch(channelId)
{
case CHANNEL_GUILD:
{
ChatChannel* newChannel = NULL;
if((newChannel = new ChatChannel(channelId, player->getGuildName(), ChatChannel::staticFlags)))
m_guildChannels[player->getGuildId()] = newChannel;
return newChannel;
}
case CHANNEL_PARTY:
{
ChatChannel* newChannel = NULL;
if(player->getParty() && (newChannel = new ChatChannel(channelId, partyName, ChatChannel::staticFlags)))
m_partyChannels[player->getParty()] = newChannel;
return newChannel;
}
case CHANNEL_PRIVATE:
{
//only 1 private channel for each premium player
if(!player->isPremium() || getPrivateChannel(player))
return NULL;
//find a free private channel slot
for(uint16_t i = 100; i < 10000; ++i)
{
if(m_privateChannels.find(i) != m_privateChannels.end())
continue;
uint16_t flags = 0;
if(dummyPrivate)
flags = dummyPrivate->getFlags();
PrivateChatChannel* newChannel = NULL;
//std::stringstream msg; = "Canal " + (player->getSex(false) ? "do " : "da ") + player->getName();
if((newChannel = new PrivateChatChannel(i, player->getName() + "'s channels", ChatChannel::staticFlags)))
{
newChannel->setOwner(player->getGUID());
m_privateChannels = newChannel;
}
return newChannel;
}
}
default:
break;
}
return NULL;
}
depois vá em chat.h e adicione:
Spoiler
class Player;
enum ChannelFlags_t
{
CHANNELFLAG_NONE = 0,
CHANNELFLAG_ENABLED = 1 << 0,
CHANNELFLAG_ACTIVE = 1 << 1,
CHANNELFLAG_LOGGED = 1 << 2,
};
typedef std::map<uint32_t, Player*> UsersMap;
typedef std::list<uint32_t> InviteList;
class ChatChannel
{
public:
ChatChannel(uint16_t id, const std::string& name, uint16_t flags, uint32_t access = 0,
uint32_t level = 1, Condition* condition = NULL, int32_t conditionId = -1,
const std::string& conditionMessage = "", VocationMap* vocationMap = NULL);
virtual ~ChatChannel()
{
if(m_condition)
delete m_condition;
if(m_vocationMap)
delete m_vocationMap;
}
static uint16_t staticFlags;
uint16_t getId() const {return m_id;}
const std::string& getName() const {return m_name;}
uint16_t getFlags() const {return m_flags;}
int32_t getConditionId() const {return m_conditionId;}
const std::string& getConditionMessage() const {return m_conditionMessage;}
const UsersMap& getUsers() {return m_users;}
uint32_t getLevel() const {return m_level;}
uint32_t getAccess() const {return m_access;}
virtual const uint32_t getOwner() {return 0;}
bool hasFlag(uint16_t value) const {return ((m_flags & (uint16_t)value) == (uint16_t)value);}
bool checkVocation(uint32_t vocationId) const
{return !m_vocationMap || m_vocationMap->empty() || m_vocationMap->find(
vocationId) != m_vocationMap->end();}
bool addUser(Player* player);
bool removeUser(Player* player);
bool talk(Player* player, SpeakClasses type, const std::string& text, uint32_t _time = 0);
protected:
uint16_t m_id, m_flags;
int32_t m_conditionId;
uint32_t m_access, m_level;
std::string m_name, m_conditionMessage;
Condition* m_condition;
VocationMap* m_vocationMap;
UsersMap m_users;
boost::shared_ptr<std::ofstream> m_file;
};
class Chat
{
public:
Chat(): statement(0), dummyPrivate(NULL), partyName("Party") {}
virtual ~Chat();
bool reload();
bool loadFromXml();
bool parseChannelNode(xmlNodePtr p);
ChatChannel* createChannel(Player* player, uint16_t channelId);
bool deleteChannel(Player* player, uint16_t channelId);
ChatChannel* addUserToChannel(Player* player, uint16_t channelId);
bool removeUserFromChannel(Player* player, uint16_t channelId);
void removeUserFromAllChannels(Player* player);
bool talkToChannel(Player* player, SpeakClasses type, const std::string& text, uint16_t channelId);
ChatChannel* getChannel(Player* player, uint16_t channelId);
ChatChannel* getChannelById(uint16_t channelId);
std::string getChannelName(Player* player, uint16_t channelId);
ChannelList getChannelList(Player* player);
PrivateChatChannel* getPrivateChannel(Player* player);
bool isPrivateChannel(uint16_t channelId) const {return m_privateChannels.find(channelId) != m_privateChannels.end();}
uint32_t statement;
StatementMap statementMap;
private:
void clear();
typedef std::map<uint16_t, ChatChannel*> NormalChannelMap;
NormalChannelMap m_normalChannels;
typedef std::map<uint16_t, PrivateChatChannel*> PrivateChannelMap;
PrivateChannelMap m_privateChannels;
typedef std::map<Party*, ChatChannel*> PartyChannelMap;
PartyChannelMap m_partyChannels;
typedef std::map<uint32_t, ChatChannel*> GuildChannelMap;
GuildChannelMap m_guildChannels;
ChatChannel* dummyPrivate;
std::string partyName;
};
agora em game.cpp adicione:
Spoiler
bool Game::playerBroadcastMessage(Player* player, SpeakClasses type, const std::string& text)
{
if(!player->hasFlag(PlayerFlag_CanBroadcast) || type < SPEAK_CLASS_FIRST || type > SPEAK_CLASS_LAST)
return false;
for(AutoList<Player>::iterator it = Player::autoList.begin(); it != Player::autoList.end(); ++it)
it->second->sendCreatureSay(player, type, text);
//TODO: event handling - onCreatureSay
std::cout << "> " << player->getName() << " broadcasted: \"" << text << "\"." << std::endl;
return true;
}
bool Game::playerCreatePrivateChannel(uint32_t playerId)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved() || !player->isPremium())
return false;
ChatChannel* channel = g_chat.createChannel(player, 0xFFFF);
if(!channel || !channel->addUser(player))
return false;
player->sendCreatePrivateChannel(channel->getId(), channel->getName());
return true;
}
bool Game::playerChannelInvite(uint32_t playerId, const std::string& name)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
Player* invitePlayer = getPlayerByName(name);
if(!invitePlayer)
return false;
PrivateChatChannel* channel = g_chat.getPrivateChannel(player);
if(!channel)
return false;
channel->invitePlayer(player, invitePlayer);
channel->addInvited(invitePlayer);
ChatChannel* teste = (ChatChannel*) channel; teste->addUser(invitePlayer);
invitePlayer->sendChannel(channel->getId(), channel->getName());
return true;
}
bool Game::playerChannelExclude(uint32_t playerId, const std::string& name)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
PrivateChatChannel* channel = g_chat.getPrivateChannel(player);
if(!channel)
return false;
Player* excludePlayer = getPlayerByName(name);
if(!excludePlayer)
return false;
if (player->getID() == excludePlayer->getID()){
g_chat.deleteChannel(player, g_chat.getPrivateChannel(player)->getId());
return true;
}
channel->excludePlayer(player, excludePlayer);
return true;
}
bool Game::playerRequestChannels(uint32_t playerId)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
player->sendChannelsDialog();
return true;
}
bool Game::playerOpenChannel(uint32_t playerId, uint16_t channelId)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
ChatChannel* channel = g_chat.addUserToChannel(player, channelId);
if(!channel)
{
#ifdef __DEBUG_CHAT__
std::cout << "Game::playerOpenChannel - failed adding user to channel." << std::endl;
#endif
return false;
}
if(channel->getId() != CHANNEL_RVR)
player->sendChannel(channel->getId(), channel->getName());
else
player->sendRuleViolationsChannel(channel->getId());
return true;
}
bool Game::playerCloseChannel(uint32_t playerId, uint16_t channelId)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
g_chat.removeUserFromChannel(player, channelId);
return true;
}
bool Game::playerOpenPrivateChannel(uint32_t playerId, std::string& receiver)
{
Player* player = getPlayerByID(playerId);
if(!player || player->isRemoved())
return false;
if(IOLoginData::getInstance()->playerExists(receiver))
player->sendOpenPrivateChannel(receiver);
else
player->sendCancel("A player with this name does not exist.");
return true;
}
Créditos
Eu (Por postar aqui no EKZ)
Lordbaxx
Smix
