//-----------------------------------------------------------------------------
void CommunityManager::handleMessage(ChatOnGetIgnoreList const &message)
{
//DEBUG_REPORT_LOG(true, ("CommunityManager::handleMessage() - <ChatOnGetIgnoreList> networkId: %s ignore count: %d\n", message.getCharacter().getValueString().c_str(), message.getIgnoreList().size()));
PlayerObject *playerObject = getPlayerObject(message.getCharacter());
if (playerObject != NULL)
{
typedef std::vector<std::string> StringVector;
StringVector ignoreList;
ignoreList.reserve(message.getIgnoreList().size());
std::vector<ChatAvatarId>::const_iterator iterIgnoreList = message.getIgnoreList().begin();
#ifdef _DEBUG
int count = 1;
#endif // _DEBUG
std::string const & thisGameCode = Chat::getGameCode();
std::string const & thisClusterName = GameServer::getInstance().getClusterName();
for (; iterIgnoreList != message.getIgnoreList().end(); ++iterIgnoreList)
{
if (!iterIgnoreList->name.empty())
{
if (_stricmp(iterIgnoreList->gameCode.c_str(), thisGameCode.c_str()))
{
// ignore is from a different game, so store both the game and cluster name
ignoreList.push_back(iterIgnoreList->gameCode + std::string(".") + iterIgnoreList->cluster + std::string(".") + iterIgnoreList->name);
}
else if (_stricmp(iterIgnoreList->cluster.c_str(), thisClusterName.c_str()))
{
// ignore is from a different cluster, so store cluster name
ignoreList.push_back(iterIgnoreList->cluster + std::string(".") + iterIgnoreList->name);
}
else
{
// ignore is from the same cluster, so don't need to store game name
ignoreList.push_back(iterIgnoreList->name);
}
}
//DEBUG_REPORT_LOG(true, (" %2d CommunityManager::handleMessage() - <ChatOnGetIgnoreList> networkId: %s friend: %s\n", ++count, message.getCharacter().getValueString().c_str(), iterIgnoreList->getFullName().c_str()));
//playerObject->addIgnore(iterIgnoreList->name);
#ifdef _DEBUG
++count;
#endif // _DEBUG
}
playerObject->setIgnoreList(ignoreList);
}
}
void EventPerkDeedImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
ManagedReference<CreatureObject*> strongOwner = owner.get();
if (strongOwner != NULL) {
PlayerObject* ghost = strongOwner->getPlayerObject();
if (ghost != NULL) {
ghost->removeEventPerk(_this.get());
}
}
DeedImplementation::destroyObjectFromDatabase(destroyContainedObjects);
}
bool CraftingManager::HandleCancelCraftingSession(Object* object,Object* target,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(object);
message->setIndex(24);
/*uint32 counter = */
message->getUint32();
gCraftingSessionFactory->destroySession(playerObject->getCraftingSession());
//client complains over crafting tool already having an item when we go out of the slot screen!!!!!
return true;
}
void ScriptSupport::scriptSystemMessage(uint64 playerId, uint64 targetId, std::string message)
{
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(playerId));
Object* object = gWorldManager->getObjectById(targetId);
CreatureObject* creature = dynamic_cast<CreatureObject*>(gWorldManager->getObjectById(targetId));
if (object && creature && playerObject && playerObject->isConnected())
{
std::string msg = (int8*)message.c_str();
// gMessageLib->sendPlayClientEffectLocMessage(msg, object->mPosition, playerObject);
gMessageLib->sendPlayClientEffectObjectMessage(msg,"",creature,playerObject);
// "clienteffect/combat_explosion_lair_large.cef"
}
}
/**
* Is called when an object was removed
* @param object object that has been inserted
*/
int PlayerContainerComponent::notifyObjectRemoved(SceneObject* sceneObject, SceneObject* object, SceneObject* destination) const {
CreatureObject* creo = dynamic_cast<CreatureObject*>(sceneObject);
if (creo == NULL) {
return 0;
}
if (object->isArmorObject()) {
PlayerManager* playerManager = creo->getZoneServer()->getPlayerManager();
playerManager->removeEncumbrancies(creo, cast<ArmorObject*>(object));
}
if (object->isTangibleObject()) {
TangibleObject* tano = cast<TangibleObject*>(object);
tano->removeSkillModsFrom(creo);
}
if (object->isInstrument()) {
if (creo->isPlayingMusic())
creo->stopEntertaining();
}
//this it to update the equipment list
//we need a DeltaVector with all the slotted objects it seems
/*CreatureObjectMessage6* msg6 = new CreatureObjectMessage6(creo);
creo->broadcastMessage(msg6, true, true);*/
if (object->isTangibleObject() && object->getArrangementDescriptorSize() != 0 && object->getArrangementDescriptor(0)->size() != 0) {
const String& arrangement = object->getArrangementDescriptor(0)->get(0); //CHK
if (arrangement != "mission_bag" && arrangement != "ghost" && arrangement != "bank") {
creo->removeWearableObject(object->asTangibleObject(), true);
}
}
if (object->isTangibleObject()) {
ManagedReference<TangibleObject*> tano = object->asTangibleObject();
tano->removeTemplateSkillMods(creo);
}
// Jedi stuff below.
PlayerObject* ghost = creo->getPlayerObject();
if (ghost && ghost->isJedi()) {
if (object->isRobeObject()) {
ghost->recalculateForcePower();
}
}
return ContainerComponent::notifyObjectRemoved(sceneObject, object, destination);
}
/**
* Is called when this object has been inserted with an object
* @param object object that has been inserted
*/
int PlayerContainerComponent::notifyObjectInserted(SceneObject* sceneObject, SceneObject* object) {
CreatureObject* creo = dynamic_cast<CreatureObject*>(sceneObject);
if (object->isArmorObject()) {
PlayerManager* playerManager = sceneObject->getZoneServer()->getPlayerManager();
playerManager->applyEncumbrancies(creo, cast<ArmorObject*>(object));
}
if (object->isTangibleObject()) {
TangibleObject* tano = cast<TangibleObject*>(object);
tano->applySkillModsTo(creo);
}
if (object->isInstrument() && creo->isEntertaining())
creo->stopEntertaining();
//this it to update the equipment list
//we need a DeltaVector with all the slotted objects it seems
/*CreatureObjectMessage6* msg6 = new CreatureObjectMessage6(creo);
creo->broadcastMessage(msg6, true, true);*/
if (object->isTangibleObject() && object->getArrangementDescriptorSize() != 0 && object->getArrangementDescriptor(0)->size() != 0) {
const String& arrangement = object->getArrangementDescriptor(0)->get(0);
if (arrangement != "mission_bag" && arrangement != "ghost" && arrangement != "bank") {
creo->addWearableObject(object->asTangibleObject(), true);
}
}
if (object->isTangibleObject()) {
ManagedReference<TangibleObject*> tano = object->asTangibleObject();
tano->addTemplateSkillMods(creo);
}
// Jedi stuff below.
PlayerObject* ghost = creo->getPlayerObject();
if (ghost && ghost->isJedi()) {
if (object->isRobeObject()) {
ghost->setForcePowerMax(creo->getSkillMod("jedi_force_power_max"));
} else if (object->isWeaponObject()) {
WeaponObject* weaponObject = cast<WeaponObject*>(object);
if (weaponObject->isJediWeapon()) {
VisibilityManager::instance()->increaseVisibility(creo, VisibilityManager::SABERVISMOD);
}
}
}
return ContainerComponent::notifyObjectInserted(sceneObject, object);
}
void WorldManager::createObjectForKnownPlayers(PlayerObjectSet* knownPlayers, Object* object)
{
PlayerObjectSet::iterator it = knownPlayers->begin();
while(it != knownPlayers->end())
{
PlayerObject* targetObject = (*it);
gMessageLib->sendCreateObject(object,targetObject);
targetObject->addKnownObjectSafe(object);
object->addKnownObjectSafe(targetObject);
++it;
}
}
void ObjectController::_handleDismissGroupMember(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
// make sure its a fully grouped player
if(player->getGroupId() == 0)
{
return;
}
// lets get the target player
message->setIndex(32);
PlayerObject* targetPlayer = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(message->getUint64()));
// if target is valid
if(targetPlayer == NULL || targetPlayer->getGroupId() != player->getGroupId())
{
gMessageLib->sendSystemMessage(player,L"Invalid Target.");
return;
}
// we advise the chat server about it
Message* newMessage;
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opIsmGroupDismissGroupMember);
gMessageFactory->addUint32(targetPlayer->getAccountId());
newMessage = gMessageFactory->EndMessage();
player->getClient()->SendChannelA(newMessage,player->getAccountId(),CR_Chat,2);
}
void ObjectController::_handleWaypoint(uint64 targetId, Message* message, ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
Datapad* datapad = player->getDataPad();
BString waypoint_data;
glm::vec3 waypoint_position;
// Before anything else verify the datapad can hold another waypoint.
if(! datapad->getCapacity()) {
gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "too_many_waypoints"), player);
return;
}
// Read in any waypoint data that may have been sent:
// [SYNTAX] /waypoint <x> <z> or /waypoint <x> <y> <z>
message->getStringUnicode16(waypoint_data);
// Check and see if any parameters were passed to the /waypoint command. For
// immediate purposes the length can be used to tell if anything or nothing was passed.
if (waypoint_data.getLength()) {
int count = swscanf(waypoint_data.getUnicode16(), L"%f %f %f", &waypoint_position.x, &waypoint_position.y, &waypoint_position.z);
// If there are an invalid number of items then disregard and notify the player of the correct
// format for the /waypoint command.
if (count < 2 || count > 3) {
gMessageLib->SendSystemMessage(L"[SYNTAX] /waypoint <x> <z> or /waypoint <x> <y> <z>", player);
return;
}
// If the item count is 2 it means no y value was set in the /waypoint command so
// update the waypoint_position data values accordingly.
if (count == 2) {
waypoint_position.z = waypoint_position.y;
waypoint_position.y = 0;
}
// Validate the position values.
if (waypoint_position.x < -8192 || waypoint_position.x > 8192 ||
waypoint_position.y < -500 || waypoint_position.y > 500 ||
waypoint_position.z < -8192 || waypoint_position.z > 8192) {
gMessageLib->SendSystemMessage( L"[SYNTAX] Invalid range for /waypoint. x = -8192/8192 y = -500/500 z = -8192/8192", player);
return;
}
} else {
// If no parameters were passed to the /waypoint command use the current world position.
waypoint_position = player->getWorldPosition();
}
datapad->requestNewWaypoint("Waypoint", waypoint_position, static_cast<uint16>(gWorldManager->getZoneId()), Waypoint_blue);
}
void ObjectController::_findInRangeObjectsOutside(bool updateAll)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
//scale down viewing range when busy
float viewingRange = _GetMessageHeapLoadViewingRange();
// query the rtree for non moving objects/objects in buildings
// ObjectSet inRangeObjects;
// mSI->getObjectsInRange(player,&inRangeObjects,(ObjType_Player | ObjType_Tangible | ObjType_Creature | ObjType_NPC | ObjType_Building),viewingRange);
// Using intersectsWithQuery(..)
// NOTE: THIS USEAGE OF intersectsWithQuery(..) MUST BE CHECKED, SINCE IT SEEMS THAT WE GET TO MUCH / TO MANY OBJECTS !!!
// mSI->getObjectsInRangeEx(player,&inRangeObjects,(ObjType_Player | ObjType_Tangible | ObjType_Creature | ObjType_NPC | ObjType_Building),viewingRange);
// Make Set ready,
mInRangeObjects.clear();
mObjectSetIt = mInRangeObjects.begin(); // Will point to end of Set
if(player->getSubZoneId())
{
if(QTRegion* region = gWorldManager->getQTRegion(player->getSubZoneId()))
{
Anh_Math::Rectangle qRect = Anh_Math::Rectangle(player->mPosition.x - viewingRange,player->mPosition.z - viewingRange,viewingRange * 2,viewingRange * 2);
// We need to find moving creatures also...
region->mTree->getObjectsInRange(player,&mInRangeObjects,ObjType_Player | ObjType_NPC | ObjType_Creature | ObjType_Lair , &qRect);
}
}
if (updateAll)
{
// Doing this because we need the players from inside buildings too.
mSI->getObjectsInRangeEx(player,&mInRangeObjects,(ObjType_Player | ObjType_NPC | ObjType_Creature), viewingRange);
// This may be good when we standstill.
mSI->getObjectsInRange(player,&mInRangeObjects,(ObjType_Tangible | ObjType_Building | ObjType_Lair | ObjType_Structure), viewingRange);
}
/*
{
// This may be good when we are moving around outside.
mSI->getObjectsInRange(player,&mInRangeObjects,(ObjType_Player | ObjType_NPC | ObjType_Creature | ObjType_Tangible | ObjType_Building), viewingRange);
}
*/
// Update the iterator to start of Set.
mObjectSetIt = mInRangeObjects.begin();
}
void GroupObjectImplementation::disband() {
// this locked
ManagedReference<ChatRoom* > chat = chatRoom;
for (int i = 0; i < groupMembers.size(); i++) {
if (groupMembers.get(i) == NULL) {
continue;
}
Reference<CreatureObject*> groupMember = getGroupMember(i).castTo<CreatureObject*>();
try {
Locker clocker(groupMember, _this.get());
if (groupMember->isPlayerCreature()) {
if (chat != NULL) {
chat->removePlayer(groupMember, false);
chat->sendDestroyTo(groupMember);
ChatRoom* room = chat->getParent();
room->sendDestroyTo(groupMember);
}
if (groupMember->getPlayerObject() != NULL) {
PlayerObject* ghost = groupMember->getPlayerObject();
ghost->removeWaypointBySpecialType(WaypointObject::SPECIALTYPE_NEARESTMISSIONFORGROUP);
}
}
groupMember->updateGroup(NULL);
//play->updateGroupId(0);
//sendClosestWaypointDestroyTo(play);
//removeSquadLeaderBonuses(play);
} catch (Exception& e) {
System::out << "Exception in GroupObject::disband(Player* player)\n";
}
}
destroyChatRoom();
if (hasSquadLeader())
removeGroupModifiers();
groupMembers.removeAll();
//The mission waypoints should not be destroyed. They belong to the players.
//missionWaypoints.removeAll();
}
void CampRegion::applyWoundHealing(Object* object)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(object);
//Make sure it's a player.
if(player == NULL)
return;
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
for(uint8 i = HamBar_Health; i < HamBar_Willpower;i++) {
ham->RemoveWound(player->GetCreature(), i, 1);
}
}
bool WorldManager::_handleDisconnectUpdate(uint64 callTime,void* ref)
{
PlayerList::iterator it = mPlayersToRemove.begin();
while(it != mPlayersToRemove.end())
{
PlayerObject* playerObject = (*it);
// we timed out, so save + remove it
if(--*(playerObject->getDisconnectTime()) <= 0 && playerObject->isLinkDead())
{
// reset link dead state
playerObject->togglePlayerFlagOff(PlayerFlag_LinkDead);
playerObject->setConnectionState(PlayerConnState_Destroying);
//remove the player out of his group - if any
GroupObject* group = gGroupManager->getGroupObject(playerObject->getGroupId());
if(group)
{
group->removePlayer(playerObject->getId());
}
//asynch save
savePlayer(playerObject->getAccountId(),true,WMLogOut_LogOut);
it = mPlayersToRemove.erase(it);
}
else
++it;
}
return(true);
}
//=============================================================================
bool Inventory::itemExist(uint32 familyId, uint32 typeId)
{
bool found = false;
ObjectIDList::iterator invObjectIt = getObjects()->begin();
// Items inside inventory and child objects.
while (invObjectIt != getObjects()->end())
{
Object* object = getObjectById(*invObjectIt);
Item* item = dynamic_cast<Item*>(object);
if (item)
{
if ((item->getItemFamily() == familyId) && (item->getItemType() == typeId))
{
found = true;
break;
}
}
invObjectIt++;
}
if (!found)
{
// Items equipped by the player.
PlayerObject* player = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(this->getParentId()));
if(!player)
return found;
ObjectList* objList = player->getEquipManager()->getEquippedObjects();
ObjectList::iterator equippedObjectIt = objList->begin();
while (equippedObjectIt != objList->end())
{
Object* object = (*equippedObjectIt);
Item* item = dynamic_cast<Item*>(object);
if (item)
{
if ((item->getItemFamily() == familyId) && (item->getItemType() == typeId))
{
found = true;
break;
}
}
equippedObjectIt++;
}
delete objList;
}
return found;
}
void GroupObjectImplementation::removeMember(SceneObject* member) {
ManagedReference<SceneObject*> obj = member;
for (int i = 0; i < groupMembers.size(); i++) {
SceneObject* scno = groupMembers.get(i).get().get();
if (scno == member) {
GroupObjectDeltaMessage6* grp = new GroupObjectDeltaMessage6(_this.get());
grp->startUpdate(1);
groupMembers.remove(i, grp);
grp->close();
broadcastMessage(grp);
}
}
if (member->isPlayerCreature()) {
// Remove member's pets
CreatureObject* playerCreature = cast<CreatureObject*>(member);
RemovePetsFromGroupTask* task = new RemovePetsFromGroupTask(playerCreature, _this.get());
task->execute();
//Close any open Group SUIs.
ManagedReference<PlayerObject*> ghost = playerCreature->getPlayerObject();
if (ghost != NULL) {
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_RULE);
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_CHANGED);
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_PICK_LOOTER);
}
//Reset Master Looter if needed.
if (getMasterLooterID() == playerCreature->getObjectID()) {
ManagedReference<CreatureObject*> groupLeader = (getLeader()).castTo<CreatureObject*>();
GroupManager::instance()->changeMasterLooter(_this.get(), groupLeader, false);
}
if (hasSquadLeader()) {
removeGroupModifiers(playerCreature);
}
if (playerCreature->getPlayerObject() != NULL) {
PlayerObject* ghost = playerCreature->getPlayerObject();
ghost->removeWaypointBySpecialType(WaypointObject::SPECIALTYPE_NEARESTMISSIONFORGROUP);
}
scheduleUpdateNearestMissionForGroup(playerCreature->getPlanetCRC());
}
calcGroupLevel();
}
uint64 ScriptSupport::getParentOfTarget(uint64 playerId)
{
uint64 parentId = 0;
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(playerId));
if (playerObject)
{
uint64 targetId = playerObject->getTargetId();
Object* object = dynamic_cast<Object*>(gWorldManager->getObjectById(targetId));
if (object)
{
parentId = object->getParentId();
}
}
return parentId;
}
void WorldManager::destroyObjectForKnownPlayers(Object* object)
{
PlayerObjectSet* knownPlayers = object->getKnownPlayers();
PlayerObjectSet::iterator it = knownPlayers->begin();
while(it != knownPlayers->end())
{
PlayerObject* targetObject = (*it);
gMessageLib->sendDestroyObject(object->getId(),targetObject);
targetObject->removeKnownObject(object);
++it;
}
object->destroyKnownObjects();
}
void ScavengerDroidImplementation::sendGameInstructionsSUI(CreatureObject* player) {
PlayerObject* ghost = player->getPlayerObject();
if (ghost == NULL)
return;
ManagedReference<SuiMessageBox*> msgBox = new SuiMessageBox(player, SuiWindowType::SCAVENGER_INFO);
msgBox->setPromptTitle("@event_perk:scavenger_instruction"); // Instructions
msgBox->setPromptText("@event_perk:scavenger_game_instruction"); // Choose "View Item List" to see what items you need to find. As you find items, show me the item by dragging and dropping them onto me. The first person to find all of the items wins!
msgBox->setUsingObject(_this.getReferenceUnsafeStaticCast());
msgBox->setForceCloseDistance(32.f);
ghost->addSuiBox(msgBox);
player->sendMessage(msgBox->generateMessage());
}
void JukeboxImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
ManagedReference<CreatureObject*> strongOwner = owner.get();
if (strongOwner != NULL) {
Locker clocker(strongOwner, _this.getReferenceUnsafeStaticCast());
PlayerObject* ghost = strongOwner->getPlayerObject();
if (ghost != NULL) {
ghost->removeEventPerk(_this.getReferenceUnsafeStaticCast());
}
}
TangibleObjectImplementation::destroyObjectFromDatabase(destroyContainedObjects);
}
void ScavengerDroidImplementation::sendSetupInstructionsSUI(CreatureObject* player) {
PlayerObject* ghost = player->getPlayerObject();
if (ghost == NULL)
return;
ManagedReference<SuiMessageBox*> msgBox = new SuiMessageBox(player, SuiWindowType::SCAVENGER_INFO);
msgBox->setPromptTitle("@event_perk:scavenger_instruction"); // Instructions
msgBox->setPromptText("@event_perk:scavenger_setup_instruction"); // Drag and drop items onto me so I can look at them and I will add them to the scavenger hunt list. You can look at the items you've added by selecting "View List". If you've made a mistake, select "Reset" to start again. When you are ready, choose "Start Game" to begin.
msgBox->setUsingObject(_this.getReferenceUnsafeStaticCast());
msgBox->setForceCloseDistance(32.f);
ghost->addSuiBox(msgBox);
player->sendMessage(msgBox->generateMessage());
}
void ChatRoomImplementation::removeAllPlayers() {
Locker locker(_this.get());
for (int i = 0; i < playerList.size(); i++) {
ManagedReference<CreatureObject*> player = playerList.get(i);
Locker clocker(player, _this.get());
PlayerObject* ghost = player->getPlayerObject();
ghost->removeChatRoom(_this.get());
}
playerList.removeAll();
}
int CoaMessageFragmentMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (!player->isPlayerCreature()) {
return 0;
}
if (!sceneObject->isASubChildOf(player)) {
player->sendSystemMessage("@encoded_disk/message_fragment:sys_not_in_inv"); // The disk can't be used unless it is in your inventory!
return 0;
}
TangibleObject* fragment = cast<TangibleObject*>(sceneObject);
if (fragment == NULL) {
return 0;
}
PlayerObject* ghost = player->getPlayerObject();
if (ghost == NULL) {
return 0;
}
if (selectedID == 20) {
String title = fragment->getCustomObjectName().toString();
StringBuffer body;
body << "@encoded_disk/message_fragment:text_event";
if (title.contains("Imperial")) {
body << "imp1";
} else if (title.contains("Rebel")) {
body << "reb1";
} else {
return 0;
}
ManagedReference<SuiMessageBox*> box = new SuiMessageBox(player, SuiWindowType::COA_MESSAGE_FRAGMENT);
box->setCallback(new CoaMessageFragmentSuiCallback(player->getZoneServer()));
box->setPromptTitle(title);
box->setPromptText(body.toString());
box->setUsingObject(fragment);
box->setCancelButton(true, "@close");
box->setOkButton(true, "@encoded_disk/message_fragment:combine");
ghost->addSuiBox(box);
player->sendMessage(box->generateMessage());
return 0;
}
return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID);
}
//======================================================================================================================
//
// Modifies the Admin List
//
void ObjectController::_handleTransferStructure(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
// requirement we have the structure targeted AND give the name of the recipient on the commandline
// OR we have the recipient targeted and stand NEXT to the structure were about to transfer
//do we have a valid donor ?
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if(!player)
{
return;
}
// is the player online and near 30m ?
// we get the players id as targetid if yes, otherwise we get the name as string
// however, we do not want players that are not online
//now get the target player
PlayerObject* recipient = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(targetId));
if(!recipient)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "no_transfer_target"), player);
return;
}
//do we have a valid structure ??? check our target first
uint64 id = player->getTargetId();
Object* object = gWorldManager->getObjectById(id);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
// we need to get the nearest structure that we own
// for now dustoff
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
//is the structure in Range???
float fTransferDistance = gWorldConfig->getConfiguration<float>("Player_Transfer_Structure_Distance",(float)8.0);
if(glm::distance(player->mPosition, structure->mPosition) > fTransferDistance)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
StructureAsyncCommand command;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
command.RecipientId = recipient->getId();
command.PlayerStr = recipient->getFirstName().getAnsi();
command.Command = Structure_Command_TransferStructure;
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->getFirstName().getAnsi(),"ADMIN",command);
}
void ChatRoomImplementation::removePlayer(CreatureObject* player, bool doLock) {
Locker locker(player);
PlayerObject* ghost = player->getPlayerObject();
ghost->removeChatRoom(_this.get());
locker.release();
Locker locker2(_this.get());
playerList.drop(player->getFirstName());
ChatOnLeaveRoom* msg = new ChatOnLeaveRoom(_this.get(), player);
player->sendMessage(msg);
}
void ObjectController::_handleDisband(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if(player->getGroupId() == 0)
{
return;
}
// we advise the chat server about the disband
Message* newMessage;
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opIsmGroupDisband);
newMessage = gMessageFactory->EndMessage();
player->getClient()->SendChannelA(newMessage,player->getAccountId(),CR_Chat,2);
}
void CraftingManager::handleCraftExperiment(Object* object, Message* message)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(object);
CraftingSession* session = player->getCraftingSession();
uint8 counter = message->getUint8();
uint32 propCount = message->getUint32();
std::vector<std::pair<uint32,uint32> > properties;
if(!session || player->getCraftingStage() != 3)
return;
for(uint32 i = 0; i < propCount; i++)
properties.push_back(std::make_pair(message->getUint32(),message->getUint32()));
session->experiment(counter,properties);
}
void SuiManager::sendTransferBox(SceneObject* usingObject, SceneObject* player, const String& title, const String& text, LuaObject& optionsAddFrom, LuaObject& optionsAddTo, const String& screenplay, const String& callback) {
if (usingObject == NULL)
return;
if (player == NULL || !player->isCreatureObject())
return;
CreatureObject* creature = cast<CreatureObject*>(player);
PlayerObject* playerObject = creature->getPlayerObject();
if (playerObject != NULL) {
ManagedReference<SuiTransferBox*> box = NULL;
box = new SuiTransferBox(creature, 0x00);
if(optionsAddFrom.isValidTable()){
String optionAddFromTextString = optionsAddFrom.getStringAt(1);
String optionAddFromStartingString = optionsAddFrom.getStringAt(2);
String optionAddFromRatioString = optionsAddFrom.getStringAt(3);
box->addFrom(optionAddFromTextString,
optionAddFromStartingString,
optionAddFromStartingString, optionAddFromRatioString);
optionsAddFrom.pop();
}
if(optionsAddTo.isValidTable()){
String optionAddToTextString = optionsAddTo.getStringAt(1);
String optionAddToStartingString = optionsAddTo.getStringAt(2);
String optionAddToRatioString = optionsAddTo.getStringAt(3);
box->addTo(optionAddToTextString,
optionAddToStartingString,
optionAddToStartingString, optionAddToRatioString);
optionsAddTo.pop();
}
box->setCallback(new LuaSuiCallback(creature->getZoneServer(), screenplay, callback));
box->setPromptTitle(title);
box->setPromptText(text);
box->setUsingObject(usingObject);
box->setForceCloseDistance(32.f);
creature->sendMessage(box->generateMessage());
playerObject->addSuiBox(box);
}
}
void CharacterBuilderTerminalImplementation::grantGlowyBadges(CreatureObject* player) {
CharacterBuilderTerminalTemplate* terminalTemplate = dynamic_cast<CharacterBuilderTerminalTemplate*>(templateObject.get());
if (terminalTemplate == NULL)
return;
PlayerObject* ghost = player->getPlayerObject();
if (ghost == NULL)
return;
Vector<int> ids = terminalTemplate->getGlowyBadgeIds();
for (int i = 0; i < ids.size(); i++) {
ghost->awardBadge(ids.get(i));
}
}
void EntertainingSessionImplementation::addEntertainerBuffStrength(CreatureObject* creature, int performanceType, float strength) {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
int buffStrength = getEntertainerBuffStrength(creature, performanceType);
float newBuffStrength = buffStrength + strength;
float maxBuffStrength = 0.0f; //cap based on enhancement skill
if(dancing) {
maxBuffStrength = (float) entertainer->getSkillMod("healing_dance_mind");
}
else if (playingMusic) {
maxBuffStrength = (float) entertainer->getSkillMod("healing_music_mind");
}
if(maxBuffStrength > 125.0f)
maxBuffStrength = 125.0f; //cap at 125% power
float factionPerkStrength = entertainer->getSkillMod("private_faction_buff_mind");
ManagedReference<BuildingObject*> building = entertainer->getRootParent().get().castTo<BuildingObject*>();
if (building != NULL && factionPerkStrength > 0 && building->isPlayerRegisteredWithin(entertainer->getObjectID())) {
unsigned int buildingFaction = building->getFaction();
unsigned int entFaction = entertainer->getFaction();
PlayerObject* ghost = entertainer->getPlayerObject();
if (ghost != NULL && entFaction != 0 && entFaction == buildingFaction && ghost->getFactionStatus() == FactionStatus::OVERT) {
maxBuffStrength += factionPerkStrength;
}
}
//add xp based on % added to buff strength
if (newBuffStrength < maxBuffStrength) {
healingXp += strength;
}
else {
healingXp += maxBuffStrength - buffStrength;
newBuffStrength = maxBuffStrength;
}
//newBuffStrength = newBuffStrength;
setEntertainerBuffStrength(creature, performanceType, newBuffStrength);
}
void GroupManager::_processIsmInviteRequest(Message* message)
{
PlayerObject* sender = gWorldManager->getPlayerByAccId(message->getUint32()); // the player who sent the invite
PlayerObject* target = gWorldManager->getPlayerByAccId(message->getUint32()); // the player who will recieve it
if(sender == NULL || target == NULL)
{
gLogger->logMsg("GroupManager::_processIsmInviteRequest PlayerAccId not found");
return;
}
//target->setGroupId(message->getUint64()); // the group id provided by the chatserver
gMessageLib->sendInviteSenderUpdateDeltasCreo6(sender->getId(),target);
}
