void FireworkManager::Process()
{
//This iterates all fired fireworks and keeps everything spiffy.
std::list<FireworkEvent*>::iterator it=this->fireworkEvents.begin();
std::list<FireworkEvent*>::iterator fEnd = fireworkEvents.end();
//We can do this outside the while...We likely won't get a vastly different value while in it anyway.
uint64 currentTime = gWorldManager->GetCurrentGlobalTick();
while( it != fEnd)
{
if(*it && (currentTime - (*it)->timeFired) > 2000 && (*it)->playerToldToStand == false) //2 sec
{
PlayerObject* player = dynamic_cast<PlayerObject*> (gWorldManager->getObjectById((*it)->firework_operator));
if(player && player->GetCreature()->GetPosture() == CreaturePosture_Crouched)
{
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
(*it)->playerToldToStand = true;
}
++it;
}
else if(*it && (currentTime - (*it)->timeFired) > 25000) //25 sec (about the time of a firework)
{
gWorldManager->destroyObject((*it)->firework);
delete *it;
it = fireworkEvents.erase(it);
}
else
{
++it;
}
}
}
void ObjectController::_handleTendWound(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* Medic = creature->GetGhost();
PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));
//TODO:: add medic droid
/*EMLocationType loc = Medic->getPlayerLocation();
if(loc != EMLocation_Cantina || loc != EMLocation_Camp || loc != EMLocation_PlayerStructure)
{
return;
}*/
std::string messageResponse = gMedicManager->handleMessage(message,"(action|constitution|health|quickness|stamina|strength)");
if (messageResponse.length() == 0) {
//you must specify a valid wound type
gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "healing_response_65"), Medic);
return;
}
//check Medic has enough Mind
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
if(!ham->checkMainPools(Medic->GetCreature(), 0, 0, 500)) {
gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);
return;
}
if (gMedicManager->HealWound(Medic, Target, 0, cmdProperties, messageResponse + "tendwound"))
{
ham->ApplyWound(Medic->GetCreature(), HamBar_Focus, 5);
ham->ApplyWound(Medic->GetCreature(), HamBar_Willpower, 5);
Medic->GetCreature()->AddBattleFatigue(2);
//call the event
gMedicManager->startWoundTreatmentEvent(Medic);
return;
}
}
void ObjectController::_handleTendDamage(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* Medic = creature->GetGhost();
PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));
//check Medic has enough Mind
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
if(!ham->checkMainPools(Medic->GetCreature(), cmdProperties->mHealthCost, cmdProperties->mActionCost, cmdProperties->mMindCost)){
gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);
return;
}
if (gMedicManager->HealDamage(Medic, Target, 0, cmdProperties, "tendDamage"))
{
ham->ApplyWound(Medic->GetCreature(), HamBar_Focus, 5);
ham->ApplyWound(Medic->GetCreature(), HamBar_Willpower, 5);
Medic->GetCreature()->AddBattleFatigue(2);
//call the event
gMedicManager->startInjuryTreatmentEvent(Medic);
return;
}
}
//======================================================================================================================
//
// 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);
}
//======================================================================================================================
//
// 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);
}
//======================================================================================================================
//
// provides the harvester with the current resources
//
void ObjectController::_handleHarvesterGetResourceData(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)
{
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->GetCreature()->getFirstName(),"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
}
void ObjectController::_handleHealWound(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* Medic = creature->GetGhost();
PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));
std::string messageResponse = gMedicManager->handleMessage(message,"(action|constitution|health|quickness|stamina|strength)");
if (messageResponse.length() == 0)
{
//you must specify a valid wound type
gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "healing_response_65"), Medic);
}
else
{
//check Medic has enough Mind
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
if(!ham->checkMainPool(Medic->GetCreature(), HamBar_Mind, 140)) {
gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);
return;
}
if (gMedicManager->CheckMedicine(Medic, Target, cmdProperties, messageResponse))
{
//call the event
gMedicManager->startWoundTreatmentEvent(Medic);
return;
}
}
}
void VehicleController::MountPlayer()
{
if (!body_) {
assert(false && "Vehicle::mountPlayer() no vehicle body!");
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
CreatureObject* owner_creature = owner->GetCreature();
//Make the mount equip the player
// body_->AddObject(owner_creature);
//ok this makes hughe problems starting with auto equipping the player crc in the creo (the naked woman riding behind me)
//and ending with the question on how to send the auto updates for the creates / destroys as we basically transfer into the main cell (which isnt existent in our core)
gMessageLib->sendContainmentMessage_InRange(owner_creature->getId(), body_->getId(), 4, owner_creature);
gStateManager.setCurrentActionState(body_, CreatureState_MountedCreature);
//gStateManager.removeActionState(owner_creature,CreatureState_ClearState);
gStateManager.setCurrentActionState(owner_creature,CreatureState_RidingMount);
gStateManager.setCurrentPostureState(owner_creature,CreaturePosture_DrivingVehicle);
gStateManager.setCurrentLocomotionState(owner_creature,CreatureLocomotion_DrivingVehicle);
owner->setMounted(true);
gMessageLib->sendUpdateMovementProperties(owner);
//gMessageLib->sendUpdateTransformMessage(body_);
}
void VehicleController::MountPlayer()
{
if (!body_) {
assert(false && "Vehicle::mountPlayer() no vehicle body!");
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
CreatureObject* owner_creature = owner->GetCreature();
//Make the mount equip the player
body_->AddObject(owner_creature);
//thats currently somewhat of a hack as addobject sets the objects parent id
//this currently upsets the spatial index code as it thinks the swoop might be a cell
//and getrootparent breaks everything as it tries to calculate the lokation relative to the swoop
//this needs to be ironed out somehow
owner_creature->setParentId(0);
LOG(info) << "VehicleController::MountPlayer : arrangement " << owner->GetArrangementId();
gMessageLib->sendContainmentMessage_InRange(owner_creature->getId(), body_->getId(), owner_creature->GetArrangementId(), owner_creature);
gMessageLib->sendUpdateTransformMessage(body_);
body_->states.toggleActionOn(CreatureState_MountedCreature);
gMessageLib->sendStateUpdate(body_);
gStateManager.setCurrentActionState(owner_creature,CreatureState_RidingMount);
gMessageLib->sendStateUpdate(owner_creature);
//gStateManager.setCurrentPostureState(owner_,CreaturePosture_DrivingVehicle);
//gStateManager.setCurrentLocomotionState(owner_,CreatureLocomotion_DrivingVehicle);
owner->setMounted(true);
gMessageLib->sendUpdateMovementProperties(owner);
}
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->GetCreature()->getGroupId());
if(group)
{
group->removePlayer(playerObject->getId());
}
//asynch save
savePlayer(playerObject->getAccountId(),true,WMLogOut_LogOut);
it = mPlayersToRemove.erase(it);
}
else
++it;
}
return(true);
}
void VehicleController::DismountPlayer() {
if(!body_) {
LOG(error) << "Vehicle::DismountPlayer() no vehicle body!";
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
CreatureObject* owner_creature = owner->GetCreature();
if(!owner->checkIfMounted()) {
LOG(error) << "Vehicle::DismountPlayer() no vehicle body!";
return;
}
//For safe measures make the player equipped by nothing
body_->RemoveObject(owner, owner_creature);
gMessageLib->sendContainmentMessage_InRange(owner_creature->getId(), 0, owner_creature->GetArrangementId(), owner_creature);
gMessageLib->sendUpdateTransformMessage(body_);
// TODO: make this more automatic...
gStateManager.removeActionState(owner_creature, CreatureState_RidingMount);
gStateManager.removeActionState(body_, CreatureState_MountedCreature);
owner->setMounted(false);
gMessageLib->sendPostureAndStateUpdate(owner_creature);
gMessageLib->sendUpdateMovementProperties(owner);
}
void VehicleController::DismountPlayer() {
if(!body_) {
LOG(error) << "Vehicle::DismountPlayer() no vehicle body!";
return;
}
LOG(error) << "Vehicle::DismountPlayer()";
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
CreatureObject* owner_creature = owner->GetCreature();
if(!owner->checkIfMounted()) {
LOG(error) << "Vehicle::DismountPlayer() no vehicle body!";
return;
}
//see elaboration downstairs
// body_->RemoveObject(owner, owner_creature);
gMessageLib->sendContainmentMessage_InRange(owner_creature->getId(), 0, 0, owner_creature);
//gMessageLib->sendUpdateTransformMessage(body_);
// TODO: make this more automatic...
gStateManager.removeActionState(owner_creature, CreatureState_RidingMount);
gStateManager.setCurrentLocomotionState(owner_creature, CreatureLocomotion_Standing);
gStateManager.setCurrentPostureState(owner_creature, CreaturePosture_Upright);
gStateManager.removeActionState(body_, CreatureState_MountedCreature);
owner->setMounted(false);
gMessageLib->sendUpdateMovementProperties(owner);
}
//===============================================================================================
//stores the physical body
void VehicleController::Store()
{
if(!body_) {
DLOG(info) << "Vehicle::store() Error: Store was called for a nonexistant body object!";
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(owner_));
if(!owner_ || owner->GetCreature()->isDead() || owner->GetCreature()->isIncapacitated()) {
DLOG(info) << "Vehicle::store() couldnt find owner";
return;
}
// todo auto dismount
if(owner->checkIfMounted())
{
DLOG(info) << "Vehicle::store() dismounted";
DismountPlayer();
}
if(!owner->checkIfMountCalled())
{
DLOG(info) << "Vehicle::store() Mount wasnt called !!!";
return;
}
//the body is a creature_object!!!
gSpatialIndexManager->RemoveObjectFromWorld(body_);
owner->setMount(NULL);
owner->setMounted(false);
owner->setMountCalled(false);
// finally unload & destroy the vehicle creature
gWorldManager->destroyObject(body_);
// null the reference
body_ = NULL;
}
void CampRegion::update() {
//Camps have a max timer of 55 minutes
if (gWorldManager->GetCurrentGlobalTick() - mSetUpTime > 3300000) {
despawnCamp();
return;
}
if(mAbandoned && (gWorldManager->GetCurrentGlobalTick() >= mExpiresTime) && (!mDestroyed)) {
despawnCamp();
return;
}
PlayerObject* owner = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(mOwnerId));
if (!owner) {
despawnCamp();
return;
}
if(owner->GetCreature()->states.checkState(CreatureState_Combat)) {
//abandon
mAbandoned = true;
mExpiresTime = gWorldManager->GetCurrentGlobalTick(); //There is no grace period for combat.
return;
}
std::for_each(mVisitingPlayers.begin(), mVisitingPlayers.end(), [=] (uint64_t player_id) {
Object* visitor = gWorldManager->getObjectById(player_id);
if (!visitor) {
assert(false && "The camp is holding a reference to a player that doesn't exist");
return;
}
if (!mAbandoned) {
applyHAMHealing(visitor);
mXp++;
}
auto it = std::find_if(links.begin(), links.end(), [=] (campLink* link) {
return link->objectID == visitor->getId();
});
if (it != links.end()) {
(*it)->lastSeenTime = gWorldManager->GetCurrentGlobalTick();
if ((*it)->tickCount == 15) {
applyWoundHealing(visitor);
(*it)->tickCount = 0;
} else {
(*it)->tickCount++;
}
}
});
}
void ObjectController::_handleDestroyInstrument(Item* item)
{
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(mObject);
Item* tempInstrument = NULL;
Item* permanentInstrument = NULL;
auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService");
auto held_item = dynamic_cast<Item*>(equip_service->GetEquippedObject(playerObject, "hold_r"));
// first, stop playing, if its currently in use
if(playerObject->GetCreature()->getPerformingState() == PlayerPerformance_Music)
{
// equipped instrument
if(item == held_item || playerObject->getPlacedInstrumentId())
{
gEntertainerManager->stopEntertaining(playerObject);
}
}
// handle destruction of instanced instruments, placed in world
if(playerObject->getPlacedInstrumentId())
{
// get the instruments
tempInstrument = dynamic_cast<Item*>(gWorldManager->getObjectById(playerObject->getPlacedInstrumentId()));
if(!tempInstrument)
{
return;
}
permanentInstrument = dynamic_cast<Item*>(gWorldManager->getObjectById(tempInstrument->getPersistantCopy()));
if(!permanentInstrument)
{
return;
}
// the temporary gets ALWAYS deleted
// update the attributes of the permanent Instrument
if(tempInstrument == item)
{
permanentInstrument->setPlaced(false);
permanentInstrument->setNonPersistantCopy(0);
playerObject->setPlacedInstrumentId(0);
}
// it is the permanent Instrument delete the temporary copy too
else if(permanentInstrument == item)
{
destroyObject(tempInstrument->getId());
}
}
}
//======================================================================================================================
//
// 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::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);
}
}
void ObjectController::_handleHarvesterDeActivate(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;
}
HarvesterObject* harvester = dynamic_cast<HarvesterObject*>(structure);
harvester->setActive(false);
//send the respective delta
gMessageLib->sendHarvesterActive(harvester);
//send the db update
mDatabase->executeSqlAsync(0,0,"UPDATE %s.harvesters SET active = 0 WHERE id=%"PRIu64" ",mDatabase->galaxy(),harvester->getId());
}
void Instrument::prepareCustomRadialMenu(CreatureObject* player, uint8 itemCount)
{
// NOTE: player is also of type CreatureObject* !!!
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(player);
mRadialMenu.reset();
mRadialMenu = RadialMenuPtr(new RadialMenu());
// RadialMenu* radial = new RadialMenu();
//string mInstrumentString = instrument->getName();
uint32 instrumentNr = this->getItemType();
if ((instrumentNr == ItemType_Nalargon) || (instrumentNr == ItemType_omni_box) || (instrumentNr == ItemType_nalargon_max_reebo))
{
uint32 radId = 1;
// We have to know if this is the real one or the copy.
if (playerObject->getPlacedInstrumentId() == this->getId())
{
// We are handling the copy
if ((playerObject->getId() == this->getOwner()) && this->getPlaced())
{
if ((playerObject->GetCreature()->getPerformingState() == PlayerPerformance_Music))
{
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemUse,radAction_ObjCallback, "@radial_performance:stop_playing");
}
else
{
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemUse,radAction_ObjCallback, "@radial_performance:play_instrument");
}
}
else
{
// radial->addItem(radId++,0,radId_examine,radAction_Default);
// radial->addItem(radId++,0,radId_itemPickup,radAction_Default);
return;
}
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_examine,radAction_Default);
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemPickup,radAction_Default);
}
else
{
// We may be handling the original instrument.
auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService");
auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(playerObject->GetCreature(), "inventory"));
if (inventory) {
if (inventory->getId() == this->getParentId())
{
// We have our real instrument in the inventory.
// We can't drop if outside in the world.
if (player->getParentId() == 0)
{
// Outside
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_examine,radAction_Default);
mRadialMenu->addItem(static_cast<uint8>(radId),0,radId_itemDestroy, radAction_Default);
}
else
{
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_examine,radAction_Default);
mRadialMenu->addItem(static_cast<uint8>(radId),0,radId_itemDrop,radAction_Default);
mRadialMenu->addItem(static_cast<uint8>(radId),0,radId_itemDestroy, radAction_Default);
}
if (playerObject->getPlacedInstrumentId() == 0)
{
// We do not have any other placed intrument out.
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemUse,radAction_ObjCallback,"Use");
}
}
else if (dynamic_cast<CellObject*>(gWorldManager->getObjectById(this->getParentId())))
{
// It's either a original instrument, or someone else instrument, copy or original.
// Time for some dirty... the original instrument does not have an owner.
// Let's take advantage of that shortcoming.
// Is this my instrument?
if (this->getOwner() == player->getId())
{
// Yes, are we handling the original instrument.
// if (cell->getId() == this->getParentId())
{
if ((playerObject->GetCreature()->getPerformingState() == PlayerPerformance_Music))
{
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemUse,radAction_ObjCallback, "@radial_performance:stop_playing");
}
else
{
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemUse,radAction_ObjCallback, "@radial_performance:play_instrument");
}
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_examine,radAction_Default);
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_itemPickup,radAction_Default);
}
}
else
{
// This is not my instrument.
// gMessageLib->sendSystemMessage(playerObject,L"","error_message","insufficient_permissions");
mRadialMenu->addItem(static_cast<uint8>(radId++),0,radId_examine,radAction_Default);
// radial->addItem(radId++,0,radId_itemPickup,radAction_Default);
}
}
}
}
}
// mRadialMenu = RadialMenuPtr(radial);
// RadialMenuPtr radialPtr(radial);
// mRadialMenu = radialPtr;
}
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;
}
//======================================================================================================================
//
// 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);
}
//======================================================================================================================
//
// Selects the resource for extraction
//
void ObjectController::_handleHarvesterSelectResource(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)
{
DLOG(info) << " ObjectController::_handleHarvesterSelectResource Structure not in Range";
return;
}
HarvesterObject* harvester = dynamic_cast<HarvesterObject*>(structure);
//get the relevant Resource
BString dataStr;
message->getStringUnicode16(dataStr);
uint64 resourceId;
swscanf(dataStr.getUnicode16(),L"%"WidePRIu64,&resourceId);
Resource* tmpResource = gResourceManager->getResourceById(resourceId);
if((!tmpResource)||(!tmpResource->getCurrent()))
{
DLOG(info) << " ObjectController::_handleHarvesterSelectResource No valid resource!";
return;
}
harvester->setCurrentResource(resourceId);
// update the current resource in the db
mDatabase->executeSqlAsync(0,0,"UPDATE %s.harvesters SET ResourceID=%"PRIu64" WHERE id=%"PRIu64" ",mDatabase->galaxy(),resourceId,harvester->getId());
CurrentResource* cR = reinterpret_cast<CurrentResource*>(tmpResource);
//resource = reinterpret_cast<CurrentResource*>(gResourceManager->getResourceByNameCRC(resourceName.getCrc()));
float posX, posZ;
float ratio = 0.0;
posX = harvester->mPosition.x;
posZ = harvester->mPosition.z;
if(cR)
{
ratio = cR->getDistribution((int)posX + 8192,(int)posZ + 8192);
if(ratio > 1.0)
{
ratio = 1.0;
}
}
float ber = harvester->getSpecExtraction();
harvester->setCurrentExtractionRate(ber*ratio);
// now enter the new resource in the hoppers resource list if its isnt already in there
// TODO keep the list up to date by removing unnecessary resources
// to this end read the list anew and delete every resource with zero amount
// have a stored function do this
if(!harvester->checkResourceList(resourceId))
{
//do *not* add to list - otherwise we get a racecondition with the asynch update from db !!!
//harvester->getResourceList()->push_back(std::make_pair(resourceId,float(0.0)));
//add to db
mDatabase->executeSqlAsync(0,0,"INSERT INTO %s.harvester_resources VALUES(%"PRIu64",%"PRIu64",0,0)",mDatabase->galaxy(),harvester->getId(),resourceId);
}
// update the current extractionrate in the db for the stored procedure handling the harvesting
mDatabase->executeSqlAsync(0,0,"UPDATE %s.harvesters SET rate=%f WHERE id=%"PRIu64" ",mDatabase->galaxy(),(ber*ratio),harvester->getId());
//now send the updates
gMessageLib->sendCurrentResourceUpdate(harvester,player);
gMessageLib->sendCurrentExtractionRate(harvester,player);
}
void ObjectController::destroyObject(uint64 objectId)
{
CreatureObject* creature = dynamic_cast<CreatureObject*>(mObject); PlayerObject* playerObject = creature->GetGhost();
Datapad* datapad = playerObject->getDataPad();
Object* object = gWorldManager->getObjectById(objectId);
auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService");
auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(playerObject->GetCreature(), "inventory"));
//could be a schematic!
ManufacturingSchematic* schem = datapad->getManufacturingSchematicById(objectId);
if(schem != NULL)
{
//delete schematic
datapad->removeManufacturingSchematic(objectId);
//delete schematic object
gObjectFactory->deleteObjectFromDB(schem);
gMessageLib->sendDestroyObject(objectId,playerObject);
return;
}
// or something else
if(object == NULL)
{
DLOG(info) << "ObjController::destroyObject: could not find object " << objectId;
return;
}
// waypoint
if(object->getType() == ObjType_Waypoint)
{
// delete from db
gObjectFactory->deleteObjectFromDB(object);
if(!datapad) {
LOG(error) << "ObjectController::destroyObject cant get datapad to destroy waypoint : " << object->getId();
return;
}
datapad->RemoveWaypoint(object->getId());
//remove from grid and/or container
gWorldManager->destroyObject(object);
}
//Inangible Objects
if(object->getType() == ObjType_Intangible)
{
gObjectFactory->deleteObjectFromDB(object);
//remove from grid and/or container
gWorldManager->destroyObject(object);
}
// tangible
else if(object->getType() == ObjType_Tangible)
{
TangibleObject* tangibleObject = dynamic_cast<TangibleObject*>(object);
auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService");
auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(playerObject->GetCreature(), "inventory"));
// items
if(Item* item = dynamic_cast<Item*>(tangibleObject))
{
// handle any family specifics
switch(item->getItemFamily())
{
case ItemFamily_CraftingTools: _handleDestroyCraftingTool(dynamic_cast<CraftingTool*>(item)); break;
case ItemFamily_Instrument: _handleDestroyInstrument(item); break;
default:break;
}
}
// reset pending ui callbacks
playerObject->resetUICallbacks(object);
// delete from db CAVE :: mark if its an Object saved in the db!!!!
// temporary placed instruments are not saved in the db
gObjectFactory->deleteObjectFromDB(object);
//remove from grid and/or container and/or World
gWorldManager->destroyObject(object);
}
}
void ArtisanManager::handleUIEvent(uint32 action,int32 element,std::u16string inputStr,UIWindow* window, std::shared_ptr<WindowAsyncContainerCommand> AsyncContainer)
{
PlayerObject* player = window->getOwner();
std::shared_ptr<SimpleEvent> sample_UI_event = nullptr;
if(!player) {
DLOG(error) << "ArtisanManager::handleUIEvent :: no player";
return;
}
auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService");
auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(player->GetCreature(), "inventory"));
if(!inventory) {
DLOG(error) << "ArtisanManager::handleUIEvent :: no inventory";
return;
}
if(!AsyncContainer) {
DLOG(error) << "ArtisanManager::handleUIEvent :: no asynccontainer";
return;
}
switch(window->getWindowType())
{
// Sampling Radioactive Msg Box
case SUI_Window_SmplRadioactive_MsgBox:
{
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
//we stopped the sampling
if(action == 1)
{
player->getSampleData()->mPassRadioactive = false;
player->getSampleData()->mPendingSample = false;
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
return;
}
else
{
player->getSampleData()->mPassRadioactive = true;
player->getSampleData()->mPendingSample = true;
if(ham->checkMainPool(player->GetCreature(), HamBar_Action, mSampleActionCost*2))
{
SurveyTool* tool = dynamic_cast<SurveyTool*>(gWorldManager->getObjectById(AsyncContainer->ToolId));
CurrentResource* resource = (CurrentResource*)AsyncContainer->CurrentResource;
player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getStoredTime() + 4000;
sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_radioactive"),0, 4000,
std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
}
else
{
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_no_action"), player);
return;
}
}
}
break;
case SUI_Window_SmplGamble_ListBox:
{
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
//action == 1 is cancel
if(action == 1)
{
player->getSampleData()->mPendingSample = false;
player->getSampleData()->mSampleGambleFlag = false;
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
player->GetCreature()->updateMovementProperties();
gMessageLib->sendUpdateMovementProperties(player);
gMessageLib->sendPostureAndStateUpdate(player->GetCreature());
return;
}
else
{
if(element == 0)
{
player->getSampleData()->mPendingSample = true;
player->getSampleData()->mSampleGambleFlag = false;
SurveyTool* tool = dynamic_cast<SurveyTool*>(gWorldManager->getObjectById(AsyncContainer->ToolId));
CurrentResource* resource = (CurrentResource*)AsyncContainer->CurrentResource;
player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 1000;
sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_gamble"),0, 1000,
std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
}
else
{
//action costs
if(!ham->checkMainPool(player->GetCreature(), HamBar_Action ,mSampleActionCost*2))
{
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
player->getSampleData()->mSampleEventFlag = false;
player->getSampleData()->mSampleGambleFlag = false;
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_no_action"), player);
return;
}
player->getSampleData()->mPendingSample = true;
//determine whether gamble is good or not
int32 gambleRoll = int(gRandom->getRand()%2) + 1;
if(gambleRoll == 1)
{
player->getSampleData()->mSampleEventFlag = true;
player->getSampleData()->mSampleGambleFlag = true;
}
else
{
player->getSampleData()->mSampleEventFlag = false;
player->getSampleData()->mSampleGambleFlag = false;
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_fail"), player);
}
SurveyTool* tool = dynamic_cast<SurveyTool*>(gWorldManager->getObjectById(AsyncContainer->ToolId));
CurrentResource* resource = (CurrentResource*)AsyncContainer->CurrentResource;
player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 1000;
sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_gamble"),0, 1000,
std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
}
}
}
break;
case SUI_Window_SmplWaypNode_ListBox:
{
if(action == 0)
{
//we hit ok and went for the wp
if(element == 1)
{
player->getSampleData()->mPendingSample = false;
player->getSampleData()->mSampleNodeFlag = true;
player->getSampleData()->Position.x = player->mPosition.x +(((gRandom->getRand()%50)+1));
player->getSampleData()->Position.z = player->mPosition.z +(((gRandom->getRand()%50)+1));
player->getSampleData()->zone = gWorldManager->getZoneId();
player->getSampleData()->resource = (CurrentResource*)AsyncContainer->CurrentResource;
Datapad* datapad = player->getDataPad();
std::string name("Resource Node");
std::u16string name_u16 (name.begin(), name.end());
datapad->requestNewWaypoint(name_u16, player->getSampleData()->Position ,static_cast<uint16>(gWorldManager->getZoneId()),Waypoint_blue);
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "node_waypoint"), player);
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
return;
}
//we ignored the node - so continue sampling
if(element == 0)
{
player->getSampleData()->mPendingSample = true;
player->getSampleData()->mSampleGambleFlag = false;
SurveyTool* tool = dynamic_cast<SurveyTool*>(gWorldManager->getObjectById(AsyncContainer->ToolId));
CurrentResource* resource = (CurrentResource*)AsyncContainer->CurrentResource;
player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 10000;
sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_continue"),0, 10000,
std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
}
}
else
{
player->getSampleData()->mPendingSample = false;
player->getSampleData()->mSampleNodeFlag = false;
player->getSampleData()->Position.x = 0;
player->getSampleData()->Position.z = 0;
player->getSampleData()->resource = NULL;
player->getSampleData()->zone = 0;
gStateManager.setCurrentPostureState(player->GetCreature(), CreaturePosture_Upright);
return;
}
}
break;
}
//notify the listeners
if (sample_UI_event)
gEventDispatcher.Notify(sample_UI_event);
}
void TreasuryManager::handleUIEvent(uint32 action,int32 element,std::u16string inputStr,UIWindow* window)
{
// gLogger->logMsgF("CloningTerminal::handleUIEvent You are here!",MSG_NORMAL);
if(window == NULL)
{
return;
}
PlayerObject* playerObject = window->getOwner(); // window owner
if(playerObject == NULL || !playerObject->isConnected() || playerObject->getSamplingState() || playerObject->GetCreature()->isIncapacitated() || playerObject->GetCreature()->isDead() || playerObject->GetCreature()->states.checkState(CreatureState_Combat))
{
return;
}
switch(window->getWindowType())
{
case SUI_Window_Trade_BankTip_ConfirmSurcharge:
{
if (action == 1)
{
// That's the Cancel.
//what
}
else
{
// This is the OK. (action == 0)
std::shared_ptr<TreasuryManagerAsyncContainer> container = std::static_pointer_cast<TreasuryManagerAsyncContainer>(window->getAsyncContainer());
handleBankTipSurchargeConfirmed(container);
}
}
break;
}
}
bool ArtisanManager::handleRequestCoreSample(Object* player,Object* target, Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(player);
if(cmdProperties)
// unfortunately it's not in this opcode
// hardcode for now
//mSampleActionCost = cmdProperties->mActionCost;
mSampleActionCost = 150;
if(playerObject->GetCreature()->getPerformingState() != PlayerPerformance_None || playerObject->checkIfMounted() || playerObject->GetCreature()->isDead() || playerObject->GetCreature()->states.checkState(CreatureState_Combat))
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "wrong_state"), playerObject);
return false;
}
// can't sample while surveying
if(playerObject->getSurveyState())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "sample_survey"), playerObject);
return false;
}
// don't allow sampling in buildings
if(playerObject->getParentId())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_in_structure"), playerObject);
return false;
}
uint64 localTime = Anh_Utils::Clock::getSingleton()->getLocalTime();
// don't allow more than one sample at a time
if(playerObject->getSamplingState())
{
playerObject->getSampleData()->mPendingSample = false;
playerObject->setNextSampleTime(localTime + 18000);
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "tool_recharge_time", 0, 0, 0, (int32)(playerObject->getNextSampleTime() - localTime) / 1000), playerObject);
return false;
}
if(!playerObject->getNextSampleTime() || (int32)(playerObject->getNextSampleTime() - localTime) <= 0)
{
playerObject->getSampleData()->mPendingSample = false;
playerObject->setNextSampleTime(localTime + 18000);
}
else
{
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "tool_recharge_time", 0, 0, 0, (int32)(playerObject->getNextSampleTime() - localTime) / 1000), playerObject);
return false;
}
SurveyTool* tool = dynamic_cast<SurveyTool*>(target);
CurrentResource* resource = NULL;
BString resourceName;
message->getStringUnicode16(resourceName);
resourceName.convert(BSTRType_ANSI);
resource = reinterpret_cast<CurrentResource*>(gResourceManager->getResourceByNameCRC(resourceName.getCrc()));
if(resource == NULL || tool == NULL)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("ui","survey_noresource"), playerObject);
return false;
}
if((resource->getType()->getCategoryId() == 903)||(resource->getType()->getCategoryId() == 904))
{
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "must_have_harvester"), playerObject);
return false;
}
playerObject->setSamplingState(true);
auto terrain = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::terrain::TerrainService>("TerrainService");
if(terrain->IsWater(gWorldManager->getZoneId(), playerObject->mPosition.x, playerObject->mPosition.z))
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_swimming"), playerObject);
return false;
}
resourceName.convert(BSTRType_Unicode16);
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "start_sampling", L"", L"", resourceName.getUnicode16()), playerObject);
// change posture
gStateManager.setCurrentPostureState(playerObject->GetCreature(), CreaturePosture_Crouched);
// play animation
gWorldManager->getClientEffect(tool->getInternalAttribute<uint32>("sample_effect"));
// schedule execution
std::shared_ptr<SimpleEvent> start_sample_event = nullptr;
start_sample_event = std::make_shared<SimpleEvent>(EventType("start_sample"), 0, 2000,
std::bind(&ArtisanManager::sampleEvent,this, playerObject, resource, tool));
// notify any listeners
gEventDispatcher.Notify(start_sample_event);
return true;
}
void HarvesterObject::handleObjectMenuSelect(uint8 messageType,Object* srcObject)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(srcObject);
if(!player)
{
return;
}
switch(messageType)
{
case radId_StructureStatus:
{
StructureAsyncCommand command;
command.Command = Structure_Command_ViewStatus;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
break;
case radId_depositPower:
{
StructureAsyncCommand command;
command.Command = Structure_Command_DepositPower;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
break;
case radId_payMaintenance:
{
StructureAsyncCommand command;
command.Command = Structure_Command_PayMaintenance;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
break;
case radId_serverTerminalManagementDestroy:
{
StructureAsyncCommand command;
command.Command = Structure_Command_Destroy;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
break;
case radId_serverTerminalPermissionsAdmin:
{
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(gWorldManager->getObjectById(this->getId()));
if(structure->getAdminData().check_admin(player->getId())) {
structure->sendStructureAdminList(player->getId());
}
}
break;
case radId_serverTerminalPermissionsHopper:
{
PlayerStructure* structure = dynamic_cast<PlayerStructure*>(gWorldManager->getObjectById(this->getId()));
if(structure->getAdminData().check_admin(player->getId())) {
structure->sendStructureHopperList(player->getId());
}
}
break;
case radId_setName:
{
StructureAsyncCommand command;
command.Command = Structure_Command_RenameStructure;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"ADMIN",command);
}
break;
case radId_operateHarvester:
{
StructureAsyncCommand command;
command.Command = Structure_Command_OperateHarvester;
command.PlayerId = player->getId();
command.StructureId = this->getId();
gStructureManager->checkNameOnPermissionList(this->getId(),player->GetCreature()->getId(),player->GetCreature()->getFirstName(),"HOPPER",command);
}
break;
}
}
bool NpcManager::_verifyCombatState(CreatureObject* attacker, uint64 defenderId)
{
if (!attacker || !defenderId)
{
return false;
}
CreatureObject* defender = dynamic_cast<CreatureObject*>(gWorldManager->getObjectById(defenderId));
if (!defender)
{
return false;
}
// If the target (defender) do have me in his defender list, we should not bother.
/*
if (defender->checkDefenderList(attacker->getId()))
{
return true;
}
*/
PlayerObject* playerAttacker = dynamic_cast<PlayerObject*>(attacker);
// make sure we got both objects
if (playerAttacker && defender)
{
// 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->GetCreature()->isIncapacitated())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_incap");
return(false);
}
else if(defenderPlayer->GetCreature()->isDead())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_dead");
return(false);
}
// put us in combat state
if(!playerAttacker->GetCreature()->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(playerAttacker->GetCreature(),CreatureState_Combat);
gStateManager.setCurrentActionState(playerAttacker->GetCreature(),CreatureState_CombatAttitudeNormal);
}
// put our target in combat state
if(!defenderPlayer->GetCreature()->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_Combat);
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_CombatAttitudeNormal);
}
// update our defender list
if (!playerAttacker->GetCreature()->checkDefenderList(defenderPlayer->getId())) // or if (!playerAttacker->checkDefenderList(defenderId)
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
// update our targets defender list
if (!defenderPlayer->GetCreature()->checkDefenderList(playerAttacker->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->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 our 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->GetCreature()->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(playerAttacker->GetCreature(),CreatureState_Combat);
gStateManager.setCurrentActionState(playerAttacker->GetCreature(),CreatureState_CombatAttitudeNormal);
}
// put our target in combat state
if (!defender->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(defender,CreatureState_Combat);
gStateManager.setCurrentActionState(defender,CreatureState_CombatAttitudeNormal);
}
// update our defender list
if (!playerAttacker->GetCreature()->checkDefenderList(defender->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
// update our targets defender list
if (!defender->checkDefenderList(playerAttacker->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
}
return(true);
}
else if (AttackableCreature* attackerNpc = dynamic_cast<AttackableCreature*>(attacker))
{
// make sure we got both objects
if (attackerNpc && defender)
{
// Our target can be a player or another npc.
if (PlayerObject* defenderPlayer = dynamic_cast<PlayerObject*>(defender))
{
// The target (defender) is a player. Kill him!
if (defenderPlayer->GetCreature()->isIncapacitated())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_incap");
return(false);
}
else if(defenderPlayer->GetCreature()->isDead())
{
return(false);
}
/*
if (!defenderPlayer->checkPvPState(CreaturePvPStatus_Attackable))
{
// Player is not attackable
return(false);
}
*/
// put us in combat state
if (!attackerNpc->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(attackerNpc,CreatureState_Combat);
gStateManager.setCurrentActionState(attackerNpc,CreatureState_CombatAttitudeNormal);
}
// put our target in combat stance
if (!defenderPlayer->GetCreature()->states.checkState(CreatureState_Combat))
{
gMessageLib->sendUpdatePvpStatus(defenderPlayer->GetCreature(),defenderPlayer, defenderPlayer->GetCreature()->getPvPStatus() | CreaturePvPStatus_Attackable | CreaturePvPStatus_Aggressive); // | CreaturePvPStatus_Enemy);
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_Combat);
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_CombatAttitudeNormal);
}
// If the target (defender) is not on our list, update pvp-status.
if (!attackerNpc->checkDefenderList(defenderPlayer->getId()))
{
// May not be neeeded, since the pvp-status is changed when getting enough aggro.
// gMessageLib->sendUpdatePvpStatus(attackerNpc,defenderPlayer, attackerNpc->getPvPStatus() | CreaturePvPStatus_Attackable | CreaturePvPStatus_Aggressive | CreaturePvPStatus_Enemy);
// update our defender list
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
// Update player and all his group mates currently in range.
/*
PlayerList inRangeMembers = defenderPlayer->getInRangeGroupMembers(true);
PlayerList::iterator it = inRangeMembers.begin();
while (it != inRangeMembers.end())
{
PlayerObject* player = (*it);
// If player online, send emote.
if (player && player->isConnected())
{
MessageLib->sendUpdatePvpStatus(attackerNpc,player);
}
}
*/
}
// update our targets defender list
if (!defenderPlayer->GetCreature()->checkDefenderList(attackerNpc->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
// Player can/may start auto-attack if idle.
if (!defenderPlayer->autoAttackEnabled())
{
defenderPlayer->getController()->enqueueAutoAttack(attackerNpc->getId());
}
}
else if (dynamic_cast<AttackableCreature*>(defender))
{
// The target (defender) is a npc. Kill him!
// Here I think some validation would be great, don't wanna kill you piket-brother?
if (defenderPlayer->GetCreature()->isIncapacitated())
{
// gMessageLib->sendSystemMessage(playerAttacker,L"","base_player","prose_target_incap");
return(false);
}
else if(defenderPlayer->GetCreature()->isDead())
{
return(false);
}
// put us in combat state
if (!attackerNpc->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(attackerNpc,CreatureState_Combat);
gStateManager.setCurrentActionState(attackerNpc,CreatureState_CombatAttitudeNormal);
}
// put our target in combat state
if (!defenderPlayer->GetCreature()->states.checkState(CreatureState_Combat))
{
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_Combat);
gStateManager.setCurrentActionState(defenderPlayer->GetCreature(),CreatureState_CombatAttitudeNormal);
}
// update our defender list
if (!attackerNpc->checkDefenderList(defenderPlayer->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
// update our targets defender list
if (!defenderPlayer->GetCreature()->checkDefenderList(attackerNpc->getId()))
{
playerAttacker->GetCreature()->AddDefender(defenderPlayer->getId());
}
}
return(true);
}
return(false);
}
return false;
}
bool ArtisanManager::handleRequestSurvey(Object* playerObject,Object* target,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* player = dynamic_cast<PlayerObject*>(playerObject);
std::shared_ptr<SimpleEvent> start_survey_event = nullptr;
if(cmdProperties)
mSurveyMindCost = cmdProperties->mMindCost;
// don't allow survey in buildings
if(player->getParentId())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_in_structure"), player);
return false;
}
if(player->GetCreature()->getPerformingState() != PlayerPerformance_None)
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "wrong_state"), player);
return false;
}
if(player->getSurveyState())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_cant"), player);
return false;
}
if(player->getSamplingState())
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_sample"), player);
return false;
}
// checks if we are in combat, dead or incapacitated
if (player->GetCreature()->states.checkState(CreatureState_Combat) || player->GetCreature()->states.checkPosture(CreaturePosture_Dead) || player->GetCreature()->states.checkLocomotion(CreatureLocomotion_Incapacitated))
{
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "wrong_state"), player);
return false;
}
SurveyTool* tool = dynamic_cast<SurveyTool*>(target);
CurrentResource* resource = NULL;
BString resourceName;
message->getStringUnicode16(resourceName);
resourceName.convert(BSTRType_ANSI);
resource = reinterpret_cast<CurrentResource*>(gResourceManager->getResourceByNameCRC(resourceName.getCrc()));
if(tool && resource)
{
player->setSurveyState(true);
// play effect
std::string effect = gWorldManager->getClientEffect(tool->getInternalAttribute<uint32>("survey_effect"));
gMessageLib->sendPlayClientEffectLocMessage(effect,player->mPosition,player);
gContainerManager->sendToRegisteredWatchers(player, [effect, player] (PlayerObject* const recipient) {
gMessageLib->sendPlayClientEffectLocMessage(effect, player->mPosition, recipient);
});
auto ham = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::ham::HamService>("HamService");
uint32 survey_cost = mSurveyMindCost;
//are we able to sample in the first place ??
if(!ham->ApplyModifiedHamCosts(player->GetCreature(), 0, 0, survey_cost)) {
gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "sample_mind"), player);
//message for stop sampling
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "sample_cancel"), player);
player->getSampleData()->mPendingSurvey = false;
player->GetCreature()->updateMovementProperties();
return false;
}
// send system message
resourceName.convert(BSTRType_Unicode16);
gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "start_survey", L"", L"", resourceName.getUnicode16()), player);
// schedule execution
start_survey_event = std::make_shared<SimpleEvent>(EventType("start_survey"),0, 5000,
std::bind(&ArtisanManager::surveyEvent, this, player, resource, tool));
}
else
{
gMessageLib->SendSystemMessage(::common::OutOfBand("ui","survey_nothingfound"));
return false;
}
// notify any listeners
if (start_survey_event)
gEventDispatcher.Notify(start_survey_event);
return true;
}
