mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-14 05:04:50 +00:00
3657 lines
110 KiB
C++
3657 lines
110 KiB
C++
|
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
||
|
// Copyright (C) 2010 Winch Gate Property Limited
|
||
|
//
|
||
|
// This program is free software: you can redistribute it and/or modify
|
||
|
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
||
|
//
|
||
|
// You should have received a copy of the GNU Affero General Public License
|
||
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
||
|
|
||
|
|
||
|
#include "stdpch.h"
|
||
|
|
||
|
//net
|
||
|
#include "nel/net/message.h"
|
||
|
#include "nel/misc/command.h"
|
||
|
#include "nel/misc/algo.h"
|
||
|
#include "nel/misc/common.h"
|
||
|
//game_share
|
||
|
#include "game_share/generic_xml_msg_mngr.h"
|
||
|
#include "game_share/sphrase_com.h"
|
||
|
#include "game_share/security_check.h"
|
||
|
#include "server_share/log_item_gen.h"
|
||
|
//egs
|
||
|
#include "client_messages.h"
|
||
|
#include "player_manager/player_manager.h"
|
||
|
#include "player_manager/player.h"
|
||
|
#include "player_manager/character.h"
|
||
|
#include "entity_manager/entity_callbacks.h"
|
||
|
#include "phrase_manager/phrase_manager_callbacks.h"
|
||
|
#include "zone_manager.h"
|
||
|
#include "phrase_manager/phrase_manager.h"
|
||
|
#include "mission_manager/mission_queue_manager.h"
|
||
|
#include "building_manager/building_manager.h"
|
||
|
#include "team_manager/team_manager.h"
|
||
|
#include "creature_manager/creature_manager.h"
|
||
|
#include "egs_sheets/egs_sheets.h"
|
||
|
#include "pvp_manager/pvp_manager.h"
|
||
|
#include "pvp_manager/pvp_manager_2.h"
|
||
|
#include "pvp_manager/pvp.h"
|
||
|
#include "building_manager/room_instance.h"
|
||
|
#include "player_manager/gear_latency.h"
|
||
|
#include "outpost_manager/outpost_manager.h"
|
||
|
#include "pvp_manager/pvp_faction_reward_manager/pvp_faction_reward_manager.h"
|
||
|
#include "guild_manager/guild_member.h"
|
||
|
#include "guild_manager/guild.h"
|
||
|
#include "guild_manager/guild_manager.h"
|
||
|
#include "modules/r2_mission_item.h"
|
||
|
#include "modules/r2_give_item.h"
|
||
|
#include "game_share/scenario.h"
|
||
|
#include "server_share/r2_vision.h"
|
||
|
|
||
|
using namespace NLMISC;
|
||
|
using namespace NLNET;
|
||
|
using namespace std;
|
||
|
|
||
|
extern CGenericXmlMsgHeaderManager GenericMsgManager;
|
||
|
|
||
|
CVariable<bool> BuildSpireActive( "egs", "BuildSpireActive", "Activate build spire", true, 0, true );
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:ITEM
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientItemDrop( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbItemDrop(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
|
||
|
void cbClientItemPickUpClose( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
cbItemClosePickup(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientItemSwap( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbItemSwap(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientItemHarvest( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbHarvest(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientItemHarvestClose( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbHarvestClose(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientItemEquip( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientItemEquip);
|
||
|
|
||
|
uint16 equippedInventory, equippedSlot, bagSlot;
|
||
|
CEntityId id;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( equippedInventory );
|
||
|
msgin.serial( equippedSlot );
|
||
|
msgin.serial( bagSlot );
|
||
|
|
||
|
CCharacter *c = (CCharacter * ) CEntityBaseManager::getEntityBasePtr( id );
|
||
|
if( c )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->incInterfaceCounter();
|
||
|
|
||
|
// if player is stunned or dead cancel action
|
||
|
if (c->isDead() || c->isStunned())
|
||
|
return;
|
||
|
c->equipCharacter( INVENTORIES::TInventory(equippedInventory), equippedSlot, bagSlot, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientItemUnequip( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientItemUnequip);
|
||
|
|
||
|
uint16 equippedInventory, equippedSlot;
|
||
|
CEntityId id;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( equippedInventory );
|
||
|
msgin.serial( equippedSlot );
|
||
|
|
||
|
CCharacter *c = (CCharacter * ) CEntityBaseManager::getEntityBasePtr( id );
|
||
|
if( c )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->incInterfaceCounter();
|
||
|
|
||
|
// if player is stunned or dead cancel action
|
||
|
if (c->isDead() || c->isStunned())
|
||
|
return;
|
||
|
|
||
|
c->unequipCharacter( INVENTORIES::TInventory(equippedInventory), equippedSlot, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//----------------------------
|
||
|
// cbItemDestroy
|
||
|
//----------------------------
|
||
|
void cbClientItemDestroy( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemDestroy);
|
||
|
|
||
|
CEntityId user;
|
||
|
uint16 inventory,slot,quantity;
|
||
|
|
||
|
msgin.serial(user);
|
||
|
msgin.serial(inventory);
|
||
|
msgin.serial(slot);
|
||
|
msgin.serial(quantity);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbItemDestroy> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbItemDestroy> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
character->setAfkState(false);
|
||
|
character->destroyItem( INVENTORIES::TInventory(inventory), slot, quantity, true );
|
||
|
}
|
||
|
|
||
|
// take an item from temp inventory to bag
|
||
|
void cbClientItemTempToBag( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemTempToBag);
|
||
|
|
||
|
CEntityId user;
|
||
|
uint16 slot;
|
||
|
|
||
|
msgin.serial(user);
|
||
|
msgin.serial(slot);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientItemTempToBag> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientItemTempToBag> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
character->setAfkState(false);
|
||
|
character->itemTempInventoryToBag( slot );
|
||
|
}
|
||
|
|
||
|
// get all item from temp inventory
|
||
|
void cbClientItemAllTemp( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemAllTemp);
|
||
|
|
||
|
CEntityId user;
|
||
|
msgin.serial(user);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientItemAllTemp> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientItemAllTemp> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
character->setAfkState(false);
|
||
|
character->sendCloseTempInventoryImpulsion();
|
||
|
}
|
||
|
|
||
|
// clear temp inventory
|
||
|
void cbClientItemNoTemp( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemNoTemp);
|
||
|
|
||
|
CEntityId user;
|
||
|
msgin.serial(user);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientItemNoTemp> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientItemAllTemp> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
TLogContext_Item_DropTempInventory dropTemp(user);
|
||
|
|
||
|
character->setAfkState(false);
|
||
|
character->clearTempInventory();
|
||
|
}
|
||
|
|
||
|
// Enchant or recharge an item
|
||
|
void cbClientItemEnchant( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemEnchant);
|
||
|
|
||
|
CEntityId user;
|
||
|
msgin.serial(user);
|
||
|
|
||
|
uint8 inv;
|
||
|
uint16 slot;
|
||
|
msgin.serial(inv, slot);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientItemEnchant> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientItemEnchant> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
character->enchantOrRechargeItem( (INVENTORIES::TInventory) inv, slot );
|
||
|
character->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
// use a tp item
|
||
|
void cbClientItemUseItem( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemUseItem);
|
||
|
|
||
|
CEntityId user;
|
||
|
msgin.serial(user);
|
||
|
|
||
|
uint16 slot;
|
||
|
msgin.serial(slot);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<USEITEM> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<USEITEM> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
character->useItem(slot);
|
||
|
}
|
||
|
|
||
|
void cbClientItemStopUseXpCat( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientItemStopUseXpCat);
|
||
|
|
||
|
CEntityId user;
|
||
|
msgin.serial(user);
|
||
|
|
||
|
bool isRingCatalyser;
|
||
|
msgin.serial(isRingCatalyser);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( user );
|
||
|
if (character == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientItemStopUseXpCat> Invalid player Id %s", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!character->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientItemStopUseXpCat> player Id %s not yet ready", user.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
character->stopUseItem( isRingCatalyser );
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:HARVEST
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
void cbClientHarvestDeposit( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbHarvestDeposit(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:PHRASE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
// execute client sentence
|
||
|
void cbClientPhraseExecute( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseExecute);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set,slot);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseExecute> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseExecute> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->executeMemorizedPhrase( set, slot, false , false);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseExecuteCyclic( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseExecuteCyclic);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set,slot);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseExecuteCyclic> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseExecuteCyclic> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->setAfkState(false);
|
||
|
ch->executeMemorizedPhrase( set, slot, true,false );
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseExecuteFaber( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseExecuteFaber);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
NLMISC::CSheetId craftPlan;
|
||
|
msgin.serial( craftPlan );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set,slot);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
if ( ch->getKnownBricks().find( craftPlan ) == ch->getKnownBricks().end())
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(Id).toString();
|
||
|
nlwarning("HACK: %s %s tries to craft a brick he doesn't know %s", Id.toString().c_str(), name.c_str(), craftPlan.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->setCraftPlan( craftPlan );
|
||
|
|
||
|
ch->clearFaberRms();
|
||
|
msgin.serialCont( ch->getFaberRmsNoConst() );
|
||
|
msgin.serialCont( ch->getFaberRmsFormulaNoConst() );
|
||
|
|
||
|
ch->executeMemorizedPhrase( set, slot, false,false );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseMemorize( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseMemorize);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set, slot);
|
||
|
|
||
|
uint16 phraseId;
|
||
|
msgin.serial( phraseId );
|
||
|
|
||
|
CSPhraseCom phraseDesc;
|
||
|
msgin.serial( phraseDesc );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseMemorize> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseMemorize> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// memorize
|
||
|
ch->memorize(set, slot,phraseId,phraseDesc.Bricks);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseForget( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseForget);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set,slot);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseForget> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseForget> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->forgetPhrase( set, slot);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseDelete( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseDelete);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint16 phraseId;
|
||
|
msgin.serial( phraseId );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseDelete> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseDelete> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->deleteKnownPhrase(phraseId);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientPhraseLearn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseLearn);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint16 phraseId;
|
||
|
msgin.serial( phraseId );
|
||
|
|
||
|
CSPhraseCom phrase;
|
||
|
msgin.serial( phrase );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseLearn> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseLearn> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->learnPhrase( phrase.Bricks, phraseId, phrase.Name );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
|
||
|
void cbClientPhraseBuyByIndex( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseBuyByIndex);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 botChatIndex;
|
||
|
msgin.serial( botChatIndex );
|
||
|
|
||
|
uint16 phraseId;
|
||
|
msgin.serial( phraseId );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseBuyByIndex> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseBuyByIndex> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->incInterfaceCounter();
|
||
|
ch->buyPhraseByIndex( botChatIndex, phraseId);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
void cbClientPhraseBuyBySheet( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseBuyBySheet);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
CSheetId phraseSheetId;
|
||
|
uint32 val;
|
||
|
msgin.serial( val );
|
||
|
phraseSheetId = val;
|
||
|
|
||
|
uint16 index;
|
||
|
msgin.serial( index );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseBuyBySheet> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseBuyBySheet> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->incInterfaceCounter();
|
||
|
ch->buyPhraseBySheet(phraseSheetId,index);
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
void cbClientPhraseCancelTop( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseCancelTop);
|
||
|
|
||
|
if ( ! Mirror.mirrorIsReady() )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseCancelTop> Received from %s service but mirror not yet ready", serviceName.c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
NLMISC::CEntityId entityId;
|
||
|
msgin.serial( entityId );
|
||
|
|
||
|
TDataSetRow entityRowId = TheDataset.getDataSetRow(entityId);
|
||
|
|
||
|
CPhraseManager::getInstance().cancelTopPhrase(entityRowId);
|
||
|
} // cbClientPhraseCancelTop //
|
||
|
|
||
|
void cbClientPhraseCancelAll( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseCancelAll);
|
||
|
|
||
|
if ( ! Mirror.mirrorIsReady() )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseCancelAll> Received from %s service but mirror not yet ready", serviceName.c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
NLMISC::CEntityId entityId;
|
||
|
msgin.serial( entityId );
|
||
|
|
||
|
TDataSetRow entityRowId = TheDataset.getDataSetRow(entityId);
|
||
|
|
||
|
CPhraseManager::getInstance().cancelAllPhrases(entityRowId);
|
||
|
} // cbClientPhraseCancelAll //
|
||
|
|
||
|
void cbClientPhraseCristalize( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientPhraseCristalize);
|
||
|
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
uint8 set,slot;
|
||
|
msgin.serial(set,slot);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseCristalize> Unknown character %s", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!ch->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientPhraseCristalize> player Id %s not yet ready", Id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ch->executeMemorizedPhrase( set, slot, false, true );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:COMBAT
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientCombatEngage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbEngage(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientCombatDisengage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbDisengage( msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientCombatDefaultAttack( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbDefaultAttack(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
|
||
|
void cbClientValidateMeleeCombat( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientValidateMeleeCombat);
|
||
|
|
||
|
CEntityId idPlayer;
|
||
|
msgin.serial( idPlayer );
|
||
|
|
||
|
uint8 flag;
|
||
|
msgin.serial(flag);
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( idPlayer );
|
||
|
if ( ch && ch->getEnterFlag() )
|
||
|
{
|
||
|
ch->validateMeleeCombat(flag != 0);
|
||
|
//ch->setAfkState(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientCombatProtectedSlot( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientCombatProtectedSlot);
|
||
|
|
||
|
CEntityId idPlayer;
|
||
|
msgin.serial( idPlayer );
|
||
|
|
||
|
uint8 slot;
|
||
|
msgin.serial( slot );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( idPlayer );
|
||
|
if ( ch && ch->getEnterFlag() )
|
||
|
{
|
||
|
ch->protectedSlot( SLOT_EQUIPMENT::TSlotEquipment(slot) );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientCombatParry( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientCombatParry);
|
||
|
|
||
|
CEntityId idPlayer;
|
||
|
msgin.serial( idPlayer );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( idPlayer );
|
||
|
if ( ch && ch->getEnterFlag() )
|
||
|
{
|
||
|
ch->dodgeAsDefense( false );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientCombatDodge( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientCombatDodge);
|
||
|
|
||
|
CEntityId idPlayer;
|
||
|
msgin.serial( idPlayer );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( idPlayer );
|
||
|
if ( ch && ch->getEnterFlag() )
|
||
|
{
|
||
|
ch->dodgeAsDefense( true );
|
||
|
ch->setAfkState(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:LEAGUE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientLeagueJoin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinLeague(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientLeagueJoinProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinLeagueProposal(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientLeagueJoinProposalDecline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinLeagueDecline(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:TEAM
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientTeamLeave( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbLeaveTeam(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientTeamJoin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinTeam(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientTeamKick( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbKickTeammate(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientTeamJoinProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinTeamProposal(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientTeamJoinProposalDecline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbJoinTeamDecline(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
void cbClientTeamSetSuccessor( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientTeamSetSuccessor);
|
||
|
|
||
|
CEntityId id;
|
||
|
uint8 idx;
|
||
|
msgin.serial(id);
|
||
|
msgin.serial(idx);
|
||
|
CCharacter* user = PlayerManager.getChar( id );
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<TEAM> Invalid user %s",id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
CTeam * team = TeamManager.getTeam( user->getTeamId() );
|
||
|
if ( !team )
|
||
|
{
|
||
|
nlwarning("<TEAM> Invalid team for user %s",id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
if ( team->getLeader() != id )
|
||
|
{
|
||
|
nlwarning("<TEAM> user %s is not leader: cant set successor",id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
if (team->getSuccessor() == id)
|
||
|
{
|
||
|
nlwarning("<TEAM> user %s already is successor", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// increment the target index as the leader is not in its team list
|
||
|
++idx;
|
||
|
team->setSuccessor( idx );
|
||
|
|
||
|
}
|
||
|
|
||
|
void cbClientTeamShareValidItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientTeamShareValidItem);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
CCharacter * user = PlayerManager.getChar(id);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValidItem>invalid char %s",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValidItem> player Id %s not yet ready", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
user->setAfkState(false);
|
||
|
CTeam * team = TeamManager.getRealTeam(user->getTeamId());
|
||
|
if (!team)
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValidItem>char %s has no valid team",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
if ( !team->getReward() )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValidItem>char %s: his team has no reward",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint8 pos,state;
|
||
|
msgin.serial(pos);
|
||
|
msgin.serial(state);
|
||
|
team->getReward()->userItemSelect(user->getEntityRowId(),pos,state);
|
||
|
}
|
||
|
|
||
|
void cbClientTeamShareInvalidItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientTeamShareInvalidItem);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
CCharacter * user = PlayerManager.getChar(id);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareInvalidItem>invalid char %s",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareInvalidItem> player Id %s not yet ready", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->setAfkState(false);
|
||
|
CTeam * team = TeamManager.getRealTeam(user->getTeamId());
|
||
|
if (!team)
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareInvalidItem>char %s has no valid team",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
if ( !team->getReward() )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareInvalidItem>char %s: his team has no reward",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint8 pos,state;
|
||
|
msgin.serial(pos);
|
||
|
msgin.serial(state);
|
||
|
team->getReward()->userItemSelect(user->getEntityRowId(),pos,state);
|
||
|
}
|
||
|
|
||
|
void cbClientTeamShareValid( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientTeamShareValid);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
CCharacter * user = PlayerManager.getChar(id);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValid>invalid char %s",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValid> player Id %s not yet ready", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->setAfkState(false);
|
||
|
CTeam * team = TeamManager.getRealTeam(user->getTeamId());
|
||
|
if (!team)
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValid>char %s has no valid team",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
if ( !team->getReward() )
|
||
|
{
|
||
|
nlwarning("<cbClientTeamShareValid>char %s: his team has no reward",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint8 state;
|
||
|
msgin.serial(state);
|
||
|
if ( team->getReward()->userValidSelect(user->getEntityRowId(),state) )
|
||
|
team->clearReward();
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------
|
||
|
// Add a player to contact list or ignore list
|
||
|
//---------------------------------------------------
|
||
|
void cbClientAddToContactList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientAddToContactList);
|
||
|
|
||
|
CEntityId charId;
|
||
|
ucstring playerName;
|
||
|
uint8 list;
|
||
|
|
||
|
msgin.serial(charId);
|
||
|
msgin.serial(playerName);
|
||
|
msgin.serial(list);
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( charId );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
if (list == 0)
|
||
|
{
|
||
|
c->addPlayerToFriendList(playerName);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
c->addPlayerToIgnoreList(playerName);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------
|
||
|
// remove a player from contact list or ignore list
|
||
|
//---------------------------------------------------
|
||
|
void cbClientRemoveFromContactList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientRemoveFromContactList);
|
||
|
|
||
|
CEntityId charId;
|
||
|
uint32 contactId;
|
||
|
uint8 list;
|
||
|
|
||
|
msgin.serial(charId);
|
||
|
msgin.serial(contactId);
|
||
|
msgin.serial(list);
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( charId );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
if (list == 0)
|
||
|
{
|
||
|
c->removePlayerFromFriendListByContactId(contactId);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
c->removePlayerFromIgnoreListByContactId(contactId);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------
|
||
|
// Mobe a player from a contact list to an another one
|
||
|
//---------------------------------------------------
|
||
|
void cbClientMoveInContactLists( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientMoveInContactLists);
|
||
|
|
||
|
CEntityId charId;
|
||
|
uint32 contactIdOrigin;
|
||
|
uint8 listOrigin;
|
||
|
|
||
|
msgin.serial(charId);
|
||
|
msgin.serial(contactIdOrigin);
|
||
|
msgin.serial(listOrigin);
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( charId );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
if (listOrigin == 0)
|
||
|
{
|
||
|
NLMISC::CEntityId eid= c->getFriendByContactId(contactIdOrigin);
|
||
|
// allows the whole operation or nothing if player does not exist
|
||
|
if (eid != CEntityId::Unknown)
|
||
|
{
|
||
|
c->removePlayerFromFriendListByEntityId(eid);
|
||
|
c->addPlayerToIgnoreList(eid);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// player not found => message
|
||
|
PHRASE_UTILITIES::sendDynamicSystemMessage( c->getEntityRowId(), "OPERATION_NOTEXIST");
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
NLMISC::CEntityId eid= c->getIgnoreByContactId(contactIdOrigin);
|
||
|
// allows the whole operation or nothing if player is not present
|
||
|
if(eid != CEntityId::Unknown)
|
||
|
{
|
||
|
c->removePlayerFromIgnoreListByEntityId(eid);
|
||
|
c->addPlayerToFriendList(eid);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// player not found => message
|
||
|
PHRASE_UTILITIES::sendDynamicSystemMessage( c->getEntityRowId(), "OPERATION_NOTEXIST");
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:TP
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
// teleport near a bot
|
||
|
/*void cbClientTpBot( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId idPlayer;
|
||
|
string name;
|
||
|
CEntityId botId;
|
||
|
msgin.serial( idPlayer );
|
||
|
msgin.serial( name );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( idPlayer );
|
||
|
if ( ch && ch->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
CEntityBase* entity = PlayerManager.getCharacterByName( name );
|
||
|
if( ! entity )
|
||
|
{
|
||
|
TAIAlias alias = CAIAliasTranslator::getInstance()->getNPCAliasFromName(name);
|
||
|
if ( ! CAIAliasTranslator::getInstance()->getEntityId(alias,botId) )
|
||
|
{
|
||
|
nlwarning("<cbClientTpBot> Unknown alias %d", alias );
|
||
|
return;
|
||
|
}
|
||
|
entity = CreatureManager.getCreature( botId );
|
||
|
}
|
||
|
if ( entity )
|
||
|
{
|
||
|
sint32 x = entity->getState().X + sint32( cos(entity->getState().Heading) * 2000 );
|
||
|
sint32 y = entity->getState().Y + sint32( sin(entity->getState().Heading) * 2000 );
|
||
|
ch->allowNearPetTp();
|
||
|
ch->tpWanted( x,y, entity->getState().Z );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientTpBot> Unknown bot %s", botId.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientTpBot> Unknown character %s or don't have priv", idPlayer.toString().c_str() );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
//
|
||
|
/*void cbClientTpWanted( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId Id;
|
||
|
sint32 x, y, z;
|
||
|
|
||
|
msgin.serial( Id );
|
||
|
msgin.serial( x );
|
||
|
msgin.serial( y );
|
||
|
msgin.serial( z );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
if ( ch && ch->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
ch->forbidNearPetTp();
|
||
|
ch->tpWanted( x, y , z );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientTpWanted> Unknown character %s or don't have priv", Id.toString().c_str() );
|
||
|
}
|
||
|
|
||
|
}*/
|
||
|
|
||
|
|
||
|
// client want tp at respawn point (beta test features for work-arround stuck collide)
|
||
|
/*void cbClientTpRespawn( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId characterId;
|
||
|
msgin.serial( characterId );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( characterId );
|
||
|
if ( ch )
|
||
|
{
|
||
|
COfflineEntityState state = PlayerManager.getStartState( ch->getActiveRole() );
|
||
|
ch->allowNearPetTp();
|
||
|
ch->tpWanted( state.X, state.Y, state.Z );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:ANIMALS
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientAnimalsBeast( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbAnimalCommand(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
void cbClientAnimalsDisbandConvoy( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->clearBeastTrain();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientAnimalsDisbandConvoy> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
|
||
|
/*
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:TRADE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
|
||
|
void cbClientTradeNextPage( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint16 session;
|
||
|
msgin.serial(userId);
|
||
|
msgin.serial(session);
|
||
|
CCharacter * c = PlayerManager.getChar( userId );
|
||
|
if ( c )
|
||
|
;//c->tradeNextPage(session);
|
||
|
else
|
||
|
nlwarning("<cbClientTradeNextPage> Invalid user %s",userId.toString().c_str());
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
void cbClientTradeMissionNextPage( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint16 session;
|
||
|
msgin.serial(userId);
|
||
|
msgin.serial(session);
|
||
|
CCharacter * c = PlayerManager.getChar( userId );
|
||
|
if ( c )
|
||
|
;//c->tradeMissionNextPage(session);
|
||
|
else
|
||
|
nlwarning("<cbClientTradeNextPage> Invalid user %s",userId.toString().c_str());
|
||
|
}
|
||
|
|
||
|
// Client want buy an item
|
||
|
void cbClientTradeBuy( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
cbTradeBuySomething(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
|
||
|
// Client ask selling price of an item
|
||
|
void cbClientTradeQuerySellPrice( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId id;
|
||
|
uint16 Inventory, Slot;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( Inventory );
|
||
|
msgin.serial( Slot );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c )
|
||
|
{
|
||
|
c->askSellPrice( Inventory, Slot );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientTradeQuerySellPrice> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Client sell an item
|
||
|
void cbClientTradeSellItem( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId id;
|
||
|
uint16 Inventory, Slot;
|
||
|
uint16 Quantity;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( Inventory );
|
||
|
msgin.serial( Slot );
|
||
|
msgin.serial( Quantity );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c )
|
||
|
{
|
||
|
c->sellItem( Inventory, Slot, Quantity );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientTradeSellItem> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:EXCHANGE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbExchangeProposal(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeAcceptInvitation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbAcceptExchangeInvitation(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeDeclineInvitation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbDeclineExchangeInvitation(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeSeeds( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbExchangeSeeds(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeEnd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbEndExchange(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientExchangeValidate( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
cbAcceptExchange(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
|
||
|
void cbClientExchangeInvalidate( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientExchangeInvalidate);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if (c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->invalidateExchange();
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbClientExchangeInvalidate : invalid char %s>",id.toString().c_str());
|
||
|
}
|
||
|
|
||
|
void cbClientExchangeAdd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientExchangeAdd);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
|
||
|
uint16 slotSrc, slotDest;
|
||
|
uint16 quantity;
|
||
|
|
||
|
msgin.serial(slotSrc);
|
||
|
msgin.serial(slotDest);
|
||
|
msgin.serial(quantity);
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if (c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->incInterfaceCounter();
|
||
|
c->itemBagToExchange(slotSrc, slotDest, quantity);
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbClientExchangeAdd : invalid char %s>",id.toString().c_str());
|
||
|
}
|
||
|
|
||
|
void cbClientExchangeRemove( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
|
||
|
{
|
||
|
H_AUTO(cbClientExchangeRemove);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
|
||
|
uint16 slotSrc;
|
||
|
msgin.serial(slotSrc);
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if (c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
c->incInterfaceCounter();
|
||
|
c->itemExchangeToBag(slotSrc);
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbClientExchangeRemove : invalid char %s>",id.toString().c_str());
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// BRICK/SENTENCE RELATED COMMANDS
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//
|
||
|
/*void cbClientSentenceCancelCurrent( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
cbCancelCurrentSentence(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientSentenceCancel( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
cbCancelSentence(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
void cbClientSentenceCancelAll( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
cbCancelAllSentences(msgin, serviceName, serviceId);
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// bot chat missions commands
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
/// start the static mission interface
|
||
|
void cbClientBotChatChooseStaticMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
/// ask for the next mission page
|
||
|
void cbClientBotChatNextMissionPage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
/// pick a static mission
|
||
|
void cbClientBotChatPickStaticMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
///continue a mission by ending the current step
|
||
|
void cbClientContinueMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
///validate a gift to a bot
|
||
|
void cbClientValidateMissionGift( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
/// client ends a bot gift
|
||
|
void cbClientBotChatEndGift( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
/// client sends a dynamic bot chat nswer
|
||
|
void cbClientBotChatDynChatSend( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
// client abandons a mission
|
||
|
void cbClientAbandonMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
// client abandons a group mission
|
||
|
void cbClientGroupAbandonMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// bot chat trade
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
|
||
|
/// open interface for item trade
|
||
|
void cbClientBotChatStartTradeItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartTradeItem);
|
||
|
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeItem> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeItem> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// start a bot chat
|
||
|
if ( !user->startBotChat( BOTCHATTYPE::TradeItemFlag ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
user->resetRawMaterialItemPartFilter();
|
||
|
user->resetItemTypeFilter();
|
||
|
user->startTradeItemSession(session);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
/// open interface for teleport trade
|
||
|
void cbClientBotChatStartTradeTp( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartTradeTp);
|
||
|
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeTp> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeTp> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// start a bot chat
|
||
|
if ( !user->startBotChat( BOTCHATTYPE::TradeTeleportFlag ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
user->startTradeItemSession(session);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
/// open interface for faction item trade
|
||
|
void cbClientBotChatStartTradeFaction( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartTradeFaction);
|
||
|
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeFaction> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeFaction> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// start a bot chat
|
||
|
if ( !user->startBotChat( BOTCHATTYPE::TradeFactionFlag ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
user->startTradeItemSession(session);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
/// start trade guild options
|
||
|
void cbClientBotChatStartTradeGuildOptions( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartTradeGuildOptions);
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
CBuildingManager::getInstance()->buildBuildingTradeList(userId,session);
|
||
|
}
|
||
|
|
||
|
/// buy a guild option
|
||
|
void cbClientBotChatBuyGuildOptions( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatBuyGuildOptions);
|
||
|
uint8 idx;
|
||
|
CEntityId userId;
|
||
|
msgin.serial( userId,idx );
|
||
|
CBuildingManager::getInstance()->buyBuildingOption( userId,idx );
|
||
|
}
|
||
|
|
||
|
/// start research with a guild bot
|
||
|
void cbClientBotChatStartGuildResearch( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartGuildResearch);
|
||
|
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
|
||
|
/// todo appart
|
||
|
// CGuildManager::getInstance()->buildGuildResearchList(userId,session);
|
||
|
}
|
||
|
|
||
|
|
||
|
/// trade next page
|
||
|
void cbClientBotChatTradeNextPage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatTradeNextPage);
|
||
|
|
||
|
uint16 session;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,session);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeNextPage> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeNextPage> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->fillTradePage(session);
|
||
|
|
||
|
}
|
||
|
|
||
|
/// buy an item
|
||
|
void cbClientBotChatTradeBuy( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatTradeBuy);
|
||
|
|
||
|
uint16 idx;
|
||
|
uint16 quantity;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,idx,quantity);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeBuy> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeBuy> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->buyItem( idx,quantity);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
// destroy an item in sale store
|
||
|
void cbClientBotChatTradeDestroy( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatTradeDestroy);
|
||
|
uint16 idx;
|
||
|
uint16 quantity;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,idx,quantity);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeDestroy> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeDestroy> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->destroySaleItem( idx,quantity);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
// sell item
|
||
|
void cbClientBotChatTradeSell( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatTradeSell);
|
||
|
|
||
|
uint8 inv;
|
||
|
uint8 idx;
|
||
|
uint16 quantity;
|
||
|
uint32 price;
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId,inv,idx,quantity,price);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeSell> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatTradeSell> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->sellItem(INVENTORIES::TInventory(inv),idx,quantity,price);
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
|
||
|
// start a guild creation session
|
||
|
void cbClientBotChatStartGuildCreation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartGuildCreation);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial(id);
|
||
|
CCharacter * user = PlayerManager.getChar(id);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartGuildCreation> Invalid char %s",id.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartGuildCreation> player Id %s not yet ready", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
user->setAfkState(false);
|
||
|
|
||
|
if ( !user->startBotChat( BOTCHATTYPE::CreateGuildFlag ) )
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
// start trade actions
|
||
|
void cbClientBotChatStartTradeAction( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatStartTradeAction);
|
||
|
|
||
|
uint16 sessionId;
|
||
|
CEntityId userId;
|
||
|
|
||
|
msgin.serial(userId, sessionId);
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeAction> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
// check character is ready
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatStartTradeAction> player Id %s not yet ready", userId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->setAfkState(false);
|
||
|
|
||
|
// start a bot chat
|
||
|
if ( !user->startBotChat( BOTCHATTYPE::TradePhraseFlag ) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
user->startTradePhrases(sessionId);
|
||
|
}
|
||
|
|
||
|
|
||
|
void cbClientBotChatSetFilters( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatSetFilters);
|
||
|
CEntityId userId;
|
||
|
|
||
|
uint32 minQuality, maxQuality, minPrice, maxPrice;
|
||
|
uint8 minClass, maxClass;
|
||
|
uint8 itemPartFilter;
|
||
|
uint8 itemTypeFilter;
|
||
|
|
||
|
msgin.serial(userId, minQuality, maxQuality, minPrice, maxPrice);
|
||
|
msgin.serial(minClass, maxClass, itemPartFilter, itemTypeFilter);
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatSetFilters> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
user->setAfkState(false);
|
||
|
user->setFilters( minQuality, maxQuality, minPrice, maxPrice, (RM_CLASS_TYPE::TRMClassType)minClass, (RM_CLASS_TYPE::TRMClassType)maxClass, (RM_FABER_TYPE::TRMFType)itemPartFilter, (ITEM_TYPE::TItemType)itemTypeFilter );
|
||
|
}
|
||
|
|
||
|
void cbRefreshTradeList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbRefreshTradeList);
|
||
|
CEntityId userId;
|
||
|
|
||
|
msgin.serial( userId );
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<cbClientBotChatSetFilters> Invalid char %s",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
user->refreshTradeList();
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// Client bot chat end
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientBotChatEnd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientBotChatEnd);
|
||
|
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CCharacter* user = PlayerManager.getChar( userId );
|
||
|
if (user && user->getEnterFlag())
|
||
|
{
|
||
|
user->endBotChat();
|
||
|
user->incInterfaceCounter();
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
else
|
||
|
nlwarning("<cbClientBotChatEnd> invalid character %s", userId.toString().c_str());
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// PLAYER COMMAND
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
// client send an emote
|
||
|
void cbClientSendEmote( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientSendEmote);
|
||
|
|
||
|
CEntityId id;
|
||
|
MBEHAV::EBehaviour behaviour = MBEHAV::IDLE;
|
||
|
uint16 emoteTextId;
|
||
|
try
|
||
|
{
|
||
|
msgin.serial( id );
|
||
|
msgin.serialEnum( behaviour );
|
||
|
msgin.serial( emoteTextId );
|
||
|
|
||
|
}
|
||
|
catch(const Exception &e)
|
||
|
{
|
||
|
nlwarning("Bad emote serialisation '%s'", e.what());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
// check if client can launch this emote from his UI
|
||
|
const CStaticTextEmotes & emotes = CSheets::getTextEmoteList();
|
||
|
const CStaticTextEmotes::CTextEmotePhrases * phraseCont = emotes.getPhrase( emoteTextId );
|
||
|
if ( phraseCont != NULL )
|
||
|
{
|
||
|
if( phraseCont->UsableFromClientUI == false )
|
||
|
{
|
||
|
nlwarning("<cbClientSendEmote> client %s sent a forbidden emote : %u",c->getId().toString().c_str(),emoteTextId );
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
c->sendEmote( id, behaviour, emoteTextId );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientSendEmote> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// client send a custom emote
|
||
|
void cbClientSendCustomEmote( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientSendCustomEmote);
|
||
|
|
||
|
CEntityId id;
|
||
|
MBEHAV::EBehaviour behaviour = MBEHAV::IDLE;
|
||
|
ucstring emoteCustomText;
|
||
|
try
|
||
|
{
|
||
|
msgin.serial( id );
|
||
|
msgin.serialEnum( behaviour );
|
||
|
msgin.serial( emoteCustomText );
|
||
|
|
||
|
}
|
||
|
catch(const Exception &e)
|
||
|
{
|
||
|
nlwarning("Bad custom emote serialisation '%s'", e.what());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if(behaviour >= 140 && behaviour <= 169)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(id).toString();
|
||
|
nlwarning("HACK: %s %s tries to launch a firework %d", id.toString().c_str(), name.c_str(), behaviour);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->sendCustomEmote( id, behaviour, emoteCustomText );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientSendCustomEmote> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// client send a command where for known where is it
|
||
|
void cbClientSendWhere( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientSendWhere);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
CZoneManager::getInstance().answerWhere(id);
|
||
|
}
|
||
|
|
||
|
// client send a command where for known where is it
|
||
|
void cbClientSendAfk( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientSendAfk);
|
||
|
|
||
|
CEntityId id;
|
||
|
bool afk;
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( afk );
|
||
|
CCharacter * user = PlayerManager.getChar( id );
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<AFK>'%s' is not a valid user",id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
user->setAfkState( afk );
|
||
|
}
|
||
|
|
||
|
// client send a command to roll a dice
|
||
|
void cbClientRollDice( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientRollDice);
|
||
|
|
||
|
CEntityId entityId;
|
||
|
sint16 min;
|
||
|
sint16 max;
|
||
|
sint16 roll;
|
||
|
msgin.serial( entityId );
|
||
|
msgin.serial( min );
|
||
|
msgin.serial( max );
|
||
|
|
||
|
static NLMISC::CRandom* dice = (NLMISC::CRandom*)NULL;
|
||
|
if (!dice)
|
||
|
{
|
||
|
dice = new NLMISC::CRandom;
|
||
|
dice->srand(CTickEventHandler::getGameCycle());
|
||
|
}
|
||
|
|
||
|
roll = min + (sint16)dice->rand(max-min);
|
||
|
|
||
|
SM_STATIC_PARAMS_4(params, STRING_MANAGER::player, STRING_MANAGER::integer, STRING_MANAGER::integer, STRING_MANAGER::integer);
|
||
|
params[0].setEIdAIAlias(entityId, CAIAliasTranslator::getInstance()->getAIAlias(entityId));
|
||
|
params[1].Int = min;
|
||
|
params[2].Int = max;
|
||
|
params[3].Int = roll;
|
||
|
|
||
|
TDataSetRow playerRowId = TheDataset.getDataSetRow( entityId );
|
||
|
if ( !TheDataset.isAccessible(playerRowId) )
|
||
|
return;
|
||
|
|
||
|
PHRASE_UTILITIES::sendDynamicSystemMessage(playerRowId, "ROLL_DICE", params);
|
||
|
STRING_MANAGER::sendSystemStringToClientAudience(playerRowId, std::vector<NLMISC::CEntityId>(), CChatGroup::shout, "ROLL_DICE", params);
|
||
|
}
|
||
|
|
||
|
// client send command sit (for sit/up)
|
||
|
void cbClientSit( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientSit);
|
||
|
|
||
|
CEntityId id;
|
||
|
bool sit;
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( sit );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
if( sit )
|
||
|
{
|
||
|
if( !c->isInWater() && c->getMode()!=MBEHAV::MOUNT_NORMAL && c->getMode()!=MBEHAV::DEATH )
|
||
|
{
|
||
|
c->setMode( MBEHAV::SIT );
|
||
|
// only if player is'nt equipping an item
|
||
|
//( to prevent exploit "sit to reduce equip latency time")
|
||
|
if( !c->getGearLatency().isLatent() )
|
||
|
{
|
||
|
c->cancelStaticActionInProgress(STATIC_ACT_TYPES::Neutral, false, false);
|
||
|
}
|
||
|
c->cancelStaticEffects();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
c->setMode( MBEHAV::NORMAL );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientSendWhere> received message from unknown client %s", id.toString().c_str() );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// client send a command to change guild motd
|
||
|
void cbClientGuildMotd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientGuildMotd);
|
||
|
|
||
|
CEntityId entityId;
|
||
|
string motd;
|
||
|
msgin.serial( entityId );
|
||
|
msgin.serial( motd );
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar( entityId );
|
||
|
if (!user)
|
||
|
{
|
||
|
nlwarning("<cbClientGuildMotd>'%s' is not a valid char",entityId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
if (!user->getEnterFlag())
|
||
|
{
|
||
|
nlwarning("<cbClientGuildMotd>'%s' is not entered", entityId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
if (!TheDataset.isAccessible(user->getEntityRowId()))
|
||
|
{
|
||
|
nlwarning("<cbClientGuildMotd>'%s' is not valid in mirror", entityId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CGuild * guild = CGuildManager::getInstance()->getGuildFromId( user->getGuildId() );
|
||
|
if( guild )
|
||
|
{
|
||
|
guild->setMOTD(motd, entityId);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:CHEAT
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
// turn character to god mod
|
||
|
//void cbGodMode( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId);
|
||
|
/*void cbClientCheatGod( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
c->ToggleGodMode();
|
||
|
}
|
||
|
|
||
|
// cbGodMode(msgin, serviceName, serviceId);
|
||
|
}*/
|
||
|
|
||
|
/*
|
||
|
void cbClientCreateItemInBag( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId charId;
|
||
|
msgin.serial( charId );
|
||
|
|
||
|
CSheetId itemSheetId;
|
||
|
msgin.serial( itemSheetId );
|
||
|
|
||
|
uint16 quantity;
|
||
|
msgin.serial( quantity );
|
||
|
|
||
|
uint16 quality;
|
||
|
msgin.serial( quality );
|
||
|
|
||
|
// get character
|
||
|
CCharacter *c = PlayerManager.getChar( charId );
|
||
|
if (c&& c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
nlwarning("<cbClientCreateItemInBag> Invalid player Id %s", charId.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
c->createItemInBag( quality, quantity, itemSheetId );
|
||
|
}*/
|
||
|
|
||
|
/*// character learn all existing bricks
|
||
|
void cbClientLearnAllBricks( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
|
||
|
{
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
GameItemManager.learnAllBricks( c );
|
||
|
else
|
||
|
nlwarning("cbClientLearnAllBricks, unknown player '%s'", id.toString().c_str() );
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
// client ask to add money to his character
|
||
|
/*void cbClientMoney( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
msgin.serial ( id );
|
||
|
|
||
|
sint32 vb, b, m, s;
|
||
|
|
||
|
msgin.serial ( vb );
|
||
|
msgin.serial ( b );
|
||
|
msgin.serial ( m );
|
||
|
msgin.serial ( s );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
c->giveSeed( CSeeds( vb, b, m, s ) );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
/*// Client want set Ryzom Time
|
||
|
void cbClientRyzomTime( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
if (!PlayerManager.havePriv(Id, PriviliegeGameMaster))
|
||
|
return;
|
||
|
|
||
|
float Time;
|
||
|
msgin.serial( Time );
|
||
|
|
||
|
CMessage msgout( "SET_RYZOM_TIME" );
|
||
|
msgout.serial( Time );
|
||
|
sendMessageViaMirror( "WOS", msgout );
|
||
|
}
|
||
|
|
||
|
// Client want set Ryzom Day
|
||
|
void cbClientRyzomDay( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
if (!PlayerManager.havePriv(Id, PriviliegeGameMaster))
|
||
|
return;
|
||
|
|
||
|
uint32 Day;
|
||
|
msgin.serial( Day );
|
||
|
|
||
|
CMessage msgout( "SET_RYZOM_DAY" );
|
||
|
msgout.serial( Day );
|
||
|
sendMessageViaMirror( "WOS", msgout );
|
||
|
}
|
||
|
*/
|
||
|
// Client want gain xp in indicated skill
|
||
|
/*void cbClientGainXp( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId Id;
|
||
|
string Skill, Speciality;
|
||
|
uint32 Xp;
|
||
|
|
||
|
msgin.serial( Id );
|
||
|
msgin.serial( Xp );
|
||
|
msgin.serial( Skill );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( Id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
c->addXpToSkill( (double) Xp, Skill );
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
// Client create a new character
|
||
|
/*void cbClientCreateCharacter( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
string characterName;
|
||
|
EGSPD::CPeople::TPeople people;
|
||
|
GSGENDER::EGender gender;
|
||
|
//Deprecated
|
||
|
// ROLES::ERole role;
|
||
|
uint16 level;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serial( characterName );
|
||
|
msgin.serialEnum( people );
|
||
|
msgin.serialEnum( gender );
|
||
|
// msgin.serialEnum( role );
|
||
|
msgin.serial( level );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
uint32 playerId = PlayerManager.getPlayerId( id );
|
||
|
CPlayer * player = PlayerManager.getPlayer( playerId );
|
||
|
if( player )
|
||
|
{
|
||
|
player->replaceCharacter( characterName, people, gender, level );
|
||
|
PlayerManager.savePlayer( playerId );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
// Client create a new character
|
||
|
/*void cbClientAddRole( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
ROLES::ERole role;
|
||
|
uint16 level;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serialEnum( role );
|
||
|
msgin.serial( level );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
c->getRoles().addNewJob( JOBS::getJobForRace( role, (EGSPD::CPeople::TPeople) c->getRace() ) );
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
// Client want to learn bricks
|
||
|
/*void cbClientLearnBrick( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
ROLES::ERole role;
|
||
|
uint16 level;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
msgin.serialEnum( role );
|
||
|
msgin.serial( level );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
GameItemManager.learnAllBricksForRoleAndRace( c, role, (EGSPD::CPeople::TPeople) c->getRace(), level );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
/// cient want to learn all faber plans
|
||
|
/*void cbClientLearnAllFaberPlans( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
|
||
|
msgin.serial( id );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->havePriv(PriviliegeGameMaster))
|
||
|
{
|
||
|
c->learnAllFaberPlans();
|
||
|
}
|
||
|
} // cbClientLearnAllFaberPlans //
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
* CLIENT:DEBUG
|
||
|
*/
|
||
|
|
||
|
// Send server client coordinate
|
||
|
void cbClientWhere( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientWhere);
|
||
|
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c && c->getEnterFlag() )
|
||
|
{
|
||
|
c->setAfkState(false);
|
||
|
CMessage msgout( "IMPULSION_ID" );
|
||
|
msgout.serial( id );
|
||
|
CBitMemStream bms;
|
||
|
if ( ! GenericMsgManager.pushNameToStream( "DEBUG:REPLY_WHERE", bms) )
|
||
|
{
|
||
|
nlwarning("<cbClientWhere> Msg name DEBUG:REPLY_WHERE not found");
|
||
|
return;
|
||
|
}
|
||
|
bms.serial( const_cast< sint32& > (c->getState().X.getValue()) );
|
||
|
bms.serial( const_cast< sint32& > (c->getState().Y.getValue()) );
|
||
|
bms.serial( const_cast< sint32& > (c->getState().Z.getValue()) );
|
||
|
msgout.serialBufferWithSize((uint8*)bms.buffer(), bms.length());
|
||
|
CUnifiedNetwork::getInstance()->send( NLNET::TServiceId(id.getDynamicId()), msgout );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// local macro definition ( undef below )
|
||
|
#define SEND_GM_WHO_ANSWER( _code_ , _msg_) {\
|
||
|
gms = PlayerManager.getSpecialUsers(_code_);\
|
||
|
if ( gms && !gms->empty() )\
|
||
|
{\
|
||
|
for ( uint i = 0; i < gms->size(); i++ )\
|
||
|
{\
|
||
|
TDataSetRow row = TheDataset.getDataSetRow( (*gms)[i] );\
|
||
|
if ( TheDataset.isAccessible( row ) )\
|
||
|
{\
|
||
|
CMirrorPropValue<TYPE_WHO_SEES_ME> whoSeesMe(TheDataset, row, DSPropertyWHO_SEES_ME );\
|
||
|
if ( R2_VISION::isEntityVisibleToPlayers(whoSeesMe) )\
|
||
|
{\
|
||
|
params[0].setEId((*gms)[i]);\
|
||
|
CCharacter::sendDynamicSystemMessage( id,_msg_,params );\
|
||
|
nbAnswers++;\
|
||
|
}\
|
||
|
}\
|
||
|
}\
|
||
|
}\
|
||
|
}
|
||
|
|
||
|
// local macro definition ( undef below )
|
||
|
#define SEND_GM_WHO_ANSWER_INVIS( _code_ , _msg_) {\
|
||
|
gms = PlayerManager.getSpecialUsers(_code_);\
|
||
|
if ( gms && !gms->empty() )\
|
||
|
{\
|
||
|
for ( uint i = 0; i < gms->size(); i++ )\
|
||
|
{\
|
||
|
TDataSetRow row = TheDataset.getDataSetRow( (*gms)[i] );\
|
||
|
if ( TheDataset.isAccessible( row ) )\
|
||
|
{\
|
||
|
CMirrorPropValue<TYPE_WHO_SEES_ME> whoSeesMe(TheDataset, row, DSPropertyWHO_SEES_ME );\
|
||
|
if ( !R2_VISION::isEntityVisibleToPlayers(whoSeesMe) )\
|
||
|
{\
|
||
|
params[0].setEId( (*gms)[i] );\
|
||
|
CCharacter::sendDynamicSystemMessage( id,_msg_,params );\
|
||
|
nbAnswers++;\
|
||
|
}\
|
||
|
}\
|
||
|
}\
|
||
|
}\
|
||
|
}
|
||
|
|
||
|
// Send list of connected character name / account to client
|
||
|
void cbClientWho( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
H_AUTO(cbClientWho);
|
||
|
|
||
|
CEntityId id;
|
||
|
std::string opt;
|
||
|
msgin.serial( id,opt );
|
||
|
const std::vector<CEntityId> * gms = NULL;
|
||
|
|
||
|
// Make sure opt is not like "A(c)" for e acute
|
||
|
ucstring ucopt;
|
||
|
ucopt.fromUtf8(opt);
|
||
|
opt = ucopt.toString();
|
||
|
|
||
|
uint nbAnswers = 0;
|
||
|
|
||
|
// standard who
|
||
|
if ( opt.empty() )
|
||
|
{
|
||
|
CCharacter * user = PlayerManager.getChar( id );
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<WHO>'%s' is invalid", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
CRegion* region = dynamic_cast<CRegion*>( CZoneManager::getInstance().getPlaceFromId( user->getCurrentRegion() ) );
|
||
|
if ( region == NULL )
|
||
|
{
|
||
|
nlwarning("<WHO>'%s' Invalid region %u", id.toString().c_str(), user->getCurrentRegion() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
{
|
||
|
SM_STATIC_PARAMS_1(params, STRING_MANAGER::place);
|
||
|
params[0].Identifier = region->getName();
|
||
|
CCharacter::sendDynamicSystemMessage( id,"WHO_REGION_INTRO",params );
|
||
|
}
|
||
|
|
||
|
// send all users in region
|
||
|
{
|
||
|
SM_STATIC_PARAMS_1(params, STRING_MANAGER::player);
|
||
|
for ( set<CEntityId>::const_iterator it = region->getPlayersInside().begin(); it != region->getPlayersInside().end(); ++it )
|
||
|
{
|
||
|
TDataSetRow row = TheDataset.getDataSetRow( (*it) );
|
||
|
if ( TheDataset.isAccessible( row ) )
|
||
|
{
|
||
|
CCharacter *ch = PlayerManager.getChar( *it );
|
||
|
|
||
|
// check that user are visible to each other and in the same instance
|
||
|
if ( R2_VISION::isEntityVisibleToPlayers(ch->getWhoSeesMe())
|
||
|
&& user->getInstanceNumber() == ch->getInstanceNumber())
|
||
|
{
|
||
|
params[0].setEId( (*it) );
|
||
|
CCharacter::sendDynamicSystemMessage( id,"WHO_REGION_LIST", params );
|
||
|
nbAnswers++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
// GM who
|
||
|
else if ( NLMISC::nlstricmp( opt.c_str(), "GM" ) == 0)
|
||
|
{
|
||
|
TVectorParamCheck params(1);
|
||
|
params[0].Type = STRING_MANAGER::player;
|
||
|
CCharacter::sendDynamicSystemMessage( id,"WHO_GM_INTRO" );
|
||
|
SEND_GM_WHO_ANSWER( ":SGM:","WHO_SGM_LIST" );
|
||
|
SEND_GM_WHO_ANSWER( ":GM:","WHO_GM_LIST" );
|
||
|
SEND_GM_WHO_ANSWER( ":VG:","WHO_VG_LIST" );
|
||
|
SEND_GM_WHO_ANSWER( ":SG:","WHO_SG_LIST" );
|
||
|
SEND_GM_WHO_ANSWER( ":G:","WHO_G_LIST" );
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar( id );
|
||
|
if ( user )
|
||
|
{
|
||
|
CPlayer *p = PlayerManager.getPlayer(PlayerManager.getPlayerId(user->getId()));
|
||
|
if (p != NULL)
|
||
|
{
|
||
|
bool allowIt = p->havePriv(":DEV:");
|
||
|
if( allowIt || p->havePriv(":SGM:GM:VG:SG:G:") )
|
||
|
{
|
||
|
nbAnswers = 0;
|
||
|
TVectorParamCheck params(1);
|
||
|
params[0].Type = STRING_MANAGER::player;
|
||
|
CCharacter::sendDynamicSystemMessage( id,"WHO_INVISIBLE_GM_INTRO" );
|
||
|
if ( allowIt || p->havePriv(":SGM:") )
|
||
|
{
|
||
|
SEND_GM_WHO_ANSWER_INVIS( ":SGM:","WHO_SGM_LIST" );
|
||
|
allowIt = true;
|
||
|
}
|
||
|
if ( allowIt || p->havePriv(":SGM:GM:") )
|
||
|
{
|
||
|
SEND_GM_WHO_ANSWER_INVIS( ":GM:","WHO_GM_LIST" );
|
||
|
allowIt = true;
|
||
|
}
|
||
|
if ( allowIt || p->havePriv(":SGM:GM:VG:") )
|
||
|
{
|
||
|
SEND_GM_WHO_ANSWER_INVIS( ":VG:","WHO_VG_LIST" );
|
||
|
}
|
||
|
if ( allowIt || p->havePriv(":SGM:GM:VG:SG:") )
|
||
|
{
|
||
|
SEND_GM_WHO_ANSWER_INVIS( ":SG:","WHO_SG_LIST" );
|
||
|
}
|
||
|
SEND_GM_WHO_ANSWER_INVIS( ":G:","WHO_G_LIST" );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
TChanID chanID;
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar( id );
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<WHO>'%s' is invalid", id.toString().c_str() );
|
||
|
return;
|
||
|
}
|
||
|
CPlayer *p = PlayerManager.getPlayer(PlayerManager.getPlayerId(user->getId()));
|
||
|
|
||
|
if (NLMISC::nlstricmp( opt.c_str(), "league" ) == 0)
|
||
|
{
|
||
|
chanID = user->getLeagueId();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
chanID = DynChatEGS.getChanIDFromName(opt);
|
||
|
}
|
||
|
|
||
|
if (chanID == DYN_CHAT_INVALID_CHAN)
|
||
|
{
|
||
|
CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_NOT_FOUND" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
bool havePriv = p->havePriv(":DEV:SGM:GM:EM:");
|
||
|
bool hasChannel = false;
|
||
|
nbAnswers = 0;
|
||
|
|
||
|
vector<NLMISC::CEntityId> players;
|
||
|
DynChatEGS.getPlayersInChan(chanID, players);
|
||
|
ucstring playerNames("");
|
||
|
uint32 shardId = CEntityIdTranslator::getInstance()->getEntityShardId(id);
|
||
|
|
||
|
for (uint i = 0; i < players.size(); i++)
|
||
|
{
|
||
|
if (players[i] == id)
|
||
|
hasChannel = true;
|
||
|
|
||
|
ucstring name = CEntityIdTranslator::getInstance()->getByEntity(players[i]);
|
||
|
if (shardId == CEntityIdTranslator::getInstance()->getEntityShardId(players[i]))
|
||
|
{
|
||
|
// Same shard, remove shard from name
|
||
|
CEntityIdTranslator::removeShardFromName(name);
|
||
|
}
|
||
|
playerNames += ((i > 0) ? "\n" : "") + name ;
|
||
|
}
|
||
|
|
||
|
if (!hasChannel && !havePriv)
|
||
|
{
|
||
|
SM_STATIC_PARAMS_1(params, STRING_MANAGER::literal);
|
||
|
params[0].Literal = opt;
|
||
|
CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_NOT_CONNECTED", params );
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (!playerNames.empty())
|
||
|
{
|
||
|
SM_STATIC_PARAMS_1(params, STRING_MANAGER::literal);
|
||
|
params[0].Literal = opt;
|
||
|
CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_INTRO", params);
|
||
|
//playerNames = "Players in channel \"" + opt + "\":" + playerNames;
|
||
|
params[0].Literal = playerNames;
|
||
|
CCharacter::sendDynamicSystemMessage( id, "LITERAL", params );
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( nbAnswers == 0 )
|
||
|
{
|
||
|
CCharacter::sendDynamicSystemMessage( id,"WHO_NO_ANSWER" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#undef SEND_GM_WHO_ANSWER_INVIS
|
||
|
#undef SEND_GM_WHO_ANSWER
|
||
|
|
||
|
// received a ping from a client, write it to client database
|
||
|
void cbClientPing( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId id;
|
||
|
msgin.serial( id );
|
||
|
|
||
|
TGameCycle time;
|
||
|
msgin.serial( time );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar( id );
|
||
|
if( c )
|
||
|
{
|
||
|
// c->_PropertyDatabase.setProp( c->getDataIndexReminder()->DATABASE_PING.PING, time );
|
||
|
CBankAccessor_PLR::getDEBUG_INFO().setPing(c->_PropertyDatabase, time );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
extern void cbClientAdmin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
|
||
|
extern void cbClientAdminOffline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
|
||
|
extern void cbClientRemoteAdmin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
|
||
|
|
||
|
|
||
|
/************************************************************************/
|
||
|
/* GUILD CALLBACKS */
|
||
|
/* implemented in guild_client_callbacks.cpp */
|
||
|
/************************************************************************/
|
||
|
|
||
|
// client wants to create a guild
|
||
|
void cbClientGuildCreate( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// set the leader
|
||
|
void cbClientGuildSetLeader( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// set playergrade
|
||
|
void cbClientGuildSetGrade( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
//client asked another to join his guild
|
||
|
void cbClientGuildJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
//client accept invitation
|
||
|
void cbClientGuildAcceptJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
//client refused invitation
|
||
|
void cbClientGuildRefuseJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// kick a member
|
||
|
void cbClientGuildKickMember( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// quit the guild
|
||
|
void cbClientGuildQuit( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// item : bag to guild
|
||
|
//void cbClientBagToGuild( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId );
|
||
|
/// item : guild to bag
|
||
|
//void cbClientGuildToBag( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId );
|
||
|
/// money : bag to guild
|
||
|
void cbClientGuildPutMoney( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
/// money : guild to bag
|
||
|
void cbClientGuildTakeMoney( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
/// outpost callbacks (implemented in guild_client_callbacks.cpp)
|
||
|
void cbClientOutpostSetSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostSetSquadSpawnZone(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostInsertSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostRemoveSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostSetExpenseLimit(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
//void cbClientOutpostBuyBuilding(NLNET::CMessage & msgin, const std::string & serviceName, uint16 serviceId);
|
||
|
//void cbClientOutpostDestroyBuilding(NLNET::CMessage & msgin, const std::string & serviceName, uint16 serviceId);
|
||
|
void cbClientOutpostSideChosen( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
void cbClientOutpostSelect(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostUnselect(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostWarStart(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostWarValidate(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostGiveup(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostBanishPlayer(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostBanishGuild(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
void cbClientOutpostSetDefensePeriod(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
|
||
|
|
||
|
// client asked for a lift destination
|
||
|
void cbClientGuildLiftDestAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eId;
|
||
|
msgin.serial( eId );
|
||
|
uint16 session;
|
||
|
msgin.serial(session);
|
||
|
CBuildingManager::getInstance()->fillTriggerPage(eId, session,true );
|
||
|
}
|
||
|
|
||
|
// client asked for a lift next page
|
||
|
void cbClientGuildLiftNextPage( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eId;
|
||
|
msgin.serial( eId );
|
||
|
uint16 session;
|
||
|
msgin.serial(session);
|
||
|
CBuildingManager::getInstance()->fillTriggerPage(eId, session, false );
|
||
|
}
|
||
|
|
||
|
// client asked for a lift teleport
|
||
|
void cbClientGuildLiftTeleport( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eId;
|
||
|
msgin.serial( eId );
|
||
|
uint16 index;
|
||
|
msgin.serial(index);
|
||
|
CCharacter * user = PlayerManager.getChar( eId );
|
||
|
if ( user )
|
||
|
CBuildingManager::getInstance()->triggerTeleport(user,index);
|
||
|
}
|
||
|
|
||
|
void cbClientSetCharacterTitle( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eId;
|
||
|
uint8 title;
|
||
|
msgin.serial( eId );
|
||
|
msgin.serial( title );
|
||
|
|
||
|
CCharacter * c = PlayerManager.getChar(eId);
|
||
|
if ( !c )
|
||
|
{
|
||
|
nlwarning("<cbClientSetCharacterTitle> Invalid user %s",eId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
c->setAfkState(false);
|
||
|
|
||
|
const uint32 userId = PlayerManager.getPlayerId(eId);
|
||
|
CPlayer * p = PlayerManager.getPlayer(userId);
|
||
|
if (p == NULL)
|
||
|
{
|
||
|
nlwarning("<cbClientSetCharacterTitle> Invalid player %u", userId);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( title == uint8(CHARACTER_TITLE::FBT) )
|
||
|
{
|
||
|
if ( !p->isBetaTester() )
|
||
|
return;
|
||
|
}
|
||
|
else if ( title == uint8(CHARACTER_TITLE::WIND) )
|
||
|
{
|
||
|
if ( !p->isWindermeerCommunity() )
|
||
|
return;
|
||
|
}
|
||
|
else if ( title >= uint8(CHARACTER_TITLE::BeginGmTitle) && title <= uint8(CHARACTER_TITLE::EndGmTitle) )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// kxu: TODO: check validity of title chosen by player
|
||
|
c->setNewTitle(CHARACTER_TITLE::toString((CHARACTER_TITLE::ECharacterTitle)title));
|
||
|
c->registerName();
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:ITEM_INFO
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientItemInfos( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint16 slotId;
|
||
|
msgin.serial(userId,slotId);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() && TheDataset.isAccessible( user->getEntityRowId() ) )
|
||
|
user->sendItemInfos( slotId );
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:MISSION_PREREQ
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientMissionPrereq( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint8 slotId;
|
||
|
msgin.serial(userId, slotId);
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() && TheDataset.isAccessible( user->getEntityRowId() ) )
|
||
|
user->sendMissionPrerequisitInfos( slotId );
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:DEATH:ASK_RESPAWN
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientAskRespawn( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint16 index;
|
||
|
msgin.serial(userId,index);
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() )
|
||
|
{
|
||
|
user->respawn( index );
|
||
|
user->setAfkState(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:TARGET
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientCompassEnableDynamic( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
//TDataSetIndex compressedIndex;
|
||
|
uint32 compressedIndex;
|
||
|
|
||
|
msgin.serial(userId);
|
||
|
msgin.serial(compressedIndex);
|
||
|
|
||
|
TDataSetRow index = TheDataset.getCurrentDataSetRow( compressedIndex );
|
||
|
if ( ! TheDataset.isAccessible(index) )
|
||
|
{
|
||
|
nlwarning("<cbClientCompassEnableDynamic>: compressed index results in an invalid datasetrow");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() )
|
||
|
{
|
||
|
user->setCompassTarget( index );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientCompassDisableDynamic( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
static const TDataSetRow invalidRow;
|
||
|
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() )
|
||
|
{
|
||
|
user->setCompassTarget( invalidRow );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT: PVP choose clan
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
/*
|
||
|
void cbClientPvpChooseClan( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
uint8 clan;
|
||
|
|
||
|
msgin.serial(userId,clan);
|
||
|
|
||
|
CCharacter * user = PlayerManager.getChar(userId);
|
||
|
if ( user && user->getEnterFlag() )
|
||
|
{
|
||
|
if ( user->getPVPInterface().isValid() )
|
||
|
user->getPVPInterface().setUserClan( clan );
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:MISSION
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientMissionEnterCritical( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
|
||
|
bool accept;
|
||
|
msgin.serial(accept);
|
||
|
|
||
|
CCharacter *player = PlayerManager.getChar(userId);
|
||
|
if (player)
|
||
|
CMissionQueueManager::getInstance()->playerEntersCriticalArea(userId, player->getEnterCriticalZoneProposalQueueId(), accept);
|
||
|
|
||
|
|
||
|
}
|
||
|
|
||
|
void cbClientMissionWake( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
void cbClientMissionGroupWake( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:DUEL
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
void cbClientDuelAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager2::getInstance()->askForDuel( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientDuelAccept( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager2::getInstance()->acceptDuel( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientDuelRefuse( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager2::getInstance()->refuseDuel( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientDuelAbandon( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager2::getInstance()->abandonDuel( userId );
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:PVP CHALLENGE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
void cbClientPVPChallengeAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager::getInstance()->askForPVPChallenge( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientPVPChallengeAccept( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager::getInstance()->acceptPVPChallenge( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientPVPChallengeRefuse( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CPVPManager::getInstance()->refusePVPChallenge( userId );
|
||
|
}
|
||
|
|
||
|
void cbClientPVPChallengeAbandon( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId userId;
|
||
|
msgin.serial(userId);
|
||
|
CCharacter * user = PlayerManager.getChar( userId );
|
||
|
if ( !user )
|
||
|
{
|
||
|
nlwarning("<PVP>%s is invalid",userId.toString().c_str());
|
||
|
return;
|
||
|
}
|
||
|
CTeam * team = TeamManager.getTeam( user->getTeamId() );
|
||
|
if ( team && team->getLeader() != userId )
|
||
|
{
|
||
|
CCharacter::sendDynamicSystemMessage( userId,"CHALLENGE_ABANDON_NOT_LEADER" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( user->getPVPInterface().isValid() )
|
||
|
user->getPVPInterface().leavePVP( IPVP::AbandonChallenge );
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:PVP FACTION / GUILDE / ALLEGIANCE
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientPvPSetTag( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId charId;
|
||
|
msgin.serial(charId);
|
||
|
|
||
|
bool tagPVP = false;
|
||
|
uint8 flag;
|
||
|
msgin.serial(flag);
|
||
|
if(flag) tagPVP = true;
|
||
|
|
||
|
CCharacter * c = PlayerManager.getOnlineChar(charId);
|
||
|
if( c != 0)
|
||
|
{
|
||
|
c->setPVPFlag( tagPVP );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientPvPSetTag> %s is invalid", charId.toString().c_str());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientPvPSetNeutralAllegiance( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId charId;
|
||
|
msgin.serial(charId);
|
||
|
|
||
|
uint8 allegianceU8;
|
||
|
msgin.serial(allegianceU8);
|
||
|
|
||
|
PVP_CLAN::TPVPClan allegiance = (PVP_CLAN::TPVPClan)allegianceU8;
|
||
|
|
||
|
CCharacter * c = PlayerManager.getOnlineChar(charId);
|
||
|
if( c != 0)
|
||
|
{
|
||
|
c->setAllegianceFromIndeterminedStatus(allegiance);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientPvPSetNeutralAllegiance> %s is invalid", charId.toString().c_str());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void cbClientPvPSetNeutralAllegianceGuild( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId charId;
|
||
|
msgin.serial(charId);
|
||
|
|
||
|
uint8 allegianceU8;
|
||
|
msgin.serial(allegianceU8);
|
||
|
|
||
|
PVP_CLAN::TPVPClan allegiance = (PVP_CLAN::TPVPClan)allegianceU8;
|
||
|
|
||
|
CCharacter * c = PlayerManager.getOnlineChar(charId);
|
||
|
if( c != 0)
|
||
|
{
|
||
|
CGuild * guild = CGuildManager::getInstance()->getGuildFromId(c->getGuildId());
|
||
|
if( guild )
|
||
|
{
|
||
|
CGuildMember * gm = guild->getMemberFromEId(charId);
|
||
|
if( gm->getGrade() == EGSPD::CGuildGrade::Leader )
|
||
|
{
|
||
|
guild->setAllegianceFromIndeterminedStatus(allegiance);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CCharacter::sendDynamicSystemMessage( charId,"GUILD_INSUFFICIENT_GRADE" );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientPvPSetNeutralAllegianceGuild> Player Character % have no guild", charId.toString().c_str());
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
nlwarning("<cbClientPvPSetNeutralAllegiance> %s is invalid", charId.toString().c_str());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientQuitGameRequest( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId charId;
|
||
|
bool bypassDisconnectionTimer = false;
|
||
|
try
|
||
|
{
|
||
|
msgin.serial(charId);
|
||
|
if (IsRingShard)
|
||
|
bypassDisconnectionTimer = true;
|
||
|
else
|
||
|
{
|
||
|
msgin.serial(bypassDisconnectionTimer);
|
||
|
if (bypassDisconnectionTimer)
|
||
|
{
|
||
|
// For fast-disconnection on a mainland shard, one needs to produce credentials!
|
||
|
H_AUTO(BypassDiscoTimer);
|
||
|
CSecurityCheckForFastDisconnection securityCheck;
|
||
|
securityCheck.receiveSecurityCode(msgin);
|
||
|
CPlayer *player = PlayerManager.getPlayer(uint32(charId.getShortId()) >> 4);
|
||
|
if (player)
|
||
|
securityCheck.setCookie(player->getLoginCookie()); // if not set (null player), the check won't pass
|
||
|
|
||
|
securityCheck.check("");
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
catch (const Exception &e) // will catch any serialization/security exception
|
||
|
{
|
||
|
GIVEUP_IF(charId.isUnknownId(), "cbClientQuitGameRequest: unknown char", return);
|
||
|
nldebug("BypassDisconnectionTimer denied for %s: %s", charId.toString().c_str(), e.what());
|
||
|
bypassDisconnectionTimer = false;
|
||
|
}
|
||
|
|
||
|
TDataSetRow rowId = TheDataset.getDataSetRow(charId);
|
||
|
const uint32 playerId = PlayerManager.getPlayerId(charId);
|
||
|
|
||
|
if (rowId.isNull() || !rowId.isValid())
|
||
|
{
|
||
|
PlayerManager.disconnectPlayer(playerId);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// stop all phrases in execution for character
|
||
|
CPhraseManager::getInstance().cancelAllPhrases(rowId);
|
||
|
|
||
|
if (bypassDisconnectionTimer)
|
||
|
{
|
||
|
// send the disconnection acknowledgement at once
|
||
|
PlayerManager.disconnectPlayer(playerId);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// add disconnection phrase in manager
|
||
|
static CSheetId decoBrick("bapa02.sbrick");
|
||
|
vector<CSheetId> bricks;
|
||
|
bricks.push_back(decoBrick);
|
||
|
if ( CPhraseManager::getInstance().executePhrase(rowId, rowId, bricks) == NULL )
|
||
|
{
|
||
|
// error while building the phrase, can happen when character isn't really online (connection failed)
|
||
|
PlayerManager.userDisconnected( playerId ); // still waits for the timer before really disconnecting
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbClientReturnToMainland( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
uint32 userId;
|
||
|
msgin.serial(userId);
|
||
|
uint8 charIndex;
|
||
|
msgin.serial(charIndex);
|
||
|
TSessionId rejectedSessionId;
|
||
|
msgin.serial(rejectedSessionId);
|
||
|
|
||
|
CCharacter *character = PlayerManager.getChar( userId, (uint32)charIndex );
|
||
|
if (character)
|
||
|
character->returnToPreviousSession( userId, (sint32)charIndex, rejectedSessionId );
|
||
|
else
|
||
|
nlwarning( "Char not found for %u/%u", userId, (uint)charIndex );
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:EVENT
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
/// returns 0 on success, anything else is error:
|
||
|
/// -1: Invalid inventory
|
||
|
/// -2: Invalid slot
|
||
|
/// -3: Empty slot
|
||
|
sint32 clientEventSetItemCustomText(CCharacter* character, INVENTORIES::TInventory inventory, uint32 slot, ucstring const& text)
|
||
|
{
|
||
|
if (inventory==INVENTORIES::UNDEFINED)
|
||
|
{
|
||
|
return -1;
|
||
|
}
|
||
|
CInventoryPtr invent = character->getInventory(inventory);
|
||
|
if (slot >= invent->getSlotCount())
|
||
|
{
|
||
|
return -2;
|
||
|
}
|
||
|
if (invent->getItem(slot) == NULL)
|
||
|
{
|
||
|
return -3;
|
||
|
}
|
||
|
|
||
|
CGameItemPtr item = invent->getItem(slot);
|
||
|
item->setCustomText(text);
|
||
|
// Following line was commented out by trap, reason unknown
|
||
|
character->incSlotVersion(inventory, slot);
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void cbClientEventSetItemCustomText( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eid;
|
||
|
INVENTORIES::TInventory inventory;
|
||
|
uint32 uiInventory;
|
||
|
uint32 slot;
|
||
|
ucstring text;
|
||
|
msgin.serial(eid);
|
||
|
msgin.serial(uiInventory);
|
||
|
inventory = (INVENTORIES::TInventory)uiInventory;
|
||
|
msgin.serial(slot);
|
||
|
msgin.serial(text);
|
||
|
|
||
|
CCharacter* character = PlayerManager.getChar(eid);
|
||
|
if(!character) return;
|
||
|
|
||
|
if (!character->havePriv(":DEV:SGM:GM:EM:"))
|
||
|
{
|
||
|
// it should be the crafter of the item, check
|
||
|
if (inventory==INVENTORIES::UNDEFINED) return;
|
||
|
CInventoryPtr invent = character->getInventory(inventory);
|
||
|
if (slot >= invent->getSlotCount()) return;
|
||
|
if (invent->getItem(slot) == NULL) return;
|
||
|
CGameItemPtr item = invent->getItem(slot);
|
||
|
|
||
|
const NLMISC::CEntityId &crafterEId = item->getCreator();
|
||
|
const NLMISC::CEntityId &userEId = character->getId();
|
||
|
|
||
|
if(crafterEId != userEId)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
|
||
|
nlwarning("HACK: %s %s tries to set custom text on an item he didn't crafted", userEId.toString().c_str(), name.c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// text must not be too big
|
||
|
if(text.size() > 256)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
|
||
|
nlwarning("HACK: %s %s tries to set custom text of a size > 256 (%d)", userEId.toString().c_str(), name.c_str(), text.size());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// the item must have the good family
|
||
|
const CStaticItem * form = item->getStaticForm();
|
||
|
if (!form) return;
|
||
|
ITEMFAMILY::EItemFamily family = form->Family;
|
||
|
if (!ITEMFAMILY::isTextCustomizable(family))
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
|
||
|
nlwarning("HACK: %s %s tries to set custom text on a item that is not text customizable (%s)", userEId.toString().c_str(), name.c_str(), ITEMFAMILY::toString(family).c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// prevent use of @WEB at begin
|
||
|
if (text.size() >= 4 && text[0]=='@' && text[1]=='W' && text[2]=='E' && text[3]=='B')
|
||
|
text = text.substr(4, text.size() - 4);
|
||
|
|
||
|
// force that the begin of the text for non admin is %mfc
|
||
|
if(!text.empty() && text.substr(0, 4) != ucstring("%mfc"))
|
||
|
{
|
||
|
text = ucstring("%mfc") + text;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
clientEventSetItemCustomText(character, inventory, slot, text);
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:TOTEM
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbTotemBuild( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
if( BuildSpireActive == false )
|
||
|
return;
|
||
|
CEntityId Id;
|
||
|
msgin.serial( Id );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( Id );
|
||
|
|
||
|
if ( !ch )
|
||
|
{
|
||
|
nlwarning("Totem build aborted: no character");
|
||
|
return;
|
||
|
}
|
||
|
if ( !ch->getPVPFlag() )
|
||
|
{
|
||
|
nlwarning("Totem build aborted: character has no pvp flag");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CGuild::TAllegiances allegiance = ch->getAllegiance();
|
||
|
if ( allegiance.first == PVP_CLAN::Neutral )
|
||
|
{
|
||
|
nlwarning("Totem build aborted: character has no cult allegiance");
|
||
|
return;
|
||
|
}
|
||
|
NLMISC::CVector pos( (float)ch->getX() / 1000.0f, (float)ch->getY() / 1000.0f, 0 );
|
||
|
CRegion* region = CZoneManager::getInstance().getRegion( pos );
|
||
|
|
||
|
if ( !region )
|
||
|
{
|
||
|
nlwarning("Totem build aborted: no region where character is");
|
||
|
return;
|
||
|
}
|
||
|
if ( !CPVPFactionRewardManager::getInstance().canBuildTotem( ch ) )
|
||
|
{
|
||
|
nlwarning("Totem build aborted: can't build totem");
|
||
|
return;
|
||
|
}
|
||
|
CPVPFactionRewardManager::getInstance().startTotemBuilding( region->getId(), ch );
|
||
|
nlinfo( "<cbTotemBuild> : %s is building a totem in region %s", Id.toString().c_str(), region->getName().c_str() );
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:DM_GIFT
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbDMGiftBegin( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eid;
|
||
|
msgin.serial( eid );
|
||
|
|
||
|
if(!IsRingShard)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
|
||
|
nlwarning("HACK: %s %s tries to start a GM gift on a non ring shard", eid.toString().c_str(), name.c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CR2MissionItem::getInstance().dmGiftBegin( eid );
|
||
|
}
|
||
|
|
||
|
void cbDMGiftValidate( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eid;
|
||
|
msgin.serial( eid );
|
||
|
|
||
|
if(!IsRingShard)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
|
||
|
nlwarning("HACK: %s %s tries to validate a GM gift on a non ring shard", eid.toString().c_str(), name.c_str());
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
std::vector< R2::TItemAndQuantity > items;
|
||
|
CSheetId sheet;
|
||
|
uint8 quantity;
|
||
|
|
||
|
while( msgin.getPos() < (sint32) msgin.length() )
|
||
|
{
|
||
|
msgin.serial( sheet );
|
||
|
msgin.serial( quantity );
|
||
|
if( sheet != CSheetId::Unknown && quantity != 0)
|
||
|
{
|
||
|
R2::TItemAndQuantity item;
|
||
|
item.SheetId = sheet;
|
||
|
item.Quantity = quantity;
|
||
|
|
||
|
const CStaticItem * form = CSheets::getForm(sheet);
|
||
|
if (form == NULL)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
|
||
|
nlwarning("HACK: %s %s tries to create an item that has a null form", eid.toString().c_str(), name.c_str());
|
||
|
return;
|
||
|
}
|
||
|
if(form->Family != ITEMFAMILY::SCROLL_R2)
|
||
|
{
|
||
|
string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
|
||
|
nlwarning("HACK: %s %s tries to create an item that is not a plot item", eid.toString().c_str(), name.c_str());
|
||
|
return;
|
||
|
}
|
||
|
items.push_back( item );
|
||
|
}
|
||
|
}
|
||
|
CR2MissionItem::getInstance().dmGiftValidate( eid, items );
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:RING_MISSION
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbRingMissionSelectAction( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eid;
|
||
|
uint32 actionId;
|
||
|
|
||
|
msgin.serial( eid );
|
||
|
msgin.serial( actionId );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( eid );
|
||
|
if( ch )
|
||
|
{
|
||
|
CR2GiveItem::getInstance().giveItemGranted( ch->getTargetDataSetRow(), actionId );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
// CLIENT:NPC_ICON
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
void cbGetNpcIconDesc( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
|
||
|
{
|
||
|
CEntityId eid;
|
||
|
vector<uint32> npcKeys;
|
||
|
|
||
|
msgin.serial( eid );
|
||
|
msgin.serialCont( npcKeys );
|
||
|
|
||
|
CCharacter *ch = PlayerManager.getChar( eid );
|
||
|
if( ch )
|
||
|
{
|
||
|
ch->sendNpcMissionGiverIconDesc( npcKeys );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//----------------------------
|
||
|
// CbClientArray
|
||
|
//----------------------------
|
||
|
TUnifiedCallbackItem CbClientArray[]=
|
||
|
{
|
||
|
{ "CLIENT:CONNECTION:CLIENT_QUIT_REQUEST", cbClientQuitGameRequest },
|
||
|
{ "RET_MAINLAND", cbClientReturnToMainland },
|
||
|
|
||
|
{ "CLIENT:ITEM:DROP", cbClientItemDrop },
|
||
|
{ "CLIENT:ITEM:PICK_UP_CLOSE", cbClientItemPickUpClose },
|
||
|
{ "CLIENT:ITEM:SWAP", cbClientItemSwap },
|
||
|
{ "CLIENT:ITEM:HARVEST", cbClientItemHarvest },
|
||
|
{ "CLIENT:ITEM:HARVEST_CLOSE", cbClientItemHarvestClose },
|
||
|
{ "CLIENT:ITEM:DESTROY", cbClientItemDestroy },
|
||
|
{ "CLIENT:ITEM:EQUIP", cbClientItemEquip },
|
||
|
{ "CLIENT:ITEM:UNEQUIP", cbClientItemUnequip },
|
||
|
{ "CLIENT:ITEM:TEMP_TO_BAG", cbClientItemTempToBag },
|
||
|
{ "CLIENT:ITEM:ALL_TEMP", cbClientItemAllTemp },
|
||
|
{ "CLIENT:ITEM:NO_TEMP", cbClientItemNoTemp },
|
||
|
{ "CLIENT:ITEM:ENCHANT", cbClientItemEnchant },
|
||
|
{ "CLIENT:ITEM:USE_ITEM", cbClientItemUseItem },
|
||
|
{ "CLIENT:ITEM:STOP_USE_XP_CAT", cbClientItemStopUseXpCat },
|
||
|
|
||
|
|
||
|
{ "CLIENT:ITEM_INFO:GET", cbClientItemInfos },
|
||
|
{ "CLIENT:MISSION_PREREQ:GET", cbClientMissionPrereq },
|
||
|
|
||
|
{ "CLIENT:HARVEST:DEPOSIT", cbClientHarvestDeposit },
|
||
|
|
||
|
{ "CLIENT:PHRASE:MEMORIZE", cbClientPhraseMemorize },
|
||
|
{ "CLIENT:PHRASE:FORGET", cbClientPhraseForget },
|
||
|
{ "CLIENT:PHRASE:LEARN", cbClientPhraseLearn },
|
||
|
{ "CLIENT:PHRASE:DELETE", cbClientPhraseDelete },
|
||
|
{ "CLIENT:PHRASE:EXECUTE", cbClientPhraseExecute },
|
||
|
{ "CLIENT:PHRASE:EXECUTE_CYCLIC", cbClientPhraseExecuteCyclic },
|
||
|
{ "CLIENT:PHRASE:EXECUTE_FABER", cbClientPhraseExecuteFaber },
|
||
|
{ "CLIENT:PHRASE:BUY", cbClientPhraseBuyByIndex },
|
||
|
{ "CLIENT:PHRASE:BUY_SHEET", cbClientPhraseBuyBySheet },
|
||
|
|
||
|
{ "CLIENT:PHRASE:CANCEL_TOP", cbClientPhraseCancelTop },
|
||
|
{ "CLIENT:PHRASE:CANCEL_ALL", cbClientPhraseCancelAll },
|
||
|
{ "CLIENT:PHRASE:CRISTALIZE", cbClientPhraseCristalize },
|
||
|
|
||
|
|
||
|
{ "CLIENT:COMBAT:ENGAGE", cbClientCombatEngage },
|
||
|
{ "CLIENT:COMBAT:DISENGAGE", cbClientCombatDisengage },
|
||
|
{ "CLIENT:COMBAT:DEFAULT_ATTACK", cbClientCombatDefaultAttack },
|
||
|
{ "CLIENT:COMBAT:VALIDATE_MELEE", cbClientValidateMeleeCombat },
|
||
|
{ "CLIENT:COMBAT:PARRY", cbClientCombatParry },
|
||
|
{ "CLIENT:COMBAT:DODGE", cbClientCombatDodge },
|
||
|
{ "CLIENT:COMBAT:PROTECTED_SLOT", cbClientCombatProtectedSlot },
|
||
|
|
||
|
{ "CLIENT:TEAM:LEAVE", cbClientTeamLeave },
|
||
|
{ "CLIENT:TEAM:JOIN", cbClientTeamJoin },
|
||
|
{ "CLIENT:TEAM:KICK", cbClientTeamKick },
|
||
|
{ "CLIENT:TEAM:JOIN_PROPOSAL", cbClientTeamJoinProposal },
|
||
|
{ "CLIENT:TEAM:JOIN_PROPOSAL_DECLINE", cbClientTeamJoinProposalDecline },
|
||
|
{ "CLIENT:TEAM:SET_SUCCESSOR", cbClientTeamSetSuccessor },
|
||
|
|
||
|
{ "CLIENT:TEAM:SHARE_VALID_ITEM", cbClientTeamShareValidItem },
|
||
|
{ "CLIENT:TEAM:SHARE_INVALID_ITEM", cbClientTeamShareInvalidItem },
|
||
|
{ "CLIENT:TEAM:SHARE_VALID", cbClientTeamShareValid },
|
||
|
|
||
|
{ "CLIENT:TEAM:CONTACT_ADD", cbClientAddToContactList },
|
||
|
{ "CLIENT:TEAM:CONTACT_DEL", cbClientRemoveFromContactList },
|
||
|
{ "CLIENT:TEAM:CONTACT_MOVE", cbClientMoveInContactLists },
|
||
|
|
||
|
|
||
|
// { "CLIENT:TP:BOT", cbClientTpBot },
|
||
|
// { "CLIENT:TP:WANTED", cbClientTpWanted },
|
||
|
{ "CLIENT:TP:ACK", cbClientTpAck },
|
||
|
// { "CLIENT:TP:RESPAWN", cbClientTpRespawn },
|
||
|
|
||
|
// { "CLIENT:ANIMALS:DISBAND_CONVOY", cbClientAnimalsDisbandConvoy },
|
||
|
{ "CLIENT:ANIMALS:BEAST", cbClientAnimalsBeast },
|
||
|
// { "CLIENT:ANIMALS:MOUNT", cbAnimalMount },
|
||
|
// { "CLIENT:ANIMALS:UNSEAT", cbAnimalUnseat },
|
||
|
|
||
|
/*
|
||
|
{ "CLIENT:TRADE:NEXT_PAGE_ITEM", cbClientTradeNextPage },
|
||
|
{ "CLIENT:TRADE:NEXT_PAGE_MISSION_ITEM",cbClientTradeMissionNextPage },
|
||
|
{ "CLIENT:TRADE:BUY", cbClientTradeBuy },
|
||
|
{ "CLIENT:TRADE:QUERY_PRICE", cbClientTradeQuerySellPrice },
|
||
|
{ "CLIENT:TRADE:SELL", cbClientTradeSellItem },
|
||
|
*/
|
||
|
|
||
|
{ "CLIENT:EXCHANGE:PROPOSAL", cbClientExchangeProposal },
|
||
|
{ "CLIENT:EXCHANGE:ACCEPT_INVITATION", cbClientExchangeAcceptInvitation },
|
||
|
{ "CLIENT:EXCHANGE:DECLINE_INVITATION", cbClientExchangeDeclineInvitation },
|
||
|
{ "CLIENT:EXCHANGE:SEEDS", cbClientExchangeSeeds },
|
||
|
{ "CLIENT:EXCHANGE:END", cbClientExchangeEnd },
|
||
|
{ "CLIENT:EXCHANGE:VALIDATE", cbClientExchangeValidate },
|
||
|
{ "CLIENT:EXCHANGE:INVALIDATE", cbClientExchangeInvalidate },
|
||
|
{ "CLIENT:EXCHANGE:ADD", cbClientExchangeAdd },
|
||
|
{ "CLIENT:EXCHANGE:REMOVE", cbClientExchangeRemove },
|
||
|
|
||
|
|
||
|
// { "CLIENT:SENTENCE:CANCEL_CURRENT", cbClientSentenceCancelCurrent },
|
||
|
// { "CLIENT:SENTENCE:CANCEL", cbClientSentenceCancel },
|
||
|
// { "CLIENT:SENTENCE:CANCEL_ALL", cbClientSentenceCancelAll },
|
||
|
|
||
|
{ "CLIENT:COMMAND:EMOTE", cbClientSendEmote },
|
||
|
{ "CLIENT:COMMAND:CUSTOM_EMOTE", cbClientSendCustomEmote },
|
||
|
{ "CLIENT:COMMAND:WHERE", cbClientSendWhere },
|
||
|
{ "CLIENT:COMMAND:ADMIN", cbClientAdmin },
|
||
|
{ "CLIENT:COMMAND:ADMIN_OFFLINE", cbClientAdminOffline },
|
||
|
{ "CLIENT:COMMAND:REMOTE_ADMIN_ANSWER", cbClientRemoteAdmin },
|
||
|
{ "CLIENT:COMMAND:SIT", cbClientSit },
|
||
|
{ "CLIENT:COMMAND:AFK", cbClientSendAfk },
|
||
|
{ "CLIENT:COMMAND:RANDOM", cbClientRollDice },
|
||
|
{ "CLIENT:COMMAND:GUILDMOTD", cbClientGuildMotd },
|
||
|
|
||
|
|
||
|
// For all these commented commands, now you have to use the CLIENT:COMMAND:ADMIN message using /a client command
|
||
|
|
||
|
// { "CLIENT:CHEAT:GOD", cbClientCheatGod },
|
||
|
// { "CLIENT:CHEAT:CREATE_ITEM_IN_BAG", cbClientCreateItemInBag },
|
||
|
// { "CLIENT:CHEAT:LEARN_ALL_BRICKS", cbClientLearnAllBricks },
|
||
|
// { "CLIENT:CHEAT:MONEY", cbClientMoney },
|
||
|
// { "CLIENT:CHEAT:SET_TIME", cbClientRyzomTime },
|
||
|
// { "CLIENT:CHEAT:SET_DAY", cbClientRyzomDay },
|
||
|
// { "CLIENT:CHEAT:XP", cbClientGainXp },
|
||
|
// { "CLIENT:CHEAT:CREATE_CHARACTER", cbClientCreateCharacter },
|
||
|
// { "CLIENT:CHEAT:ADD_ROLE", cbClientAddRole },
|
||
|
// { "CLIENT:CHEAT:LEARN_BRICK", cbClientLearnBrick },
|
||
|
// { "CLIENT:CHEAT:LEARN_ALL_FABER_PLANS", cbClientLearnAllFaberPlans },
|
||
|
|
||
|
{ "CLIENT:DEBUG:WHERE", cbClientWhere },
|
||
|
{ "CLIENT:DEBUG:WHO", cbClientWho },
|
||
|
{ "CLIENT:DEBUG:PING", cbClientPing },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:START_CHOOSE_MISSION", cbClientBotChatChooseStaticMission },
|
||
|
{ "CLIENT:BOTCHAT:NEXT_PAGE_MISSION", cbClientBotChatNextMissionPage },
|
||
|
{ "CLIENT:BOTCHAT:PICK_MISSION", cbClientBotChatPickStaticMission },
|
||
|
{ "CLIENT:BOTCHAT:CONTINUE_MISSION", cbClientContinueMission },
|
||
|
{ "CLIENT:BOTCHAT:VALIDATE_PLAYER_GIFT", cbClientValidateMissionGift },
|
||
|
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_ITEM", cbClientBotChatStartTradeItem },
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_TELEPORT", cbClientBotChatStartTradeTp },
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_FACTION", cbClientBotChatStartTradeFaction },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_GUILD_OPTIONS", cbClientBotChatStartTradeGuildOptions },
|
||
|
{ "CLIENT:BOTCHAT:BUY_GUILD_OPTION", cbClientBotChatBuyGuildOptions },
|
||
|
{ "CLIENT:BOTCHAT:START_GUILD_RESEARCH", cbClientBotChatStartGuildResearch },
|
||
|
|
||
|
|
||
|
/* { "CLIENT:BOTCHAT:START_TRADE_SKILL", cbClientBotChatStartTradeSkill },
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_PACT", cbClientBotChatStartTradePact },*/
|
||
|
{ "CLIENT:BOTCHAT:START_TRADE_ACTION", cbClientBotChatStartTradeAction },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:SET_FILTERS", cbClientBotChatSetFilters },
|
||
|
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:NEXT_PAGE_ITEM", cbClientBotChatTradeNextPage },
|
||
|
{ "CLIENT:BOTCHAT:BUY", cbClientBotChatTradeBuy },
|
||
|
{ "CLIENT:BOTCHAT:DESTROY_ITEM", cbClientBotChatTradeDestroy },
|
||
|
{ "CLIENT:BOTCHAT:SELL", cbClientBotChatTradeSell },
|
||
|
{ "CLIENT:BOTCHAT:REFRESH_TRADE_LIST", cbRefreshTradeList },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:START_CREATE_GUILD", cbClientBotChatStartGuildCreation },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:END", cbClientBotChatEnd },
|
||
|
{ "CLIENT:BOTCHAT:END_GIFT", cbClientBotChatEndGift },
|
||
|
|
||
|
{ "CLIENT:BOTCHAT:DYNCHAT_SEND", cbClientBotChatDynChatSend },
|
||
|
|
||
|
|
||
|
// mission journal related commands
|
||
|
{ "CLIENT:JOURNAL:MISSION_ABANDON", cbClientAbandonMission },
|
||
|
{ "CLIENT:JOURNAL:GROUP_MISSION_ABANDON", cbClientGroupAbandonMission },
|
||
|
|
||
|
// guild related messages
|
||
|
{ "CLIENT:GUILD:CREATE", cbClientGuildCreate },
|
||
|
{ "CLIENT:GUILD:INVITATION", cbClientGuildJoinInvitation },
|
||
|
{ "CLIENT:GUILD:ACCEPT_INVITATION", cbClientGuildAcceptJoinInvitation },
|
||
|
{ "CLIENT:GUILD:REFUSE_INVITATION", cbClientGuildRefuseJoinInvitation },
|
||
|
|
||
|
{ "CLIENT:GUILD:SET_GRADE", cbClientGuildSetGrade },
|
||
|
{ "CLIENT:GUILD:KICK_MEMBER", cbClientGuildKickMember },
|
||
|
|
||
|
|
||
|
{ "CLIENT:GUILD:QUIT", cbClientGuildQuit },
|
||
|
{ "CLIENT:GUILD:TELEPORT", cbClientGuildLiftTeleport },
|
||
|
{ "CLIENT:GUILD:FIRST_ASCENSOR_PAGE", cbClientGuildLiftDestAsked },
|
||
|
{ "CLIENT:GUILD:NEXT_ASCENSOR_PAGE", cbClientGuildLiftNextPage },
|
||
|
{ "CLIENT:GUILD:SET_PLAYER_TITLE", cbClientSetCharacterTitle },
|
||
|
//{ "CLIENT:GUILD:BAG_TO_GUILD", cbClientBagToGuild },
|
||
|
//{ "CLIENT:GUILD:GUILD_TO_BAG", cbClientGuildToBag },
|
||
|
{ "CLIENT:GUILD:PUT_MONEY", cbClientGuildPutMoney },
|
||
|
{ "CLIENT:GUILD:TAKE_MONEY", cbClientGuildTakeMoney },
|
||
|
|
||
|
// outpost related messages
|
||
|
{ "CLIENT:OUTPOST:SET_SQUAD", cbClientOutpostSetSquad },
|
||
|
{ "CLIENT:OUTPOST:SET_SQUAD_SPAWN", cbClientOutpostSetSquadSpawnZone },
|
||
|
{ "CLIENT:OUTPOST:INSERT_SQUAD", cbClientOutpostInsertSquad },
|
||
|
{ "CLIENT:OUTPOST:REMOVE_SQUAD", cbClientOutpostRemoveSquad },
|
||
|
{ "CLIENT:OUTPOST:SET_SQUAD_CAPITAL", cbClientOutpostSetExpenseLimit },
|
||
|
// { "CLIENT:OUTPOST:BUY_BUILDING", cbClientOutpostBuyBuilding },
|
||
|
// { "CLIENT:OUTPOST:DESTROY_BUILDING", cbClientOutpostDestroyBuilding },
|
||
|
{ "CLIENT:OUTPOST:SIDE_CHOSEN", cbClientOutpostSideChosen },
|
||
|
{ "CLIENT:OUTPOST:SELECT", cbClientOutpostSelect },
|
||
|
{ "CLIENT:OUTPOST:UNSELECT", cbClientOutpostUnselect },
|
||
|
{ "CLIENT:OUTPOST:DECLARE_WAR_START", cbClientOutpostWarStart },
|
||
|
{ "CLIENT:OUTPOST:DECLARE_WAR_VALIDATE", cbClientOutpostWarValidate },
|
||
|
{ "CLIENT:OUTPOST:GIVEUP_OUTPOST", cbClientOutpostGiveup },
|
||
|
{ "CLIENT:OUTPOST:BANISH_PLAYER", cbClientOutpostBanishPlayer },
|
||
|
{ "CLIENT:OUTPOST:BANISH_GUILD", cbClientOutpostBanishGuild },
|
||
|
{ "CLIENT:OUTPOST:SET_DEF_PERIOD", cbClientOutpostSetDefensePeriod },
|
||
|
|
||
|
// death management messages
|
||
|
{ "CLIENT:DEATH:ASK_RESPAWN", cbClientAskRespawn },
|
||
|
|
||
|
// set compass target
|
||
|
{ "CLIENT:TARGET:COMPASS_DYNAMIC", cbClientCompassEnableDynamic },
|
||
|
{ "CLIENT:TARGET:COMPASS_NOT_DYNAMIC", cbClientCompassDisableDynamic },
|
||
|
|
||
|
{ "CLIENT:DUEL:ASK", cbClientDuelAsked },
|
||
|
{ "CLIENT:DUEL:ACCEPT", cbClientDuelAccept },
|
||
|
{ "CLIENT:DUEL:REFUSE", cbClientDuelRefuse },
|
||
|
{ "CLIENT:DUEL:ABANDON", cbClientDuelAbandon },
|
||
|
|
||
|
{ "CLIENT:PVP_CHALLENGE:ASK", cbClientLeagueJoinProposal },
|
||
|
{ "CLIENT:PVP_CHALLENGE:ACCEPT", cbClientLeagueJoin },
|
||
|
{ "CLIENT:PVP_CHALLENGE:REFUSE", cbClientLeagueJoinProposalDecline },
|
||
|
{ "CLIENT:PVP_CHALLENGE:ABANDON", cbClientPVPChallengeAbandon },
|
||
|
|
||
|
// { "CLIENT:PVP_VERSUS:CLAN", cbClientPvpChooseClan },
|
||
|
{ "CLIENT:PVP:PVP_TAG", cbClientPvPSetTag },
|
||
|
{ "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE", cbClientPvPSetNeutralAllegiance },
|
||
|
{ "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE_GUILD",cbClientPvPSetNeutralAllegianceGuild },
|
||
|
|
||
|
{ "CLIENT:MISSION:ENTER_CRITICAL", cbClientMissionEnterCritical },
|
||
|
{ "CLIENT:MISSION:WAKE", cbClientMissionWake },
|
||
|
{ "CLIENT:MISSION:GROUP_WAKE", cbClientMissionGroupWake },
|
||
|
|
||
|
{ "CLIENT:EVENT:SET_ITEM_CUSTOM_TEXT", cbClientEventSetItemCustomText },
|
||
|
|
||
|
{ "CLIENT:TOTEM:BUILD", cbTotemBuild },
|
||
|
|
||
|
{ "CLIENT:DM_GIFT:BEGIN", cbDMGiftBegin },
|
||
|
{ "CLIENT:DM_GIFT:VALIDATE", cbDMGiftValidate },
|
||
|
|
||
|
{ "CLIENT:RING_MISSION:MISSION_RING_SELECT",cbRingMissionSelectAction },
|
||
|
|
||
|
{ "CLIENT:NPC_ICON:GET_DESC", cbGetNpcIconDesc },
|
||
|
};
|
||
|
|
||
|
|
||
|
|
||
|
void CClientMessages::init()
|
||
|
{
|
||
|
// setup the callback array
|
||
|
CUnifiedNetwork::getInstance()->addCallbackArray( CbClientArray, sizeof(CbClientArray)/sizeof(CbClientArray[0]) );
|
||
|
}
|
||
|
|
||
|
void CClientMessages::release()
|
||
|
{
|
||
|
}
|