//======================================================================================================================
//
// 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 ?
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
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->GetCreature()->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->GetCreature()->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->GetCreature()->getFirstName();
command.Command = Structure_Command_TransferStructure;
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
//======================================================================================================================
//
// provides the harvester with the current resources
//
void ObjectController::_handleHarvesterGetResourceData(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if(!player)
{
return;
}
//do we have a valid structure ???
uint64 id = targetId;
Object* object = gWorldManager->getObjectById(id);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
//gMessageLib->sendSystemMessage(player,L"","player_structure","command_no_building");
return;
}
//is the structure in Range???
float fTransferDistance = gWorldConfig->getConfiguration<float>("Player_Structure_Operate_Distance",(float)10.0);
if(glm::distance(player->mPosition, structure->mPosition) > fTransferDistance)
{
DLOG(INFO) << " ObjectController::_handleHarvesterGetResourceData Structure not in Range";
return;
}
HarvesterObject* harvester = dynamic_cast<HarvesterObject*>(structure);
StructureAsyncCommand command;
command.Command = Structure_Command_GetResourceData;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->getFirstName().getAnsi(),"ADMIN",command);
return;
gMessageLib->sendHarvesterResourceData(structure,player);
DLOG(INFO) << " ObjectController::_handleHarvesterGetResourceData :: hino 7 baseline";
gMessageLib->sendBaselinesHINO_7(harvester,player);
//add the structure to the timer so the resource amounts are updated while we look at the hopper
//harvester->getTTS()->todo = ttE_UpdateHopper;
//harvester->getTTS()->playerId = player->getId();
//structure->getTTS()->projectedTime = 5000 + Anh_Utils::Clock::getSingleton()->getLocalTime();
//gStructureManager->addStructureforHopperUpdate(harvester->getId());
// this needs to be handled zoneserverside - otherwise the addition of a res will trigger a racecondition
// between the sql write query and the sql read please note that the harvesting itself happens through stored procedures
// and we cant keep the updatecounters synchronized
}
//======================================================================================================================
//
// Modifies the Admin List
//
void ObjectController::_handleNameStructure(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 ?
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if(!player)
{
return;
}
//do we have a valid structure ??? check our target first
uint64 id = player->GetCreature()->getTargetId();
Object* object = gWorldManager->getObjectById(id);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
//is the structure in Range???
float fTransferDistance = gWorldConfig->getConfiguration<float>("Player_Structure_Operate_Distance",(float)10.0);
if(glm::distance(player->GetCreature()->mPosition, structure->mPosition) > fTransferDistance)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
//find out where our structure is
BString dataStr;
message->getStringUnicode16(dataStr);
BString nameStr;
dataStr.convert(BSTRType_ANSI);
sscanf(dataStr.getAnsi(),"%s",nameStr.getAnsi());
if(nameStr.getLength() > 68)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "not_valid_name"), player);
return;
}
StructureAsyncCommand command;
command.Command = Structure_Command_RenameStructure;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
void WorldManager::savePlayer(uint32 accId,bool remove, WMLogOut mLogout, CharacterLoadingContainer* clContainer)
{
PlayerObject* playerObject = getPlayerByAccId(accId);
if(!playerObject) {
DLOG(INFO) << "WorldManager::savePlayer could not find player with AccId:" <<accId<<", save aborted.";
return;
}
// WMQuery_SavePlayer_Position is the query handler called by the buffmanager when all the buffcallbacks are finished
// we prepare the asynccontainer here already
WMAsyncContainer* asyncContainer = new(mWM_DB_AsyncPool.ordered_malloc()) WMAsyncContainer(WMQuery_SavePlayer_Position);
if(remove)
{
asyncContainer->mBool = true;
}
//clarify what handler we have to call after saving - if any
asyncContainer->mObject = playerObject;
asyncContainer->mLogout = mLogout;
asyncContainer->clContainer = clContainer;
switch (mLogout)
{
case WMLogOut_LogOut:
case WMLogOut_Char_Load:
mDatabase->executeSqlAsync(this,asyncContainer,"UPDATE characters SET parent_id=%"PRIu64",oX=%f,oY=%f,oZ=%f,oW=%f,x=%f,y=%f,z=%f,planet_id=%u,jedistate=%u WHERE id=%"PRIu64"",playerObject->getParentId()
,playerObject->mDirection.x,playerObject->mDirection.y,playerObject->mDirection.z,playerObject->mDirection.w
,playerObject->mPosition.x,playerObject->mPosition.y,playerObject->mPosition.z
,mZoneId,playerObject->getJediState(),playerObject->getId());
break;
case WMLogOut_No_LogOut:
case WMLogOut_Zone_Transfer:
//start by saving the buffs the buffmanager will deal with the buffspecific db callbacks and start the position safe at their end
//which will return its callback to the worldmanager
//if no buff was there to be saved we will continue directly
if(playerObject && playerObject->isConnected() && !playerObject->isBeingDestroyed())
{
if(!gBuffManager->SaveBuffsAsync(asyncContainer, this, playerObject, GetCurrentGlobalTick()))
{
// position save will be called by the buff callback if there is any buff
mDatabase->executeSqlAsync(this,asyncContainer,"UPDATE characters SET parent_id=%"PRIu64",oX=%f,oY=%f,oZ=%f,oW=%f,x=%f,y=%f,z=%f,planet_id=%u,jedistate=%u WHERE id=%"PRIu64"",playerObject->getParentId()
,playerObject->mDirection.x,playerObject->mDirection.y,playerObject->mDirection.z,playerObject->mDirection.w
,playerObject->mPosition.x,playerObject->mPosition.y,playerObject->mPosition.z
,mZoneId,playerObject->getJediState(),playerObject->getId());
}
}
break;
default:
DLOG(INFO) << "We should never get in here, make sure to call savePlayer with the enum WMLogOut";
}
}
void WorldManager::removePlayerfromAccountMap(uint64 playerID)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(gWorldManager->getObjectById(playerID));
if(!creature) {
LOG (error) << "WorldManager::removePlayerfromAccountMap : no player";
return;
}
PlayerObject* player = creature->GetGhost();
if(player) {
PlayerAccMap::iterator playerAccIt = mPlayerAccMap.find(player->getAccountId());
if(playerAccIt != mPlayerAccMap.end()) {
LOG(info) << "Player left [" << player->getId() << "] Total players on zone [" << (getPlayerAccMap()->size() -1) << "]";
mPlayerAccMap.erase(playerAccIt);
}
else
{
LOG(error) << "Error removing player from account map [" << player->getAccountId() << "]";
}
}
else
{
LOG(error) << "Error removing player from account map [" << player->getAccountId() << "]";
}
}
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);
}
void StructureManager::handleObjectReady(Object* object,DispatchClient* client)
{
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
gLogger->logMsg("StructureManager::handleObjectReady: No structure");
}
if(gWorldManager->getWMState() == WMState_Running)
{
// set timer for deletion of building fence
uint32 account = client->getAccountId();
PlayerObject* player = gWorldManager->getPlayerByAccId(account);
PlayerStructure* fence = gNonPersistantObjectFactory->requestBuildingFenceObject(structure->mPosition.x,structure->mPosition.y,structure->mPosition.z, player);
structure->getTTS()->todo = ttE_BuildingFence;
structure->getTTS()->buildingFence = fence->getId();
structure->getTTS()->playerId = player->getId();
structure->getTTS()->projectedTime = mBuildingFenceInterval + Anh_Utils::Clock::getSingleton()->getLocalTime();
gWorldManager->handleObjectReady(structure,player->getClient());
addStructureforConstruction(structure->getId());
}
else
{
gWorldManager->handleObjectReady(structure,NULL);
}
}
void MountObject::prepareCustomRadialMenu(CreatureObject* creature, uint8_t item_count) {
PlayerObject* player = creature->GetGhost();// dynamic_cast<PlayerObject*>(creature);
if (!player) {
// Verify the data passed in is what is expected. In debug mode the assert will
// trigger and crash the server.
assert(false && "MountObject::handleObjectMenuSelect - Menu preparation requested for a non-player object.");
return;
}
// Reset the radial menu with a new instance.
mRadialMenu.reset(new RadialMenu());
// Add the radial options for the custom menu.
mRadialMenu->addItem(1, 0, radId_examine, radAction_Default);
// Check to see if the player requesting the menu is the owner of the mount.
if(player->getId() == owner_) {
// Check to see if the player is mounted or not and display the appropriate exit/enter option.
if(player->checkIfMounted()) {
mRadialMenu->addItem(2, 0, radId_serverVehicleExit,radAction_Default, "@pet/pet_menu:menu_enter_exit");
} else {
mRadialMenu->addItem(2, 0, radId_serverVehicleEnter,radAction_Default, "@pet/pet_menu:menu_enter_exit");
}
mRadialMenu->addItem(3, 0, radId_vehicleStore,radAction_ObjCallback, "@pet/pet_menu:menu_store");
// @TODO: Check if near a garage then add repair
}
}
void WorldManager::savePlayerSync(uint32 accId,bool remove)
{
PlayerObject* playerObject = getPlayerByAccId(accId);
Ham* ham = playerObject->getHam();
mDatabase->destroyResult(mDatabase->executeSynchSql("UPDATE characters SET parent_id=%"PRIu64",oX=%f,oY=%f,oZ=%f,oW=%f,x=%f,y=%f,z=%f,planet_id=%u WHERE id=%"PRIu64"",playerObject->getParentId()
,playerObject->mDirection.x,playerObject->mDirection.y,playerObject->mDirection.z,playerObject->mDirection.w
,playerObject->mPosition.x,playerObject->mPosition.y,playerObject->mPosition.z
,mZoneId,playerObject->getId()));
mDatabase->destroyResult(mDatabase->executeSynchSql("UPDATE character_attributes SET health_current=%u,action_current=%u,mind_current=%u"
",health_wounds=%u,strength_wounds=%u,constitution_wounds=%u,action_wounds=%u,quickness_wounds=%u"
",stamina_wounds=%u,mind_wounds=%u,focus_wounds=%u,willpower_wounds=%u,battlefatigue=%u,posture=%u,moodId=%u,title=\'%s\'"
",character_flags=%u,states=%"PRIu64",language=%u, group_id=%"PRIu64" WHERE character_id=%"PRIu64"",
ham->mHealth.getCurrentHitPoints() - ham->mHealth.getModifier(), //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
ham->mAction.getCurrentHitPoints() - ham->mAction.getModifier(), //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
ham->mMind.getCurrentHitPoints() - ham->mMind.getModifier(), //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
ham->mHealth.getWounds(),
ham->mStrength.getWounds(),
ham->mConstitution.getWounds(),
ham->mAction.getWounds(),
ham->mQuickness.getWounds(),
ham->mStamina.getWounds(),
ham->mMind.getWounds(),
ham->mFocus.getWounds(),
ham->mWillpower.getWounds(),
ham->getBattleFatigue(),
playerObject->states.getPosture(),
playerObject->getMoodId(),
playerObject->getTitle().getAnsi(),
playerObject->getPlayerFlags(),
playerObject->states.getAction(),
playerObject->getLanguage(),
playerObject->getGroupId(),
playerObject->getId()));
gBuffManager->SaveBuffs(playerObject, GetCurrentGlobalTick());
if(remove)
destroyObject(playerObject);
}
//======================================================================================================================
//
// Discards the contents of a harvesters Hopper
//
void ObjectController::_handleDiscardHopper(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if(!player)
{
return;
}
//do we have a valid structure ???
uint64 id = targetId;
Object* object = gWorldManager->getObjectById(id);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
//gMessageLib->sendSystemMessage(player,L"","player_structure","command_no_building");
return;
}
//is the structure in Range???
float fTransferDistance = gWorldConfig->getConfiguration<float>("Player_Structure_Operate_Distance",(float)10.0);
if(glm::distance(player->GetCreature()->mPosition, structure->mPosition) > fTransferDistance)
{
return;
}
StructureAsyncCommand command;
command.Command = Structure_Command_DiscardHopper;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
void CampRegion::onObjectEnter(Object* object) {
if (object->getType() != ObjType_Player) {
return;
}
PlayerObject* visitor = dynamic_cast<PlayerObject*>(object);
if (!visitor) {
return;
}
if (!addVisitor(visitor)) {
return;
}
auto it = std::find_if(links.begin(), links.end(), [=] (campLink* link) {
return link->objectID == visitor->getId();
});
if (it != links.end()) {
campLink* temp = new campLink;
temp->objectID = visitor->getId();
temp->lastSeenTime = gWorldManager->GetCurrentGlobalTick();
temp->tickCount = 0;
links.push_back(temp);
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(mOwnerId));
if (owner && (owner->getId() != visitor->getId())) {
std::string text = "You have entered " + this->getCampOwnerName() + "'s camp.";
gMessageLib->SendSystemMessage(std::wstring(text.begin(), text.end()).c_str(), visitor);
} else {
//ensure it's not time to destroy the camp
mAbandoned = false;
}
}
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);
}
void ObjectController::_handleRemoveFriend(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if(player->getContactListUpdatePending())
return;
else
player->setContactListUpdatePending(true);
string friendName;
int8 sql[1024],end[16],*sqlPointer;
message->getStringUnicode16(friendName);
friendName.convert(BSTRType_ANSI);
if(!friendName.getLength())
{
player->setContactListUpdatePending(false);
return;
}
if(player->isConnected())
gMessageLib->sendHeartBeat(player->getClient());
friendName.toLower();
if(!player->checkFriendList(friendName.getCrc()))
{
player->setContactListUpdatePending(false);
return;
}
ObjControllerAsyncContainer* asyncContainer = new(mDBAsyncContainerPool.malloc()) ObjControllerAsyncContainer(OCQuery_RemoveFriend);
asyncContainer->mString = friendName.getAnsi();
sprintf(sql,"SELECT sf_removeFriend(%"PRIu64",'",player->getId());
sprintf(end,"')");
sqlPointer = sql + strlen(sql);
sqlPointer += mDatabase->Escape_String(sqlPointer,friendName.getAnsi(),friendName.getLength());
strcat(sql,end);
mDatabase->ExecuteSqlAsync(this,asyncContainer,sql);
}
void ObjectController::_handleMount(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
// The very idea with using ID's instead of object refs are that you can TEST them without using the object itself.
// And some parameter validation...
if (targetId == 0)
{
DLOG(info) << "ObjectController::_handleMount : Cannot find vehicle ID :(";
return;
}
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if (player && player->getMount() && (player->getParentId() == 0))
{
// Do we have a valid target?
if (!player->checkIfMounted())
{
// verify its player's mount
MountObject* pet = dynamic_cast<MountObject*>(gWorldManager->getObjectById(targetId));
if (pet && (pet->owner() == player->getId()))
{
// get the mount Vehicle object by the id (Creature object id - 1 )
if(VehicleController* vehicle = dynamic_cast<VehicleController*>(gWorldManager->getObjectById(pet->controller())))
{
//The /mount command can work up to 32m on live
if(glm::distance(vehicle->body()->mPosition, player->mPosition) <= 32) {
//change locomotion
vehicle->MountPlayer();
} else {
gMessageLib->SendSystemMessage(L"Your target is too far away to mount.", player);
}
}
else
{
DLOG(info) << "ObjectController::_handleMount : Cannot find vehicle";
}
}
} else {
gMessageLib->SendSystemMessage(L"You cannot mount this because you are already mounted.", player);
}
}
}
void ObjectController::_handleSetBiography(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
BString bio;
int8 sql[5000],end[64],*sqlPointer;
message->getStringUnicode16(bio);
player->setBiography(bio);
bio.convert(BSTRType_ANSI);
sprintf(sql,"UPDATE %s.character_biography SET biography ='",mDatabase->galaxy());
sprintf(end,"' WHERE character_id = %" PRIu64 "",player->getId());
sqlPointer = sql + strlen(sql);
sqlPointer += mDatabase->escapeString(sqlPointer,bio.getAnsi(),bio.getLength());
strcat(sql,end);
mDatabase->executeAsyncSql(sql);
}
void ObjectController::_handleDismount(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
// The very idea with using ID's instead of object refs are that you can TEST them without using the object itself.
// And some parameter validation...
PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
if (player && player->getMount() && (player->getParentId() == 0))
{
if (player->checkIfMounted())
{
// verify its player's mount
MountObject* pet = NULL;
if (targetId == 0)
{
// No object targeted, assume the one we are riding. - what else should we dismount ???
pet = player->getMount();
}
else
{
pet = dynamic_cast<MountObject*>(gWorldManager->getObjectById(targetId));
}
if (pet && (pet->owner() == player->getId()))
{
// get the pets controller for a swoop its the vehicle
if(VehicleController* vehicle = dynamic_cast<VehicleController*>(gWorldManager->getObjectById(pet->controller())))
{
vehicle->DismountPlayer();
}
}
}
else
{
gMessageLib->SendSystemMessage(L"You are not mounted to perform this action.", player);
}
}
}
void CampRegion::onObjectEnter(Object* object)
{
if(object->getParentId() == mParentId)
{
//PlayerObject* player = (PlayerObject*)object;
this->addKnownObjectSafe(object);
object->addKnownObjectSafe(this);
VisitorSet::iterator it = mVisitorSet.find(object->getId());
if(it == mVisitorSet.end())
mVisitorSet.insert(object->getId());
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(mOwnerId));
if(owner && (owner->getId() != object->getId()))
{
PlayerObject* player = dynamic_cast<PlayerObject*>(object);
int8 text[64];
sprintf(text,"You have entered %s's camp",this->getCampOwnerName().getAnsi());
string uT = text;
uT.convert(BSTRType_Unicode16);
gMessageLib->sendSystemMessage(player, uT);
}
else
{
//ensure it's not time to destroy the camp
mAbandoned = false;
//gLogger->logMsg("ENTERED CAMP", BACKGROUND_RED);
}
}
}
void VehicleController::Call() {
if(body_) {
assert(false && "void Vehicle::call() body already exists");
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
if(owner->checkIfMountCalled()) {
LOG(info) << "VehicleController::Call : body already in world " << this->getId();
return;
}
if(!owner->isConnected() || owner->GetCreature()->isDead() || owner->GetCreature()->isIncapacitated()) {
LOG(info) << "VehicleController::Call : owner statecheck fail for " << this->getId();
return;
}
body_ = new MountObject();
BString cust;
cust.initRawBSTR((int8*)Swoop_Customization, BSTRType_ANSI);
body_->setCustomizationStr("");//cust.getAnsi());
body_->setCreoGroup(CreoGroup_Vehicle);
body_->setTypeOptions(0x1080);
body_->setMoodId(0);
body_->setCL(0);
body_->setId(mId + 1); // Vehicles are created by the VehicleControllerFactory with +2 step for IDs
body_->set_controller(this->getId());
body_->set_owner(owner->getId());
body_->setParentId(0);
body_->SetTemplate(mPhysicalModel);
body_->setSpeciesGroup(mNameFile.getAnsi());
body_->setSpeciesString(mName.getAnsi());
body_->SetPosture(0);
body_->setScale(1.0f);
std::string con = this->getAttribute<std::string>("condition");
uint32 health_current = atoi(con.substr(0,con.find_first_of("/")).c_str());
uint32 health_max = atoi(con.substr(con.find_first_of("/")+1,con.find_first_of("/")).c_str());
for(int8 i = 0; i<9;i++) {
body_->InitStatBase(0);
body_->InitStatCurrent(0);
body_->InitStatMax(0);
body_->InitStatWound(0);
}
body_->InitStatCurrent(HamBar_Health, health_current);
body_->InitStatMax(HamBar_Health, health_max);
owner->setMount(body_);
owner->setMounted(false);
owner->setMountCalled(false);
// Set default direction and position for the body.
body_->mDirection = owner->GetCreature()->mDirection;
body_->mPosition = owner->GetCreature()->mPosition;
// Move it forward 2 meters
body_->moveForward(2);
auto terrain = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::terrain::TerrainService>("TerrainService");
gObjectManager->LoadSlotsForObject(body_);
body_->mPosition.y = terrain->GetHeight(gWorldManager->getZoneId(), body_->mPosition.x,body_->mPosition.z) + 0.3;
// Finally rotate it perpendicular to the player.
body_->rotateRight(90.0f);
// add to world
if(!gWorldManager->addObject(body_)) {
DLOG(info) << "void Vehicle::call() creating vehicle with id "<<body_->getId()<<" failed : couldnt add to world";
SAFE_DELETE(body_);
return;
}
auto permissions_objects_ = gObjectManager->GetPermissionsMap();
body_->SetPermissions(permissions_objects_.find(swganh::object::RIDEABLE_PERMISSION)->second.get());//CREATURE_PERMISSION
//currently done by gWorldManager->addObject(body_)
//gSpatialIndexManager->createInWorld(body_);
gMessageLib->sendUpdateTransformMessage(body_);
owner->setMountCalled(true);
return;
}
//======================================================================================================================
//
// rotates an item 90d to right
//
void ObjectController::HandleItemRotateRight_(
uint64 targetId,
Message* message,
ObjectControllerCmdProperties* cmdProperties) {
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if (!player) {
assert(false && "ObjectController::HandleItemRotateRight_ Player not found");
return;
}
// Verify that there was a target passed.
if (!targetId) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
Object* object = gWorldManager->getObjectById(targetId);
if(!object) {
assert(false && "ObjectController::HandleItemRotateRight_ item not found");
return;
}
// Verify that the item and player are in the same structure.
// Verify that the item and player are in the same structure.
CellObject* playerCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(player->getParentId()));
if(!playerCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
uint64 playerStructure = playerCell->getParentId();
CellObject* objectCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(object->getParentId()));
if(!objectCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
uint64 objectStructure = objectCell->getParentId();
if (objectStructure != playerStructure) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
// Verify that the player has appropriate rights on this structure.
if (playerCell) {
if (BuildingObject* building = dynamic_cast<BuildingObject*>(gWorldManager->getObjectById(playerCell->getParentId()))) {
if (!building->getAdminData().check_admin(player->getId())) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "admin_move_only"), player);
return;
}
} else {
assert(false && "ObjectController::HandleItemRotateRight_ no structure");
return;
}
} else {
//were just outside
return;
}
// Rotate the object 90 degree's to the right
object->rotateRight(ROTATE_INCREMENT);
gMessageLib->sendDataTransformWithParent053(object);
object->updateWorldPosition();
}
//======================================================================================================================
//
// Modifies the Admin List
//
void ObjectController::_handleModifyPermissionList(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if(!player)
{
DLOG(info) << " ObjectController::_handleModifyPermissionList Player not found";
return;
}
//find out where our structure is
BString dataStr;
message->getStringUnicode16(dataStr);
BString playerStr,list,action;
dataStr.convert(BSTRType_ANSI);
int8 s1[64],s2[32],s3[32];
sscanf(dataStr.getAnsi(),"%32s %16s %16s",s1, s2, s3);
playerStr = s1;
list = s2;
action = s3;
if(playerStr.getLength() > 40)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "permission_40_char"), player);
return;
}
//TODO is target a structure?? used when using the commandline option
uint64 id = player->GetCreature()->getTargetId();
Object* object = gWorldManager->getObjectById(id);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
//if we have no structure that way, see whether we have a structure were we just used the adminlist
if(!structure)
{
id = player->getStructurePermissionId();
Object* object = gWorldManager->getObjectById(id);
structure = dynamic_cast<PlayerStructure*>(object);
}
if(!structure)
{
return;
}
//is the structure in Range???
float fAdminListDistance = gWorldConfig->getConfiguration<float>("Player_Admin_List_Distance",(float)32.0);
if(player->getParentId())
{
if(CellObject* cell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(player->getParentId())))
{
if(HouseObject* house = dynamic_cast<HouseObject*>(gWorldManager->getObjectById(cell->getParentId())))
{
if(house->getId() != structure->getId())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
}
}
}
else if(glm::distance(player->GetCreature()->mPosition, structure->mPosition) > fAdminListDistance)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "command_no_building"), player);
return;
}
player->setStructurePermissionId(0);
StructureAsyncCommand command;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
command.List = list;
command.PlayerStr = playerStr.getAnsi();
if(action == "add")
{
command.Command = Structure_Command_AddPermission;
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
//addNametoPermissionList(command.StructureId, command.PlayerId, command.PlayerStr, command.List);
}
if(action == "remove")
{
command.Command = Structure_Command_RemovePermission;
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
}
void ObjectController::handleResourceEmptyHopper(Message* message)
{
uint64 playerId;
uint64 harvesterId;
message->getUint64(playerId);
message->getUint64(harvesterId);
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if(!player)
{
return;
}
//do we have a valid structure ???
Object* object = gWorldManager->getObjectById(harvesterId);
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(object);
if(!structure)
{
//gMessageLib->sendSystemMessage(player,L"","player_structure","command_no_building");
return;
}
//is the structure in Range???
float fTransferDistance = gWorldConfig->getConfiguration<float>("Player_Structure_Operate_Distance",(float)10.0);
if(glm::distance(player->GetCreature()->mPosition, structure->mPosition) > fTransferDistance)
{
return;
}
uint64 resourceId;
uint32 amount;
uint8 b1, b2;
message->getUint64(resourceId);
message->getUint32(amount);
message->getUint8(b1);
message->getUint8(b2);
StructureAsyncCommand command;
if(b1 == 0)
{
command.Command = Structure_Command_RetrieveResource;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
command.ResourceId = resourceId;
command.Amount = amount;
command.b1 = b1;
command.b2 = b2;
}
if(b1 == 1)
{
command.Command = Structure_Command_DiscardResource;
command.PlayerId = player->getId();
command.StructureId = structure->getId();
command.ResourceId = resourceId;
command.Amount = amount;
command.b1 = b1;
command.b2 = b2;
}
gStructureManager->checkNameOnPermissionList(structure->getId(),player->getId(),player->GetCreature()->getFirstName(),"HOPPER",command);
}
bool BuffManager::AddBuffToDB(WMAsyncContainer* asyncContainer,DatabaseCallback* callback, Buff* buff, uint64 currenttime)
{
// we are counting the queries we will have to start so the callbackhandler knows when the last query is through
// not sure what to do for creatures yet but my guess is thatthe handling will be very similiar
// thus the respective counter is in the creatureobject
// all asyncqueries will be returned to the callbackHandler provided
// we can decrease then the call counter of the creature object and in the case it reaches zero continue with
// whatever it was we set out to do
//If we have been passed a null Buff
if(!buff)
return false;
//Get PlayerObjects from CreatureObjects
PlayerObject* player = nullptr;
PlayerObject* target = nullptr;
try {
player = dynamic_cast<PlayerObject*>(buff->GetTarget());
target = dynamic_cast<PlayerObject*>(buff->GetInstigator()); //what is the difference ?
} catch (...) {
// The target or the instigator may have logged off in the process, bail out.
return false;
}
//If target is a player, not Creature/NPC
if(player)
{
//Get ID for Instigator (if not Creature/NPC)
uint64 instigatorid = 0;
if(target)
{
instigatorid = target->getId();
}
uint32 bufficon = buff->GetIcon();
int8 sql[550];
sprintf(sql, "INSERT INTO %s.character_buffs (character_id, buff_id, instigator_id, max_ticks, tick_length, current_tick, icon, current_global_tick, start_global_tick) values(",mDatabase->galaxy());
sprintf(sql+strlen(sql), "%" PRIu64 ",", player->getId());
sprintf(sql+strlen(sql), "%" PRIu64 ",", buff->GetID());
sprintf(sql+strlen(sql), "%" PRIu64 ",", instigatorid);
sprintf(sql+strlen(sql), "%u,", buff->GetNoOfTicks());
sprintf(sql+strlen(sql), "%" PRIu64 ",", buff->GetTickLength());
sprintf(sql+strlen(sql), "%u,", buff->GetCurrentTickNumber());
sprintf(sql+strlen(sql), "%u,", bufficon);
sprintf(sql+strlen(sql), "%" PRIu64 ",", currenttime);
sprintf(sql+strlen(sql), "%" PRIu64 ");", buff->GetStartGlobalTick());
buffAsyncContainer* asContainer = new(buffAsyncContainer);
asContainer->mQueryType = BMQuery_Save_Async;
asContainer->player = player;
asContainer->asyncContainer = asyncContainer;
asContainer->callBack = callback;
mDatabase->executeSqlAsync(this,asContainer,sql);
int8 sql2[550];
sprintf(sql2, "INSERT INTO %s.character_buff_attributes (buff_id,character_id,type,initial,tick,final) VALUES",mDatabase->galaxy());
//Add Attributes
AttributeList::iterator it = buff->Attributes.begin();
//if we have no attributes
if(it == buff->Attributes.end())
{
return true; //the first part generates already a callback
}
while(it != buff->Attributes.end())
{
BuffAttribute* batemp = *it;
sprintf(sql2+strlen(sql2), "(%" PRIu64 ",", buff->GetID());
sprintf(sql2+strlen(sql2), "%" PRIu64 ",", player->getId());
sprintf(sql2+strlen(sql2), "%" PRIu64 ",", batemp->GetType());
sprintf(sql2+strlen(sql2), "%d,", batemp->GetInitialValue());
sprintf(sql2+strlen(sql2), "%d,", batemp->GetTickValue());
AttributeList::iterator it2 = it;
it2++;
if(it2 != buff->Attributes.end())
{
sprintf(sql2+strlen(sql2), "%d),", batemp->GetFinalValue());
} else
{
sprintf(sql2+strlen(sql2), "%d);", batemp->GetFinalValue());
}
it++;
}
asContainer = new(buffAsyncContainer);
asContainer->mQueryType = BMQuery_Save_Async;
asContainer->player = player;
asContainer->asyncContainer = asyncContainer;
asContainer->callBack = callback;
mDatabase->executeSqlAsync(this,asContainer,sql2);
return true;
}
else
return false;
}
void BuffManager::LoadBuffsFromResult(buffAsyncContainer* asyncContainer, DatabaseResult* result)
{
DataBinding* buffBinding = mDatabase->createDataBinding(9);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mBuffId),8,0);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mTargetId),8,1);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mInstigatorId),8,2);
buffBinding->addField(DFT_uint32,offsetof(BuffDBItem,mMaxTicks),4,3);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mTickLength),8,4);
buffBinding->addField(DFT_uint32,offsetof(BuffDBItem,mCurrentTick),4,5);
buffBinding->addField(DFT_uint32,offsetof(BuffDBItem,mIconCRC),4,6);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mPausedGlobalTick),8,7);
buffBinding->addField(DFT_uint64,offsetof(BuffDBItem,mStartGlobalTick),8,8);
uint64 rowCount = result->getRowCount();
if(rowCount == 0)
{
SAFE_DELETE(asyncContainer);
mDatabase->destroyDataBinding(buffBinding);
return;
}
PlayerObject* player = asyncContainer->player;
BuffDBItem* tmp = new BuffDBItem();
for(uint64 i = 0; i < rowCount; i++)
{
result->getNextRow(buffBinding,tmp);
//Check player hasn't been logged out for more than 10mins
if((asyncContainer->currentTime - tmp->mPausedGlobalTick) < 600000)
{
Buff* buffTemp = Buff::FromDB(tmp, asyncContainer->currentTime);
//Check there is time left
if(buffTemp->GetRemainingTime(asyncContainer->currentTime) >0)
{
buffTemp->setTarget(player);
player->AddBuff(buffTemp);
player->IncBuffAsyncCount();
} else {
SAFE_DELETE(buffTemp);
}
}
}
SAFE_DELETE(tmp);
mDatabase->destroyDataBinding(buffBinding);
BuffList::iterator it = player->GetBuffList()->begin();
while(it != player->GetBuffList()->end())
{
asyncContainer->buff = *it;
LoadBuffAttributes(asyncContainer);
it++;
}
asyncContainer->mQueryType = BMQuery_Delete;
int8 sql2[550];
sprintf(sql2, "delete from %s.character_buffs where character_id = %" PRIu64 ";",mDatabase->galaxy(), player->getId());
mDatabase->executeSqlAsync(this,asyncContainer,sql2);
}
//======================================================================================================================
//
// rotates an item
//
void ObjectController::HandleRotateFurniture_(
uint64 targetId,
Message* message,
ObjectControllerCmdProperties* cmdProperties) {
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* player = creature->GetGhost();
if (!player) {
assert(false && "ObjectController::HandleRotateFurniture_ Player not found");
return;
}
// Verify that there was a target passed.
if (!targetId) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
Object* object = gWorldManager->getObjectById(targetId);
if(!object) {
assert(false && "ObjectController::HandleRotateFurniture_ item not found");
return;
}
// Verify that the item and player are in the same structure.
CellObject* playerCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(player->getParentId()));
if(!playerCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
uint64 playerStructure = playerCell->getParentId();
CellObject* objectCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(object->getParentId()));
if(!objectCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
uint64 objectStructure = objectCell->getParentId();
if (objectStructure != playerStructure) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_what"), player);
return;
}
// Verify that the player has appropriate rights on this structure.
if (playerCell) {
if (BuildingObject* building = dynamic_cast<BuildingObject*>(gWorldManager->getObjectById(playerCell->getParentId()))) {
if (!building->getAdminData().check_admin(player->getId())) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "admin_move_only"), player);
return;
}
} else {
assert(false && "ObjectController::HandleRotateFurniture_ no structure");
return;
}
} else {
//were just outside??
return;
}
// Read the message out of the packet.
BString tmp;
message->getStringUnicode16(tmp);
// If the string has no length the message is ill-formatted, send the
// proper format to the client.
if (!tmp.getLength()) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "format_rotatefurniture_degrees"), player);
return;
}
// Convert the string to an ansi string for ease with the regex.
tmp.convert(BSTRType_ANSI);
std::string input_string(tmp.getAnsi());
static const regex pattern("(right|left) ([0-9]+)");
smatch result;
regex_search(input_string, result, pattern);
// If the pattern doesn't match all elements then send the proper format
// to the client.
if (result.length() < 2) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "format_rotatefurniture_degrees"), player);
return;
}
// Gather the results of the pattern for validation and use.
std::string direction(result[1]);
float degrees = boost::lexical_cast<float>(result[2]);
// If the the specified amount is not within the valid range notify the client.
if (degrees < 1.0f || degrees > 180.0f) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "rotate_params"), player);
return;
}
// Rotate by the necessary amount.
if (direction.compare("left") == 0) {
object->rotateLeft(degrees);
} else {
object->rotateRight(degrees);
}
// Update the world with the changes.
gMessageLib->sendDataTransformWithParent053(object);
object->updateWorldPosition();
}
bool HandleMoveFurniture(
Object* object,
Object* target,
Message* message,
ObjectControllerCmdProperties* cmdProperties) {
PlayerObject* player = dynamic_cast<PlayerObject*>(object);
if (!player) {
assert(false && "ObjectController::HandleItemMoveDown_ Player not found");
return false;
}
// Verify that there was a target passed.
if (!target) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "move_what"), player);
return false;
}
if(!target) {
assert(false && "ObjectController::HandleItemMoveDown_ item not found");
return false;
}
// Verify that the item and player are in the same structure.
CellObject* playerCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(player->getParentId()));
if(!playerCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "move_what"), player);
return false;
}
uint64 playerStructure = playerCell->getParentId();
CellObject* objectCell = dynamic_cast<CellObject*>(gWorldManager->getObjectById(object->getParentId()));
if(!objectCell) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "move_what"), player);
return false;
}
uint64 objectStructure = objectCell->getParentId();
if (objectStructure != playerStructure) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "move_what"), player);
return false;
}
// Verify that the player has appropriate rights on this structure.
if (playerCell) {
if (BuildingObject* building = dynamic_cast<BuildingObject*>(gWorldManager->getObjectById(playerCell->getParentId()))) {
if (!building->getAdminData().check_admin(player->getId())) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "admin_move_only"), player);
return false;
}
} else {
assert(false && "ObjectController::HandleItemMoveDown_ no structure");
return false;
}
} else {
//were just outside ??
return false;
}
// Read the message out of the packet.
BString tmp;
message->getStringUnicode16(tmp);
// If the string has no length the message is ill-formatted, send the
// proper format to the client.
if (!tmp.getLength()) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "format_movefurniture_distance"), player);
return false;
}
// Convert the string to an ansi string for ease with the regex.
tmp.convert(BSTRType_ANSI);
std::string input_string(tmp.getAnsi());
static const regex pattern("(forward|back|up|down) ([0-9]+)");
smatch result;
regex_search(input_string, result, pattern);
// If the pattern doesn't match all elements then send the proper format
// to the client.
if (result.length() < 2) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "format_movefurniture_distance"), player);
return false;
}
// Gather the results of the pattern for validation and use.
std::string direction(result[1]);
float distance = boost::lexical_cast<float>(result[2]);
// If the the specified amount is not within the valid range notify the client.
if ((distance < 1.0f) || (distance > 500.0f)) {
gMessageLib->SendSystemMessage(::common::OutOfBand("player_structure", "movefurniture_params"), player);
return false;
}
// Move object an MOVE_INCREMENT times by the amount and direction specified.
if (direction == "forward") {
target->move(player->mDirection, distance * MOVE_INCREMENT);
} else if (direction == "back") {
target->move(player->mDirection, -distance * MOVE_INCREMENT);
} else if (direction == "up") {
target->mPosition.y += distance * MOVE_INCREMENT;
} else if (direction == "down") {
target->mPosition.y -= distance * MOVE_INCREMENT;
}
// Update the world with the changes.
gMessageLib->sendDataTransformWithParent053(target);
target->updateWorldPosition();
return true;
}
uint8 CombatManager::_executeAttack(CreatureObject* attacker,CreatureObject* defender,ObjectControllerCmdProperties *cmdProperties,Weapon* weapon)
{
uint8 randomHitPool = 100;
//uint8 randomPoolHitChance = 100;
uint8 stateApplied = 0;
int32 multipliedDamage = 0;
BString combatSpam = "melee";
// first see if we actually hit our target
uint8 attackResult = _hitCheck(attacker,defender,cmdProperties,weapon);
// only proceed, if so
if(!attackResult)
{
// TODO: retrieve from weapon
int32 baseMinDamage = 50;
int32 baseMaxDamage = 100;
// NOTE: Some weapon data just for tesing and to give the npc a fair chance...
if (weapon->hasAttribute("cat_wpn_damage.wpn_damage_min"))
{
baseMinDamage = weapon->getAttribute<int32>("cat_wpn_damage.wpn_damage_min");
}
if (weapon->hasAttribute("cat_wpn_damage.wpn_damage_max"))
{
baseMaxDamage = weapon->getAttribute<int32>("cat_wpn_damage.wpn_damage_max");
}
//Sanity checks of db data
if (baseMinDamage < 1)
baseMinDamage = 1;
if (baseMaxDamage < 1)
baseMaxDamage = 1;
if(baseMaxDamage <= baseMinDamage)
{
baseMaxDamage = baseMinDamage +1;
}
int32 baseDamage = -((gRandom->getRand()%(baseMaxDamage - baseMinDamage)) + baseMinDamage);
// apply damage multiplier
if(cmdProperties->mDamageMultiplier)
{
multipliedDamage = static_cast<uint32>(static_cast<float>(baseDamage) * cmdProperties->mDamageMultiplier);
}
else
{
multipliedDamage = baseDamage;
}
// mitigation
multipliedDamage = _mitigateDamage(attacker,defender,cmdProperties,multipliedDamage,weapon);
// state effects
stateApplied = _tryStateEffects(attacker,defender,cmdProperties,weapon);
// Here is the deal. When a player makes damage to a npc, we have to register the player, its group, damage done and what (kind of) weapon used.
NPCObject* npc = dynamic_cast<NPCObject*>(defender);
if (!defender->isDead() && npc)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(attacker);
if (player)
{
npc->updateDamage(player->getId(), player->getGroupId(), weapon->getGroup(), -multipliedDamage, player->GetPosture(), glm::distance(defender->mPosition, player->mPosition));
}
}
// ham damage
// if no target pool set, pick a random one
if(!cmdProperties->mHealthHitChance && !cmdProperties->mActionHitChance && !cmdProperties->mMindHitChance)
{
switch(gRandom->getRand()%3)
{
case 0: randomHitPool = HamBar_Health; break;
case 1: randomHitPool = HamBar_Action; break;
case 2: randomHitPool = HamBar_Mind; break;
default: randomHitPool = 0; break;
}
}
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
//this is pure idiocy in my eyes. Why for gods sake should an object be a creature ?
// is there precedent through SOE???????????
if (defender->getCreoGroup() != CreoGroup_AttackableObject)
{
// random pool attack
if(randomHitPool != 100)
{
ham->UpdateCurrentHitpoints(defender,randomHitPool,multipliedDamage);
//defender->getHam()->updatePropertyValue(randomHitPool,HamProperty_CurrentHitpoints,multipliedDamage,true);
}
// direct pool attack
else
{
// health hit
if(cmdProperties->mHealthHitChance)
{
ham->UpdateCurrentHitpoints(defender,HamBar_Health,multipliedDamage);
//defender->getHam()->updatePropertyValue(HamBar_Health,HamProperty_CurrentHitpoints,multipliedDamage,true);
}
// action hit
else if(cmdProperties->mActionHitChance)
{
ham->UpdateCurrentHitpoints(defender,HamBar_Action,multipliedDamage);
//defender->getHam()->updatePropertyValue(HamBar_Action,HamProperty_CurrentHitpoints,multipliedDamage,true);
}
// mind hit
else if(cmdProperties->mMindHitChance)
{
ham->UpdateCurrentHitpoints(defender,HamBar_Mind,multipliedDamage);
//defender->getHam()->updatePropertyValue(HamBar_Mind,HamProperty_CurrentHitpoints,multipliedDamage,true);
}
}
}
else
{
ham->UpdateCurrentHitpoints(defender,HamBar_Health,multipliedDamage);
//defender->getHam()->updateSingleHam(multipliedDamage, true);
}
if (defender->isIncapacitated())
{
PlayerObject* playerAttacker = dynamic_cast<PlayerObject*>(attacker);
if (playerAttacker && playerAttacker->isConnected())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_target_incap", 0, defender->getId(), 0), playerAttacker);
}
}
if (defender->isDead())
{
PlayerObject* playerAttacker = dynamic_cast<PlayerObject*>(attacker);
if (playerAttacker && playerAttacker->isConnected())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "killer_target_dead"), playerAttacker, true);
}
}
}
// fly text and animations
// default attack(s)
if(cmdProperties->mCmdCrc == 0xa8fef90a)
{
uint32 animCrc = getDefaultAttackAnimation(weapon->getGroup());
switch(attackResult)
{
// hit
case 0:
case 2:
case 3:
case 4:
{
gMessageLib->sendCombatAction(attacker,defender,animCrc,0,0,1);
}
break;
// miss
case 1:
{
gMessageLib->sendCombatAction(attacker,defender,animCrc);
}
break;
}
}
// special attack
else
{
switch(attackResult)
{
// hit
case 0:
case 2:
case 3:
case 4:
{
gMessageLib->sendCombatAction(attacker,defender,cmdProperties->mAnimationCrc,cmdProperties->mTrail1,cmdProperties->mTrail2,1);
}
break;
//miss
case 1:
{
gMessageLib->sendCombatAction(attacker,defender,cmdProperties->mAnimationCrc,cmdProperties->mTrail1,cmdProperties->mTrail2);
}
break;
}
}
switch(attackResult)
{
case 0:
{
// Defender got hit.
}
break;
case 1:
{
gMessageLib->sendFlyText(defender,"combat_effects","miss",255,255,255);
}
break;
case 2:
// We cant block yet, can we?
{
gMessageLib->sendFlyText(defender,"combat_effects","block",0,255,0);
gMessageLib->sendCombatAction(defender,attacker,0xe430ff04);
}
break;
case 3:
{
gMessageLib->sendFlyText(defender,"combat_effects","dodge",0,255,0);
gMessageLib->sendCombatAction(defender,attacker,0xe430ff04); // Dodge
}
break;
case 4:
{
gMessageLib->sendFlyText(defender,"combat_effects","counterattack",0,255,0); // I can's see this effect working?
}
break;
}
// send combat spam
// default attack
if(cmdProperties->mCmdCrc == 0xa8fef90a)
{
combatSpam = getDefaultSpam(weapon->getGroup());
}
// special attack
else
{
if(cmdProperties->mCbtSpam.getLength())
{
combatSpam = cmdProperties->mCbtSpam.getAnsi();
}
}
switch(attackResult)
{
case 0:
combatSpam << "_hit";
break;
case 1:
combatSpam << "_miss";
break;
case 2:
combatSpam << "_block";
break;
case 3:
combatSpam << "_evade";
break;
case 4:
combatSpam << "_counter";
break;
default:
break;
}
gMessageLib->sendCombatSpam(attacker,defender,-multipliedDamage,"cbt_spam",combatSpam);
return(0);
}
bool CombatManager::_verifyCombatState(CreatureObject* attacker, uint64 defenderId)
{
PlayerObject* playerAttacker = dynamic_cast<PlayerObject*>(attacker);
CreatureObject* defender = dynamic_cast<CreatureObject*>(gWorldManager->getObjectById(defenderId));
if (!defender)
{
// No such object.
return(false);
}
// Do not try to attack already incapped or dead objects.
if (defender->isIncapacitated() || defender->isDead())
{
return false;
}
//Do not attack if we are incapped or already dead or mounted.
if (attacker->isIncapacitated() || attacker->isDead() || playerAttacker->checkIfMounted())
{
return false;
}
// make sure we got both objects
if (playerAttacker && defender)
{
//Do not attack if we are mounted
if(playerAttacker->checkIfMounted())
{
return false;
}
// if our target is a player, he must be dueling us or both need to be overt(TODO)
if (PlayerObject* defenderPlayer = dynamic_cast<PlayerObject*>(defender))
{
// also return, if our target is incapacitated or dead
if(!playerAttacker->checkDuelList(defenderPlayer) || !defenderPlayer->checkDuelList(playerAttacker)
|| defenderPlayer == playerAttacker)
{
return(false);
}
if(defenderPlayer->isIncapacitated())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_incap");
return(false);
}
else if(defenderPlayer->isDead())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_dead");
return(false);
}
// put us in combat state
gStateManager.setCurrentActionState(attacker, CreatureState_Combat);
gStateManager.setCurrentActionState(attacker, CreatureState_CombatAttitudeNormal);
// put our target in combat state
if(!defenderPlayer->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(defender, CreatureState_Combat);
gStateManager.setCurrentActionState(defender, CreatureState_CombatAttitudeNormal);
}
// update our defender list
if (!playerAttacker->checkDefenderList(defenderPlayer->getId()))
{
playerAttacker->AddDefender(defenderPlayer->getId());
}
// update our targets defender list
if (!defenderPlayer->checkDefenderList(playerAttacker->getId()))
{
playerAttacker->AddDefender(defenderPlayer->getId());
}
if (!defenderPlayer->autoAttackEnabled())
{
// Player can/may start auto-attack if idle.
defenderPlayer->getController()->enqueueAutoAttack(playerAttacker->getId());
}
}
else
{
// our target is a creature
if (defender->isIncapacitated())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_incap");
return(false);
}
else if (defender->isDead())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_dead");
return(false);
}
// Vefify that out target is attackable. It's not nice to spam attacks at innocent npc's.
if (!(defender->getPvPStatus() & CreaturePvPStatus_Attackable))
{
return(false);
}
// put us in combat state
// if (!playerAttacker->states.checkState((CreatureState)(CreatureState_Combat + CreatureState_CombatAttitudeNormal)))
{
// playerAttacker->togglePvPStateOn((CreaturePvPStatus)(CreaturePvPStatus_Attackable + CreaturePvPStatus_Aggressive + CreaturePvPStatus_Enemy));
gMessageLib->sendUpdatePvpStatus(playerAttacker,playerAttacker, playerAttacker->getPvPStatus() | CreaturePvPStatus_Attackable);
// TEST STATE MANAGER!
gStateManager.setCurrentActionState(attacker, CreatureState_Combat);
gStateManager.setCurrentActionState(attacker, CreatureState_CombatAttitudeNormal);
}
if (!defender->states.checkState((CreatureState_Combat)))
{
// Creature was NOT in combat before, and may very well be dormant.
// Wake him up.
gWorldManager->forceHandlingOfDormantNpc(defender->getId());
gWorldManager->forceHandlingOfReadyNpc(defender->getId());
// Creature may need some aggro built up before going into combat state??
gStateManager.setCurrentActionState(defender, CreatureState_Combat);
gStateManager.setCurrentActionState(defender, CreatureState_CombatAttitudeNormal);
}
gMessageLib->sendUpdatePvpStatus(defender, playerAttacker, defender->getPvPStatus() | CreaturePvPStatus_Attackable | CreaturePvPStatus_Enemy);
// update our defender list
if (!playerAttacker->checkDefenderList(defender->getId()))
{
playerAttacker->AddDefender(defenderPlayer->getId());
}
// update our targets defender list
if (!defender->checkDefenderList(playerAttacker->getId()))
{
playerAttacker->AddDefender(defenderPlayer->getId());
}
}
}
else
{
return(false);
}
return(true);
}
void BuffManager::AddBuffToDB(Buff* buff, uint64 currenttime)
{
//If we have been passed a null Buff
if(!buff)
return;
//Check for deletion of buff
if(buff->GetIsMarkedForDeletion())
return;
buffAsyncContainer* envelope = new buffAsyncContainer();
envelope->mQueryType = BMQuery_Null;
/*TODO Should I Reset the Stat here on the player so it doesn't get double buffed
For now, this is dealt with by removing hte modifiers when saving Player HAM to DB,
but this might not be the best long term solution
*/
//Get PlayerObjects from CreatureObjects
PlayerObject* Player = dynamic_cast<PlayerObject*>(buff->GetTarget());
PlayerObject* target = dynamic_cast<PlayerObject*>(buff->GetInstigator());
//If target is a player, not Creature/NPC
if(Player)
{
//Get ID for Instigator (if not Creature/NPC)
uint64 instigatorid = 0;
if(target)
{
instigatorid = target->getId();
}
uint32 bufficon = buff->GetIcon();
int8 sql[550];
sprintf(sql, "INSERT INTO %s.character_buffs (character_id, buff_id, instigator_id, max_ticks, tick_length, current_tick, icon, current_global_tick, start_global_tick) values(",mDatabase->galaxy());
sprintf(sql+strlen(sql), "%" PRIu64 ",", Player->getId());
sprintf(sql+strlen(sql), "%" PRIu64 ",", buff->GetID());
sprintf(sql+strlen(sql), "%" PRIu64 ",", instigatorid);
sprintf(sql+strlen(sql), "%u,", buff->GetNoOfTicks());
sprintf(sql+strlen(sql), "%" PRIu64 ",", buff->GetTickLength());
sprintf(sql+strlen(sql), "%u,", buff->GetCurrentTickNumber());
sprintf(sql+strlen(sql), "%u,", bufficon);
sprintf(sql+strlen(sql), "%" PRIu64 ",", currenttime);
sprintf(sql+strlen(sql), "%" PRIu64 ");", buff->GetStartGlobalTick());
//Lloydyboy Changed Save SQL back to Sync, not ASync to ensure this is saved, before new zone loads
//mDatabase->ExecuteSqlAsync(this,envelope,sql);
mDatabase->destroyResult(mDatabase->executeSynchSql(sql));
int8 sql2[550];
sprintf(sql2, "INSERT INTO %s.character_buff_attributes (buff_id,character_id,type,initial,tick,final) VALUES",mDatabase->galaxy());
//Add Attributes
AttributeList::iterator it = buff->Attributes.begin();
//if we have no attributes
if(it == buff->Attributes.end())
{
return;
}
while(it != buff->Attributes.end())
{
BuffAttribute* batemp = *it;
//undo the attribute pre safe - we will reapply this on login
buff->ModifyAttribute(batemp->GetType(), batemp->GetFinalValue());
sprintf(sql2+strlen(sql2), "(%" PRIu64 ",", buff->GetID());
sprintf(sql2+strlen(sql2), "%" PRIu64 ",", Player->getId());
sprintf(sql2+strlen(sql2), "%" PRIu64 ",", batemp->GetType());
sprintf(sql2+strlen(sql2), "%d,", batemp->GetInitialValue());
sprintf(sql2+strlen(sql2), "%d,", batemp->GetTickValue());
AttributeList::iterator it2 = it;
it2++;
if(it2 != buff->Attributes.end())
{
sprintf(sql2+strlen(sql2), "%d),", batemp->GetFinalValue());
} else {
sprintf(sql2+strlen(sql2), "%d);", batemp->GetFinalValue());
}
it++;
}
//Lloydyboy Changed Save SQL back to Sync, not ASync to ensure this is saved, before new zone loads
//mDatabase->ExecuteSqlAsync(this,envelope,sql2);
//then just put the notification of the new zone into the callback handler ?
//having the zone wait for synch db calls everytime someone travels is simply stupid
mDatabase->destroyResult(mDatabase->executeSynchSql(sql2));
}
}
void BuffManager::handleDatabaseJobComplete(void *ref, DatabaseResult *result)
{
buffAsyncContainer* asyncContainer = reinterpret_cast<buffAsyncContainer*>(ref);
if(!asyncContainer)
{
if(result)
//mDatabase->DestroyResult(result);
return;
}
switch(asyncContainer->mQueryType)
{
//we started saving a player ASync - give it back to the WorldManager
case BMQuery_Save_Async:
{
//get the player and check whether this was the last buff callback
PlayerObject* playerObject = asyncContainer->player;
playerObject->DecBuffAsyncCount();
//if this is the last callback continue with saving the players data
if(!playerObject->GetBuffAsyncCount())
{
//the asynccontainer was prepared by the worldmanager
WMAsyncContainer* asContainer = asyncContainer->asyncContainer;
// position save - the callback will be in the worldmanager to proceed with the rest of the safe
mDatabase->executeSqlAsync(reinterpret_cast<DatabaseCallback*>(asyncContainer->callBack),asContainer,"UPDATE %s.characters SET parent_id=%" PRIu64 ",oX=%f,oY=%f,oZ=%f,oW=%f,x=%f,y=%f,z=%f,planet_id=%u,jedistate=%u WHERE id=%" PRIu64 "",
mDatabase->galaxy(),playerObject->getParentId()
,playerObject->mDirection.x,playerObject->mDirection.y,playerObject->mDirection.z,playerObject->mDirection.w
,playerObject->mPosition.x,playerObject->mPosition.y,playerObject->mPosition.z
,gWorldManager->getZoneId(),playerObject->getJediState(),playerObject->getId());
//Free up Memory
SAFE_DELETE(asyncContainer);
BuffList::iterator it = playerObject->GetBuffList()->begin();
while(it != playerObject->GetBuffList()->end())
{
SAFE_DELETE(*it);
it = playerObject->GetBuffList()->erase(it);
}
}
}
break;
case BMQuery_Buffs:
{
LoadBuffsFromResult(asyncContainer, result);
}
break;
case BMQuery_Buff_Attributes:
{
LoadBuffAttributesFromResult(asyncContainer, result);
}
break;
case BMQuery_Delete:
{
SAFE_DELETE(asyncContainer);
}
break;
case BMQuery_Null:
{
}
break;
default:
{
}
break;
}
}
void StructureManager::_HandleUpdateAttributes(StructureManagerAsyncContainer* asynContainer,DatabaseResult* result)
{
BString value;
Type_QueryContainer container;
DataBinding* binding = mDatabase->CreateDataBinding(2);
binding->addField(DFT_bstring,offsetof(Type_QueryContainer,mString),128,0);
binding->addField(DFT_bstring,offsetof(Type_QueryContainer,mValue),128,1);
PlayerObject* player = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(asynContainer->mPlayerId));
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(gWorldManager->getObjectById(asynContainer->mStructureId));
uint64 count;
count = result->getRowCount();
for(uint64 i = 0;i < count;i++)
{
result->GetNextRow(binding,&container);
if(strcmp(container.mString.getAnsi(),"schematicCustom") == 0)
{
FactoryObject* factory = dynamic_cast<FactoryObject*>(structure);
if(factory)
factory->setSchematicCustomName(container.mValue);
gLogger->logMsgF("StructureManager::GetCustomName : %s",MSG_HIGH, container.mValue.getAnsi());
}
if(strcmp(container.mString.getAnsi(),"schematicName") == 0)
{
FactoryObject* factory = dynamic_cast<FactoryObject*>(structure);
if(factory)
factory->setSchematicName(container.mValue);
gLogger->logMsgF("StructureManager::GetName : %s",MSG_HIGH, container.mValue.getAnsi());
}
if(strcmp(container.mString.getAnsi(),"schematicFile") == 0)
{
FactoryObject* factory = dynamic_cast<FactoryObject*>(structure);
if(factory)
factory->setSchematicFile(container.mValue);
gLogger->logMsgF("StructureManager::GetNameFile : %s",MSG_HIGH, container.mValue.getAnsi());
}
if(strcmp(container.mString.getAnsi(),"maintenance") == 0)
{
if(structure->hasAttribute("examine_maintenance"))
{
structure->setAttribute("examine_maintenance",container.mValue.getAnsi());
}
else
{
structure->addAttribute("examine_maintenance",container.mValue.getAnsi());
}
}
if(strcmp(container.mString.getAnsi(),"power") == 0)
{
if(structure->hasAttribute("examine_power"))
{
structure->setAttribute("examine_power",container.mValue.getAnsi());
}
else
{
structure->addAttribute("examine_power",container.mValue.getAnsi());
}
}
if(strcmp(container.mString.getAnsi(),"condition") == 0)
{
container.mValue.setLength(4);
structure->setDamage(boost::lexical_cast<uint32>(container.mValue.getAnsi()));
gLogger->logMsgF("StructureManager::GetConditionData : %u",MSG_HIGH, structure->getDamage());
}
if(strcmp(container.mString.getAnsi(),"name") == 0)
{
structure->setOwnersName(container.mValue);
}
}
switch(asynContainer->command.Command)
{
case Structure_Command_AccessSchem:
{
FactoryObject* factory = dynamic_cast<FactoryObject*>(structure);
if(factory)
createNewFactorySchematicBox(player, factory);
}
break;
case Structure_Command_Destroy:
{
structure->deleteStructureDBDataRead(player->getId());
}
break;
case Structure_Command_DepositPower:
{
createPowerTransferBox(player,structure);
}
break;
case Structure_Command_PayMaintenance:
{
createPayMaintenanceTransferBox(player,structure);
}
break;
case Structure_Command_ViewStatus:
{
createNewStructureStatusBox(player, structure);
}
break;
default:
break;
}
mDatabase->DestroyDataBinding(binding);
}
